001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.collections; 018 019 import org.apache.commons.collections.functors.ConstantFactory; 020 import org.apache.commons.collections.functors.InstantiateFactory; 021 import org.apache.commons.collections.functors.ExceptionFactory; 022 import org.apache.commons.collections.functors.PrototypeFactory; 023 024 /** 025 * <code>FactoryUtils</code> provides reference implementations and utilities 026 * for the Factory functor interface. The supplied factories are: 027 * <ul> 028 * <li>Prototype - clones a specified object 029 * <li>Reflection - creates objects using reflection 030 * <li>Constant - always returns the same object 031 * <li>Null - always returns null 032 * <li>Exception - always throws an exception 033 * </ul> 034 * All the supplied factories are Serializable. 035 * 036 * @since Commons Collections 3.0 037 * @version $Revision: 646777 $ $Date: 2008-04-10 13:33:15 +0100 (Thu, 10 Apr 2008) $ 038 * 039 * @author Stephen Colebourne 040 */ 041 public class FactoryUtils { 042 043 /** 044 * This class is not normally instantiated. 045 */ 046 public FactoryUtils() { 047 super(); 048 } 049 050 /** 051 * Gets a Factory that always throws an exception. 052 * This could be useful during testing as a placeholder. 053 * 054 * @see org.apache.commons.collections.functors.ExceptionFactory 055 * 056 * @return the factory 057 */ 058 public static Factory exceptionFactory() { 059 return ExceptionFactory.INSTANCE; 060 } 061 062 /** 063 * Gets a Factory that will return null each time the factory is used. 064 * This could be useful during testing as a placeholder. 065 * 066 * @see org.apache.commons.collections.functors.ConstantFactory 067 * 068 * @return the factory 069 */ 070 public static Factory nullFactory() { 071 return ConstantFactory.NULL_INSTANCE; 072 } 073 074 /** 075 * Creates a Factory that will return the same object each time the factory 076 * is used. No check is made that the object is immutable. In general, only 077 * immutable objects should use the constant factory. Mutable objects should 078 * use the prototype factory. 079 * 080 * @see org.apache.commons.collections.functors.ConstantFactory 081 * 082 * @param constantToReturn the constant object to return each time in the factory 083 * @return the <code>constant</code> factory. 084 */ 085 public static Factory constantFactory(Object constantToReturn) { 086 return ConstantFactory.getInstance(constantToReturn); 087 } 088 089 /** 090 * Creates a Factory that will return a clone of the same prototype object 091 * each time the factory is used. The prototype will be cloned using one of these 092 * techniques (in order): 093 * <ul> 094 * <li>public clone method 095 * <li>public copy constructor 096 * <li>serialization clone 097 * <ul> 098 * 099 * @see org.apache.commons.collections.functors.PrototypeFactory 100 * 101 * @param prototype the object to clone each time in the factory 102 * @return the <code>prototype</code> factory 103 * @throws IllegalArgumentException if the prototype is null 104 * @throws IllegalArgumentException if the prototype cannot be cloned 105 */ 106 public static Factory prototypeFactory(Object prototype) { 107 return PrototypeFactory.getInstance(prototype); 108 } 109 110 /** 111 * Creates a Factory that can create objects of a specific type using 112 * a no-args constructor. 113 * 114 * @see org.apache.commons.collections.functors.InstantiateFactory 115 * 116 * @param classToInstantiate the Class to instantiate each time in the factory 117 * @return the <code>reflection</code> factory 118 * @throws IllegalArgumentException if the classToInstantiate is null 119 */ 120 public static Factory instantiateFactory(Class classToInstantiate) { 121 return InstantiateFactory.getInstance(classToInstantiate, null, null); 122 } 123 124 /** 125 * Creates a Factory that can create objects of a specific type using 126 * the arguments specified to this method. 127 * 128 * @see org.apache.commons.collections.functors.InstantiateFactory 129 * 130 * @param classToInstantiate the Class to instantiate each time in the factory 131 * @param paramTypes parameter types for the constructor, can be null 132 * @param args the arguments to pass to the constructor, can be null 133 * @return the <code>reflection</code> factory 134 * @throws IllegalArgumentException if the classToInstantiate is null 135 * @throws IllegalArgumentException if the paramTypes and args don't match 136 * @throws IllegalArgumentException if the constructor doesn't exist 137 */ 138 public static Factory instantiateFactory(Class classToInstantiate, Class[] paramTypes, Object[] args) { 139 return InstantiateFactory.getInstance(classToInstantiate, paramTypes, args); 140 } 141 142 }