com.groupbyinc.common.apache.commons.collections4.FactoryUtils Maven / Gradle / Ivy
/*
* 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);
}
}