PodamFactoryImpl (podam 7.0.4.RELEASE API)

java.lang.Object
- uk.co.jemos.podam.api.PodamFactoryImpl

All Implemented Interfaces:: PodamFactory

@NotThreadSafe
 @Immutable
public class PodamFactoryImpl
extends Object
implements PodamFactory

The PODAM factory implementation

Since:: 1.0.0
Author:: mtedone

Field Summary

Fields
Modifier and Type	Field and Description
`private ClassInfoStrategy`	`classInfoStrategy` The strategy to use to introspect data.
`private PodamFactory`	`externalFactory` External factory to delegate production this factory cannot handle
`private static org.slf4j.Logger`	`LOG` Application logger
`private static String`	`MAP_CREATION_EXCEPTION_STR`
`private static Map<String,Type>`	`NULL_TYPE_ARGS_MAP` Empty type map
`private static String`	`RESOLVING_COLLECTION_EXCEPTION_STR`
`private DataProviderStrategy`	`strategy` The strategy to use to fill data.

Constructor Summary

Constructors
Constructor and Description
`PodamFactoryImpl()` Default constructor.
`PodamFactoryImpl(DataProviderStrategy strategy)` Constructor with non-default strategy
`PodamFactoryImpl(PodamFactory externalFactory)` Constructor with non-default external factory
`PodamFactoryImpl(PodamFactory externalFactory, DataProviderStrategy strategy)` Full constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private <T> T`	`doManufacturePojo(Class<T> pojoClass, ManufacturingContext manufacturingCtx, Type... genericTypeArgs)` Manufactures and populates the pojo class
`private void`	`fillCollection(ManufacturingContext manufacturingCtx, List<Annotation> annotations, String attributeName, Collection<? super Object> collection, Class<?> collectionElementType, Type... genericTypeArgs)` It fills a collection with the required number of elements of the required type.
`private void`	`fillMap(MapArguments mapArguments, ManufacturingContext manufacturingCtx)` It fills a Map with the required number of elements of the required type.
`private Class<?>`	`findInheretedCollectionElementType(Collection<Object> collection, ManufacturingContext manufacturingCtx, AtomicReference<Type[]> elementGenericTypeArgs, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` Tries to find collection element type from collection object
`private MapArguments`	`findInheretedMapElementType(Map<Object,Object> map, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` Finds key and element type arguments
`ClassInfoStrategy`	`getClassStrategy()` It returns the class info strategy for this factory.
`PodamFactory`	`getExternalFactory()` It returns the external factory assigned to this factory.
`private Object`	`getMapKeyOrElementValue(MapKeyOrElementsArguments keyOrElementsArguments, ManufacturingContext manufacturingCtx)` It fills a Map key or value with the appropriate value, considering attribute-level customisation.
`private Object[]`	`getParameterValuesForConstructor(Constructor<?> constructor, Class<?> pojoClass, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` Given a constructor it manufactures and returns the parameter values required to invoke it
`private Object[]`	`getParameterValuesForMethod(Method method, Class<?> pojoClass, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` Given a method it manufactures and returns the parameter values required to invoke it
`DataProviderStrategy`	`getStrategy()` It returns the strategy for this factory.
`private <T> T`	`getValueForAbstractType(Class<T> pojoClass, AttributeMetadata pojoMetadata, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type[] genericTypeArgs)` Returns a value for an abstract type or interface if possible.
`private <T> T`	`instantiatePojo(Class<T> pojoClass, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It creates and returns an instance of the given class if at least one of its constructors has been annotated with `PodamConstructor`
`private <T> T`	`instantiatePojoWithFactory(Class<?> factoryClass, Class<T> pojoClass, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It attempts to create an instance of the given class with a static method of the factory
`private Object`	`manufactureAttributeValue(Object pojo, ManufacturingContext manufacturingCtx, Class<?> attributeType, Type genericAttributeType, List<Annotation> annotations, String attributeName, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It manufactures and returns the value for a POJO attribute.
`private Object`	`manufactureParameterValue(Class<?> pojoClass, String parameterName, Class<?> parameterType, Type genericType, List<Annotation> annotations, Map<String,Type> typeArgsMap, ManufacturingContext manufacturingCtx, Type... genericTypeArgs)` Manufactures and returns the parameter value for method required to invoke it
`<T> T`	`manufacturePojo(Class<T> pojoClass, Type... genericTypeArgs)` Generic method which returns an instance of the given class filled with dummy values, using the default data provider strategy.
`private <T> T`	`manufacturePojoInternal(Class<T> pojoClass, AttributeMetadata pojoMetadata, ManufacturingContext manufacturingCtx, Type... genericTypeArgs)` Generic method which returns an instance of the given class filled with values dictated by the strategy
`<T> T`	`manufacturePojoWithFullData(Class<T> pojoClass, Type... genericTypeArgs)` Generic method which returns an instance of the given class filled with dummy values, using the default data provider strategy.
`<T> T`	`populatePojo(T pojo, Type... genericTypeArgs)` Generic method which populates an instance of the given class with dummy values, using the default data provider strategy.
`private <T> T`	`populatePojoInternal(T pojo, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` Fills given class filled with values dictated by the strategy
`private Object`	`resolveArrayElementValue(Object pojo, ManufacturingContext manufacturingCtx, AttributeMetadata attributeMetadata, Map<String,Type> typeArgsMap)` It returns an Array with the first element set
`private Collection<? super Object>`	`resolveCollectionValueWhenCollectionIsPojoAttribute(Object pojo, ManufacturingContext manufacturingCtx, AttributeMetadata attributeMetadata, Map<String,Type> typeArgsMap)` It returns a collection of some sort with some data in it.
`private Map<? super Object,? super Object>`	`resolveMapValueWhenMapIsPojoAttribute(Object pojo, ManufacturingContext manufacturingCtx, AttributeMetadata attributeMetadata, Map<String,Type> typeArgsMap)` It manufactures and returns a Map with at least one element in it
`private <T> T`	`resortToExternalFactory(ManufacturingContext manufacturingCtx, String msg, Class<T> pojoClass, Type... genericTypeArgs)` Delegates POJO manufacturing to an external factory
`PodamFactory`	`setClassStrategy(ClassInfoStrategy classInfoStrategy)` Sets the class info strategy for this factory
`PodamFactory`	`setExternalFactory(PodamFactory externalFactory)` Sets an external factory for this factory to delegate requests it cannot process
`PodamFactory`	`setStrategy(DataProviderStrategy strategy)` Sets the data provider strategy for this factory

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - RESOLVING_COLLECTION_EXCEPTION_STR
```
private static final String RESOLVING_COLLECTION_EXCEPTION_STR
```
    See Also:
    
    Constant Field Values
  - MAP_CREATION_EXCEPTION_STR
```
private static final String MAP_CREATION_EXCEPTION_STR
```
    See Also:
    
    Constant Field Values
  - LOG
```
private static final org.slf4j.Logger LOG
```
    Application logger
  - NULL_TYPE_ARGS_MAP
```
private static final Map<String,Type> NULL_TYPE_ARGS_MAP
```
    Empty type map
  - externalFactory
```
private PodamFactory externalFactory
```
    External factory to delegate production this factory cannot handle
    The default is NullExternalFactory.
  - strategy
```
private DataProviderStrategy strategy
```
    The strategy to use to fill data.
    The default is RandomDataProviderStrategyImpl.
  - classInfoStrategy
```
private ClassInfoStrategy classInfoStrategy
```
    The strategy to use to introspect data.
    The default is DefaultClassInfoStrategy.
- Constructor Detail
  - PodamFactoryImpl
```
public PodamFactoryImpl()
```
    Default constructor.
  - PodamFactoryImpl
```
public PodamFactoryImpl(DataProviderStrategy strategy)
```
    Constructor with non-default strategy
    
    Parameters:
    
    strategy - The strategy to use to fill data
  - PodamFactoryImpl
```
public PodamFactoryImpl(PodamFactory externalFactory)
```
    Constructor with non-default external factory
    
    Parameters:
    
    externalFactory - External factory to delegate production this factory cannot handle
  - PodamFactoryImpl
```
public PodamFactoryImpl(PodamFactory externalFactory,
                        DataProviderStrategy strategy)
```
    Full constructor.
    
    Parameters:
    
    externalFactory - External factory to delegate production this factory cannot handle
    
    strategy - The strategy to use to fill data
- Method Detail
  - manufacturePojoWithFullData
```
public <T> T manufacturePojoWithFullData(Class<T> pojoClass,
                                         Type... genericTypeArgs)
```
    Generic method which returns an instance of the given class filled with dummy values, using the default data provider strategy. In order to instantiate class, constructor with the most parameters is used.
    This method uses RandomDataProviderStrategyImpl as the default implementation.
    
    Specified by:
    
    manufacturePojoWithFullData in interface PodamFactory
    
    Type Parameters:
    
    T - The type for which a filled instance is required
    
    Parameters:
    
    pojoClass - The name of the class for which an instance filled with values is required
    
    genericTypeArgs - The generic Type arguments for a generic class instance
    
    Returns:
    
    An instance of <T> filled with dummy values
  - manufacturePojo
```
public <T> T manufacturePojo(Class<T> pojoClass,
                             Type... genericTypeArgs)
```
    Generic method which returns an instance of the given class filled with dummy values, using the default data provider strategy.
    This method uses RandomDataProviderStrategyImpl as the default implementation.
    
    Specified by:
    
    manufacturePojo in interface PodamFactory
    
    Type Parameters:
    
    T - The type for which a filled instance is required
    
    Parameters:
    
    pojoClass - The name of the class for which an instance filled with values is required
    
    genericTypeArgs - The generic Type arguments for a generic class instance
    
    Returns:
    
    An instance of <T> filled with dummy values
  - populatePojo
```
public <T> T populatePojo(T pojo,
                          Type... genericTypeArgs)
```
    Generic method which populates an instance of the given class with dummy values, using the default data provider strategy.
    This method uses RandomDataProviderStrategyImpl as the default implementation.
    
    Specified by:
    
    populatePojo in interface PodamFactory
    
    Type Parameters:
    
    T - The type for which a filled instance is required
    
    Parameters:
    
    pojo - The instance to be filled with values
    
    genericTypeArgs - The generic Type arguments for a generic class instance
    
    Returns:
    
    The same instance of object for chaining
  - getStrategy
```
public DataProviderStrategy getStrategy()
```
    It returns the strategy for this factory.
    
    Specified by:
    
    getStrategy in interface PodamFactory
    
    Returns:
    
    the strategy
  - setStrategy
```
public PodamFactory setStrategy(DataProviderStrategy strategy)
```
    Sets the data provider strategy for this factory
    
    Specified by:
    
    setStrategy in interface PodamFactory
    
    Parameters:
    
    strategy - A data provider strategy to be used by this factory
    
    Returns:
    
    instance of the factory for chaining
  - getClassStrategy
```
public ClassInfoStrategy getClassStrategy()
```
    It returns the class info strategy for this factory.
    
    Specified by:
    
    getClassStrategy in interface PodamFactory
    
    Returns:
    
    the class info strategy for this factory
  - setClassStrategy
```
public PodamFactory setClassStrategy(ClassInfoStrategy classInfoStrategy)
```
    Sets the class info strategy for this factory
    
    Specified by:
    
    setClassStrategy in interface PodamFactory
    
    Parameters:
    
    classInfoStrategy - A class info strategy to be used by this factory
    
    Returns:
    
    instance of the factory for chaining
  - getExternalFactory
```
public PodamFactory getExternalFactory()
```
    It returns the external factory assigned to this factory.
    
    Specified by:
    
    getExternalFactory in interface PodamFactory
    
    Returns:
    
    the strategy
  - setExternalFactory
```
public PodamFactory setExternalFactory(PodamFactory externalFactory)
```
    Sets an external factory for this factory to delegate requests it cannot process
    
    Specified by:
    
    setExternalFactory in interface PodamFactory
    
    Parameters:
    
    externalFactory - An external factory to be used by this factory
    
    Returns:
    
    instance of this factory for chaining
  - instantiatePojoWithFactory
```
private <T> T instantiatePojoWithFactory(Class<?> factoryClass,
                                         Class<T> pojoClass,
                                         ManufacturingContext manufacturingCtx,
                                         Map<String,Type> typeArgsMap,
                                         Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         ClassNotFoundException
```
    It attempts to create an instance of the given class with a static method of the factory
    This method attempts to instantiate POJO with a static method of provided factory, for example, getInstance().
    
    Type Parameters:
    
    T - The type of Pojo class
    
    Parameters:
    
    factoryClass - The factory class, which will be used for POJO instantiation
    
    pojoClass - The name of the class for which an instance filled with values
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    An instance of the given class
    
    Throws:
    
    IllegalArgumentException - If an illegal argument was passed to the constructor
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - instantiatePojo
```
private <T> T instantiatePojo(Class<T> pojoClass,
                              ManufacturingContext manufacturingCtx,
                              Map<String,Type> typeArgsMap,
                              Type... genericTypeArgs)
                       throws SecurityException
```
    It creates and returns an instance of the given class if at least one of its constructors has been annotated with PodamConstructor
    
    Type Parameters:
    
    T - The type of the instance to return
    
    Parameters:
    
    pojoClass - The class of which an instance is required
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    an instance of the given class if at least one of its constructors has been annotated with PodamConstructor
    
    Throws:
    
    SecurityException - If an security was violated
  - doManufacturePojo
```
private <T> T doManufacturePojo(Class<T> pojoClass,
                                ManufacturingContext manufacturingCtx,
                                Type... genericTypeArgs)
```
    Manufactures and populates the pojo class
    
    Type Parameters:
    
    T - The type of the instance to return
    
    Parameters:
    
    pojoClass - the class to instantiate
    
    manufacturingCtx - the initialized manufacturing context
    
    genericTypeArgs - generic arguments for the pojo class
    
    Returns:
    
    instance of @pojoClass or null in case it cannot be instantiated
  - manufacturePojoInternal
```
private <T> T manufacturePojoInternal(Class<T> pojoClass,
                                      AttributeMetadata pojoMetadata,
                                      ManufacturingContext manufacturingCtx,
                                      Type... genericTypeArgs)
                               throws InstantiationException,
                                      IllegalAccessException,
                                      InvocationTargetException,
                                      ClassNotFoundException
```
    Generic method which returns an instance of the given class filled with values dictated by the strategy
    
    Type Parameters:
    
    T - The type for which a filled instance is required
    
    Parameters:
    
    pojoClass - The name of the class for which an instance filled with values is required
    
    pojoMetadata - attribute metadata for POJOs produced recursively
    
    manufacturingCtx - the manufacturing context
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    An instance of <T> filled with dummy values
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If manufactured class cannot be loaded
    
    PodamMockeryException - if a problem occurred while creating a POJO instance or while setting its state
  - populatePojoInternal
```
private <T> T populatePojoInternal(T pojo,
                                   ManufacturingContext manufacturingCtx,
                                   Map<String,Type> typeArgsMap,
                                   Type... genericTypeArgs)
                            throws InstantiationException,
                                   IllegalAccessException,
                                   InvocationTargetException,
                                   ClassNotFoundException
```
    Fills given class filled with values dictated by the strategy
    
    Type Parameters:
    
    T - The type for which should be populated
    
    Parameters:
    
    pojo - An instance to be filled with dummy values
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    An instance of <T> filled with dummy values
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If manufactured class cannot be loaded
  - manufactureAttributeValue
```
private Object manufactureAttributeValue(Object pojo,
                                         ManufacturingContext manufacturingCtx,
                                         Class<?> attributeType,
                                         Type genericAttributeType,
                                         List<Annotation> annotations,
                                         String attributeName,
                                         Map<String,Type> typeArgsMap,
                                         Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         ClassNotFoundException
```
    It manufactures and returns the value for a POJO attribute.
    Parameters:
    
    pojo - The POJO being filled with values
    
    manufacturingCtx - the manufacturing context
    
    attributeType - The type of the attribute for which a value is being manufactured
    
    genericAttributeType - The generic type of the attribute for which a value is being manufactured
    
    annotations - The annotations for the attribute being considered
    
    attributeName - The attribute name
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    The value for an attribute
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    IllegalArgumentException -
    
    If an illegal argument was passed
    
    If an invalid value was set for a precise value in an annotation and such value could not be converted to the desired type
    ClassNotFoundException - If class being manufactured cannot be loaded
  - resortToExternalFactory
```
private <T> T resortToExternalFactory(ManufacturingContext manufacturingCtx,
                                      String msg,
                                      Class<T> pojoClass,
                                      Type... genericTypeArgs)
```
    Delegates POJO manufacturing to an external factory
    
    Type Parameters:
    
    T - The type of the instance to return
    
    Parameters:
    
    manufacturingCtx - the manufacturing context
    
    msg - Message to log, must contain two parameters
    
    pojoClass - The class of which an instance is required
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    instance of POJO produced by external factory or null
  - resolveCollectionValueWhenCollectionIsPojoAttribute
```
private Collection<? super Object> resolveCollectionValueWhenCollectionIsPojoAttribute(Object pojo,
                                                                                       ManufacturingContext manufacturingCtx,
                                                                                       AttributeMetadata attributeMetadata,
                                                                                       Map<String,Type> typeArgsMap)
```
    It returns a collection of some sort with some data in it.
    
    Parameters:
    
    pojo - The POJO being analyzed
    
    manufacturingCtx - the manufacturing context
    
    attributeMetadata - The attribute's metadata
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    Returns:
    
    a collection of some sort with some data in it
    
    Throws:
    
    PodamMockeryException - An exception occurred while resolving the collection
    
    IllegalArgumentException - If the field name is null or empty
  - findInheretedCollectionElementType
```
private Class<?> findInheretedCollectionElementType(Collection<Object> collection,
                                                    ManufacturingContext manufacturingCtx,
                                                    AtomicReference<Type[]> elementGenericTypeArgs,
                                                    Map<String,Type> typeArgsMap,
                                                    Type... genericTypeArgs)
```
    Tries to find collection element type from collection object
    
    Parameters:
    
    collection - The collection to be filled
    
    manufacturingCtx - the manufacturing context
    
    elementGenericTypeArgs - parameter to return generic arguments of collection element
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    class type of collection element
  - fillCollection
```
private void fillCollection(ManufacturingContext manufacturingCtx,
                            List<Annotation> annotations,
                            String attributeName,
                            Collection<? super Object> collection,
                            Class<?> collectionElementType,
                            Type... genericTypeArgs)
                     throws InstantiationException,
                            IllegalAccessException,
                            InvocationTargetException,
                            ClassNotFoundException
```
    It fills a collection with the required number of elements of the required type.
    This method has a so-called side effect. It updates the collection passed as argument.
    
    Parameters:
    
    manufacturingCtx - the manufacturing context
    
    annotations - The annotations for this attribute
    
    attributeName - The attribute name of collection in enclosing POJO class
    
    collection - The Collection to be filled
    
    collectionElementType - The type of the collection element
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - resolveMapValueWhenMapIsPojoAttribute
```
private Map<? super Object,? super Object> resolveMapValueWhenMapIsPojoAttribute(Object pojo,
                                                                                 ManufacturingContext manufacturingCtx,
                                                                                 AttributeMetadata attributeMetadata,
                                                                                 Map<String,Type> typeArgsMap)
```
    It manufactures and returns a Map with at least one element in it
    Parameters:
    
    pojo - The POJO being initialized
    
    manufacturingCtx - the manufacturing context
    
    attributeMetadata - The attribute's metadata
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    Returns:
    
    Map with at least one element in it
    
    Throws:
    IllegalArgumentException -
    
    If the attribute name is null or empty
    
    If the array of types of the Map has length different from 2
    PodamMockeryException - If an error occurred while creating the Map object
  - findInheretedMapElementType
```
private MapArguments findInheretedMapElementType(Map<Object,Object> map,
                                                 ManufacturingContext manufacturingCtx,
                                                 Map<String,Type> typeArgsMap,
                                                 Type... genericTypeArgs)
```
    Finds key and element type arguments
    
    Parameters:
    
    map - The map being initialized
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    Inherited map key and element types
  - fillMap
```
private void fillMap(MapArguments mapArguments,
                     ManufacturingContext manufacturingCtx)
              throws InstantiationException,
                     IllegalAccessException,
                     InvocationTargetException,
                     ClassNotFoundException
```
    It fills a Map with the required number of elements of the required type.
    This method has a so-called side-effect. It updates the Map given as argument.
    
    Parameters:
    
    mapArguments - The arguments POJO
    
    manufacturingCtx - Manufacturing context
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - getMapKeyOrElementValue
```
private Object getMapKeyOrElementValue(MapKeyOrElementsArguments keyOrElementsArguments,
                                       ManufacturingContext manufacturingCtx)
                                throws InstantiationException,
                                       IllegalAccessException,
                                       InvocationTargetException,
                                       ClassNotFoundException
```
    It fills a Map key or value with the appropriate value, considering attribute-level customisation.
    Parameters:
    
    keyOrElementsArguments - The arguments POJO
    
    manufacturingCtx - manufacturing context
    
    Returns:
    
    A Map key or value
    
    Throws:
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    IllegalArgumentException -
    
    If an illegal argument was passed
    
    If an invalid value was set for a precise value in an annotation and such value could not be converted to the desired type
    ClassNotFoundException - If manufactured class could not be loaded
  - resolveArrayElementValue
```
private Object resolveArrayElementValue(Object pojo,
                                        ManufacturingContext manufacturingCtx,
                                        AttributeMetadata attributeMetadata,
                                        Map<String,Type> typeArgsMap)
                                 throws InstantiationException,
                                        IllegalAccessException,
                                        InvocationTargetException,
                                        ClassNotFoundException
```
    It returns an Array with the first element set
    
    Parameters:
    
    pojo - POJO containing attribute
    
    manufacturingCtx - the manufacturing context
    
    attributeMetadata - The attribute's metadata
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    Returns:
    
    Array with the first element set
    
    Throws:
    
    IllegalArgumentException - If an illegal argument was passed to the constructor
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - getParameterValuesForConstructor
```
private Object[] getParameterValuesForConstructor(Constructor<?> constructor,
                                                  Class<?> pojoClass,
                                                  ManufacturingContext manufacturingCtx,
                                                  Map<String,Type> typeArgsMap,
                                                  Type... genericTypeArgs)
                                           throws InstantiationException,
                                                  IllegalAccessException,
                                                  InvocationTargetException,
                                                  ClassNotFoundException
```
    Given a constructor it manufactures and returns the parameter values required to invoke it
    
    Parameters:
    
    constructor - The constructor for which parameter values are required
    
    pojoClass - The POJO class containing the constructor
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    The parameter values required to invoke the constructor
    
    Throws:
    
    IllegalArgumentException - If an illegal argument was passed to the constructor
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - getParameterValuesForMethod
```
private Object[] getParameterValuesForMethod(Method method,
                                             Class<?> pojoClass,
                                             ManufacturingContext manufacturingCtx,
                                             Map<String,Type> typeArgsMap,
                                             Type... genericTypeArgs)
                                      throws InstantiationException,
                                             IllegalAccessException,
                                             InvocationTargetException,
                                             ClassNotFoundException
```
    Given a method it manufactures and returns the parameter values required to invoke it
    
    Parameters:
    
    method - The method for which parameter values are required
    
    pojoClass - The POJO class containing the constructor
    
    manufacturingCtx - the manufacturing context
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    The parameter values required to invoke the method
    
    Throws:
    
    IllegalArgumentException - If an illegal argument was passed to the method
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - manufactureParameterValue
```
private Object manufactureParameterValue(Class<?> pojoClass,
                                         String parameterName,
                                         Class<?> parameterType,
                                         Type genericType,
                                         List<Annotation> annotations,
                                         Map<String,Type> typeArgsMap,
                                         ManufacturingContext manufacturingCtx,
                                         Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         ClassNotFoundException
```
    Manufactures and returns the parameter value for method required to invoke it
    
    Parameters:
    
    pojoClass - pojo class
    
    parameterName - name of parameter
    
    parameterType - type of parameter
    
    genericType - generic type of parameter
    
    annotations - parameter annotations
    
    typeArgsMap - map for resolving generic types
    
    manufacturingCtx - the manufacturing context
    
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    
    The parameter values required to invoke the constructor
    
    Throws:
    
    IllegalArgumentException - If an illegal argument was passed to the constructor
    
    InstantiationException - If an exception occurred during instantiation
    
    IllegalAccessException - If security was violated while creating the object
    
    InvocationTargetException - If an exception occurred while invoking the constructor or factory method
    
    ClassNotFoundException - If it was not possible to create a class from a string
  - getValueForAbstractType
```
private <T> T getValueForAbstractType(Class<T> pojoClass,
                                      AttributeMetadata pojoMetadata,
                                      ManufacturingContext manufacturingCtx,
                                      Map<String,Type> typeArgsMap,
                                      Type[] genericTypeArgs)
                               throws InstantiationException,
                                      IllegalAccessException,
                                      InvocationTargetException,
                                      ClassNotFoundException
```
    Returns a value for an abstract type or interface if possible.
    
    Type Parameters:
    
    T - The type of the value to be returned
    
    Parameters:
    
    pojoClass - The Pojo class
    
    pojoMetadata - The Pojo metadata
    
    manufacturingCtx - The manufacturing context
    
    genericTypeArgs - The generic type arguments map
    
    typeArgsMap - a map relating the generic class arguments ("<T, V>" for example) with their actual types
    
    Returns:
    
    a value or null, if manufacturing didn't succeed
    
    Throws:
    
    InstantiationException - If a problem occurred while instantiating the object
    
    IllegalAccessException - If a problem occurred while instantiating the object
    
    InvocationTargetException - If a problem occurred while instantiating the object
    
    ClassNotFoundException - If a problem occurred while instantiating the object

Class PodamFactoryImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

RESOLVING_COLLECTION_EXCEPTION_STR

MAP_CREATION_EXCEPTION_STR

LOG

NULL_TYPE_ARGS_MAP

externalFactory

strategy

classInfoStrategy

Constructor Detail

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

Method Detail

manufacturePojoWithFullData

manufacturePojo

populatePojo

getStrategy

setStrategy

getClassStrategy

setClassStrategy

getExternalFactory

setExternalFactory

instantiatePojoWithFactory

instantiatePojo

doManufacturePojo

manufacturePojoInternal

populatePojoInternal

manufactureAttributeValue

resortToExternalFactory

resolveCollectionValueWhenCollectionIsPojoAttribute

findInheretedCollectionElementType

fillCollection

resolveMapValueWhenMapIsPojoAttribute

findInheretedMapElementType

fillMap

getMapKeyOrElementValue

resolveArrayElementValue

getParameterValuesForConstructor

getParameterValuesForMethod

manufactureParameterValue

getValueForAbstractType