PodamFactoryImpl (podam 6.0.2.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 org.springframework.context.support.AbstractApplicationContext`	`applicationContext`
`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 org.springframework.messaging.MessageChannel`	`messageChannel` The message channel where to send/receive the type request
`private static String`	`RESOLVING_COLLECTION_EXCEPTION_STR`
`private DataProviderStrategy`	`strategy` The strategy to use to fill data.
`private static String`	`UNCHECKED_STR`

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 void`	`fillCollection(Collection<? super Object> collection, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It fills a collection with the required number of elements of the required type.
`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(Map<? super Object,? super Object> map, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It fills a Map 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.
`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, 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 Object`	`instantiatePojoWithoutConstructors(Class<?> pojoClass, ManufacturingContext manufacturingCtx, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It attempts to create an instance of the given class
`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, 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(Class<?> attributeType, Type genericType, String attributeName, ManufacturingContext manufacturingCtx, List<Annotation> annotations, Object pojo, Map<String,Type> typeArgsMap)` It returns an Array with the first element set
`private Collection<? super Object>`	`resolveCollectionValueWhenCollectionIsPojoAttribute(Object pojo, ManufacturingContext manufacturingCtx, Class<?> collectionType, String attributeName, List<Annotation> annotations, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It returns a collection of some sort with some data in it.
`private Map<? super Object,? super Object>`	`resolveMapValueWhenMapIsPojoAttribute(Object pojo, ManufacturingContext manufacturingCtx, Class<?> attributeType, String attributeName, List<Annotation> annotations, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` 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
  - UNCHECKED_STR
```
private static final String UNCHECKED_STR
```
    See Also:
    
    Constant Field Values
  - messageChannel
```
private static org.springframework.messaging.MessageChannel messageChannel
```
    The message channel where to send/receive the type request
  - LOG
```
private static final org.slf4j.Logger LOG
```
    Application logger
  - applicationContext
```
private org.springframework.context.support.AbstractApplicationContext applicationContext
```
  - 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
  - instantiatePojoWithoutConstructors
```
private Object instantiatePojoWithoutConstructors(Class<?> pojoClass,
                                                  ManufacturingContext manufacturingCtx,
                                                  Map<String,Type> typeArgsMap,
                                                  Type... genericTypeArgs)
                                           throws InstantiationException,
                                                  IllegalAccessException,
                                                  InvocationTargetException,
                                                  ClassNotFoundException
```
    It attempts to create an instance of the given class
    This method attempts to create an instance of the given argument for classes without setters. These may be either immutable classes (e.g. with final attributes and no setters) or Java classes (e.g. belonging to the java / javax namespace). In case the class does not provide a public, no-arg constructor (e.g. Calendar), this method attempts to find a , no-args, factory method (e.g. getInstance()) and it invokes it
    
    Parameters:
    
    pojoClass - The name of the class for which an instance filled with values 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
    
    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
  - 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,
                                         org.springframework.messaging.MessageHandlingException
```
    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
    
    ClassNotFoundException - If it was not possible to create a class from a string
    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
    org.springframework.messaging.MessageHandlingException - If there was a problem handling the message
  - 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,
                                                                                       Class<?> collectionType,
                                                                                       String attributeName,
                                                                                       List<Annotation> annotations,
                                                                                       Map<String,Type> typeArgsMap,
                                                                                       Type... genericTypeArgs)
```
    It returns a collection of some sort with some data in it.
    
    Parameters:
    
    pojo - The POJO being analyzed
    
    manufacturingCtx - the manufacturing context
    
    collectionType - The type of the attribute being evaluated
    
    annotations - The set of annotations for the annotated attribute. It might be empty
    
    attributeName - The name of the field being set
    
    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:
    
    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
  - fillCollection
```
private void fillCollection(Collection<? super Object> collection,
                            ManufacturingContext manufacturingCtx,
                            Map<String,Type> typeArgsMap,
                            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:
    
    collection - The Collection to be filled
    
    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
    
    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
  - 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,
                                                                                 Class<?> attributeType,
                                                                                 String attributeName,
                                                                                 List<Annotation> annotations,
                                                                                 Map<String,Type> typeArgsMap,
                                                                                 Type... genericTypeArgs)
```
    It manufactures and returns a Map with at least one element in it
    Parameters:
    
    pojo - The POJO being initialized
    
    manufacturingCtx - the manufacturing context
    
    attributeType - The type of the POJO map attribute
    
    attributeName - The POJO attribute name
    
    annotations - The annotations specified for this attribute
    
    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:
    
    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
  - fillMap
```
private void fillMap(Map<? super Object,? super Object> map,
                     ManufacturingContext manufacturingCtx,
                     Map<String,Type> typeArgsMap,
                     Type... genericTypeArgs)
              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:
    
    map - The map being initialised
    
    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
    
    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
  - 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(Class<?> attributeType,
                                        Type genericType,
                                        String attributeName,
                                        ManufacturingContext manufacturingCtx,
                                        List<Annotation> annotations,
                                        Object pojo,
                                        Map<String,Type> typeArgsMap)
                                 throws InstantiationException,
                                        IllegalAccessException,
                                        InvocationTargetException,
                                        ClassNotFoundException
```
    It returns an Array with the first element set
    
    Parameters:
    
    attributeType - The array type
    
    genericType - The array generic type
    
    attributeName - The array attribute name in enclosing POJO class
    
    manufacturingCtx - the manufacturing context
    
    annotations - The annotations to be considered
    
    pojo - POJO containing attribute
    
    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,
                                         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
    
    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,
                                      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
    
    Returns:
    
    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

UNCHECKED_STR

messageChannel

LOG

applicationContext

externalFactory

strategy

classInfoStrategy

Constructor Detail

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

Method Detail

manufacturePojoWithFullData

manufacturePojo

populatePojo

getStrategy

setStrategy

getClassStrategy

setClassStrategy

getExternalFactory

setExternalFactory

instantiatePojoWithoutConstructors

instantiatePojo

manufacturePojoInternal

populatePojoInternal

manufactureAttributeValue

resortToExternalFactory

resolveCollectionValueWhenCollectionIsPojoAttribute

fillCollection

fillCollection

resolveMapValueWhenMapIsPojoAttribute

fillMap

fillMap

getMapKeyOrElementValue

resolveArrayElementValue

getParameterValuesForConstructor

getParameterValuesForMethod

manufactureParameterValue

getValueForAbstractType