com.groupbyinc.common.apache.commons.collections4.FactoryUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-test Show documentation
${project.name}
The newest version!
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.collections4;

import org.apache.commons.collections4.functors.ConstantFactory;
import org.apache.commons.collections4.functors.ExceptionFactory;
import org.apache.commons.collections4.functors.InstantiateFactory;
import org.apache.commons.collections4.functors.PrototypeFactory;

/**
 * FactoryUtils provides reference implementations and utilities
 * for the Factory functor interface. The supplied factories are:
 * 
 * Prototype - clones a specified object
 * 
Instantiate - creates objects using reflection
 * 
Constant - always returns the same object
 * 
Null - always returns null
 * 
Exception - always throws an exception
 * 
 * 
 * Since v4.1 only factories which are considered to be unsafe are
 * Serializable. Factories considered to be unsafe for serialization are:
 * 

 * Prototype
 * 
Instantiate
 * 
 *
 * @since 3.0
 * @version $Id: FactoryUtils.java 1714362 2015-11-14 20:38:02Z tn $
 */
public class FactoryUtils {

    /**
     * This class is not normally instantiated.
     */
    private FactoryUtils() {}

    /**
     * Gets a Factory that always throws an exception.
     * This could be useful during testing as a placeholder.
     *
     * @see org.apache.commons.collections4.functors.ExceptionFactory
     *
     * @param  the type that the factory creates
     * @return the factory
     */
    public static  Factory exceptionFactory() {
        return ExceptionFactory.exceptionFactory();
    }

    /**
     * Gets a Factory that will return null each time the factory is used.
     * This could be useful during testing as a placeholder.
     *
     * @see org.apache.commons.collections4.functors.ConstantFactory
     * @param  the "type" of null object the factory should return.
     * @return the factory
     */
    public static  Factory nullFactory() {
        return ConstantFactory.constantFactory(null);
    }

    /**
     * Creates a Factory that will return the same object each time the factory
     * is used. No check is made that the object is immutable. In general, only
     * immutable objects should use the constant factory. Mutable objects should
     * use the prototype factory.
     *
     * @see org.apache.commons.collections4.functors.ConstantFactory
     *
     * @param  the type that the factory creates
     * @param constantToReturn  the constant object to return each time in the factory
     * @return the constant factory.
     */
    public static  Factory constantFactory(final T constantToReturn) {
        return ConstantFactory.constantFactory(constantToReturn);
    }

    /**
     * Creates a Factory that will return a clone of the same prototype object
     * each time the factory is used. The prototype will be cloned using one of these
     * techniques (in order):
     * 
     * public clone method
     * 
public copy constructor
     * serialization clone
     * 
     *
     * @see org.apache.commons.collections4.functors.PrototypeFactory
     *
     * @param  the type that the factory creates
     * @param prototype  the object to clone each time in the factory
     * @return the prototype factory, or a {@link ConstantFactory#NULL_INSTANCE} if
     * the {@code prototype} is {@code null}
     * @throws IllegalArgumentException if the prototype cannot be cloned
     */
    public static  Factory prototypeFactory(final T prototype) {
        return PrototypeFactory.prototypeFactory(prototype);
    }

    /**
     * Creates a Factory that can create objects of a specific type using
     * a no-args constructor.
     *
     * @see org.apache.commons.collections4.functors.InstantiateFactory
     *
     * @param  the type that the factory creates
     * @param classToInstantiate  the Class to instantiate each time in the factory
     * @return the reflection factory
     * @throws NullPointerException if the classToInstantiate is null
     */
    public static  Factory instantiateFactory(final Class classToInstantiate) {
        return InstantiateFactory.instantiateFactory(classToInstantiate, null, null);
    }

    /**
     * Creates a Factory that can create objects of a specific type using
     * the arguments specified to this method.
     *
     * @see org.apache.commons.collections4.functors.InstantiateFactory
     *
     * @param  the type that the factory creates
     * @param classToInstantiate  the Class to instantiate each time in the factory
     * @param paramTypes  parameter types for the constructor, can be null
     * @param args  the arguments to pass to the constructor, can be null
     * @return the reflection factory
     * @throws NullPointerException if the classToInstantiate is null
     * @throws IllegalArgumentException if the paramTypes and args don't match
     * @throws IllegalArgumentException if the constructor doesn't exist
     */
    public static  Factory instantiateFactory(final Class classToInstantiate, final Class[] paramTypes,
                                                    final Object[] args) {
        return InstantiateFactory.instantiateFactory(classToInstantiate, paramTypes, args);
    }

}