PodamFactoryImpl (podam 3.1.0.RELEASE API)

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

All Implemented Interfaces:: PodamFactory

@ThreadSafe
@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
`static Comparator<Constructor<?>>`	`ConstructorComparator` Comparator for sorting constructors.
`private List<Class<? extends Annotation>>`	`excludeAnnotations` A list of `Annotation`s for attributes that PODAM shouldn't consider
`private org.apache.log4j.Logger`	`LOG` Application logger
`private DataProviderStrategy`	`strategy` The strategy to use to fill data.

Constructor Summary

Constructors
Constructor and Description

PodamFactoryImpl()
Default constructor.

PodamFactoryImpl(DataProviderStrategy strategy)
Full constructor.

Constructors
Constructor and Description
`PodamFactoryImpl()` Default constructor.
`PodamFactoryImpl(DataProviderStrategy strategy)` Full constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`private PodamStrategyValue`	`containsAttributeStrategyAnnotation(List<Annotation> annotations)` It returns a `PodamStrategyValue` if one was specified, or `null` otherwise.
`private Object`	`createNewInstanceForClassWithoutConstructors(Class<?> pojoClass, Class<?> clazz, Type... genericTypeArgs)` It attempts to create an instance of the given class
`private void`	`fillCollection(Class<?> pojoClass, String attributeName, List<Annotation> annotations, 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(Class<?> pojoClass, String attributeName, List<Annotation> annotations, Map<? super Object,? super Object> mapToBeFilled, Class<?> keyClass, Class<?> elementClass, Type[] keyGenericTypeArgs, Type[] elementGenericTypeArgs)` It fills a Map with the required number of elements of the required type.
`private Type[]`	`fillTypeArgMap(Map<String,Type> typeArgsMap, TypeVariable<?>[] typeParameters, Type[] genericTypeArgs)` Fills type agruments map
`private Boolean`	`getBooleanValueForAnnotation(List<Annotation> annotations)` It returns the boolean value indicated in the annotation.
`private Byte`	`getByteValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It returns a random byte if the attribute was annotated with `PodamByteValue` or `null` otherwise
`private Character`	`getCharacterValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It creates and returns a random `Character` value
`private Double`	`getDoubleValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It creates and returns a random `Double` value
`List<Class<? extends Annotation>>`	`getExcludeAnnotations()`
`private Float`	`getFloatValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` Returns either a customised float value if a `PodamFloatValue` annotation was provided or a random float if this was not the case
`private Integer`	`getIntegerValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` Returns either a customised int value if a `PodamIntValue` annotation was provided or a random integer if this was not the case
`private Long`	`getLongValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` Returns either a customised long value if a `PodamLongValue` annotation was provided or a random long if this was not the case
`private Object`	`getMapKeyOrElementValue(Class<?> pojoClass, String attributeName, List<Annotation> annotations, Class<?> keyOrValueType, PodamCollection collectionAnnotation, AttributeStrategy<?> elementStrategy, Type... genericTypeArgs)` It fills a Map key or value with the appropriate value, considering attribute-level customisation.
`private Object[]`	`getParameterValuesForConstructor(Constructor<?> constructor, Class<?> pojoClass, Type... genericTypeArgs)` Given a constructor it manufactures and returns the parameter values required to invoke it
`private Short`	`getShortValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It returns a random short if the attribute was annotated with `PodamShortValue` or `null` otherwise
`DataProviderStrategy`	`getStrategy()` It returns the strategy for this factory.
`private boolean`	`isWrapper(Class<?> candidateWrapperClass)` It returns `true` if this class is a wrapper class, `false` otherwise
`private Object`	`manufactureAttributeValue(Class<?> pojoClass, Class<?> attributeType, List<Annotation> annotations, String attributeName, Map<String,Type> typeArgsMap, Type... genericTypeArgs)` It manufactures and returns the value for a POJO attribute.
`private Object`	`manufactureAttributeValue(Class<?> pojoClass, Class<?> attributeType, List<Annotation> annotations, String attributeName, Type... genericTypeArgs)` It manufactures and returns the value for a POJO attribute.
`<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, int depth, Type... genericTypeArgs)` Generic method which returns an instance of the given class filled with values dictated by the strategy
`private Type[]`	`mergeTypeArrays(Type[] original, Type[] extra)` Utility method to merge two arrays
`private Object`	`resolveArrayElementValue(Class<?> attributeType, List<Annotation> annotations, Class<?> pojoClass, String attributeName, Map<String,Type> typeArgsMap)` It returns an Array with the first element set
`private Collection<? super Object>`	`resolveCollectionType(Class<?> collectionType)` Given a collection type it returns an instance
`private Collection<? super Object>`	`resolveCollectionValueWhenCollectionIsPojoAttribute(Class<?> pojoClass, 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 Class<?>`	`resolveGenericParameter(Type paramType, Map<String,Type> typeArgsMap, AtomicReference<Type[]> methodGenericTypeArgs)` It resolves generic parameter type
`private Map<? super Object,? super Object>`	`resolveMapType(Class<?> attributeType)` It manufactures and returns a default instance for each map type
`private Map<? super Object,? super Object>`	`resolveMapValueWhenMapIsPojoAttribute(Class<?> pojoClass, 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`	`resolvePojoWithoutSetters(Class<T> pojoClass, int depth, 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`	`resolvePrimitiveValue(Class<?> primitiveClass, List<Annotation> annotations, AttributeMetadata attributeMetadata)` It resolves and returns the primitive value depending on the type
`private String`	`resolveStringValue(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It creates and returns a String value, eventually customised by annotations
`private Object`	`resolveWrapperValue(Class<?> candidateWrapperClass, List<Annotation> annotations, AttributeMetadata attributeMetadata)` It attempts to resolve the given class as a wrapper class and if this is the case it assigns a random value
`private List<Annotation>`	`retrieveFieldAnnotations(Class<?> clazz, Method setter)` Given the original class and the setter method, it returns all annotations for the field or an empty collection if no custom annotations were found on the field
`private Object`	`returnAttributeDataStrategyValue(Class<?> attributeType, AttributeStrategy<?> attributeStrategy)` It retrieves the value for the `PodamStrategyValue` annotation with which the attribute was annotated
`void`	`setExcludeAnnotations(List<Class<? extends Annotation>> excludeAnnotations)`
`private void`	`validateAttributeName(String attributeName)` It validates that the attribute name is not null or empty

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

- Field Detail
  - LOG
```
private final org.apache.log4j.Logger LOG
```
    Application logger
  - strategy
```
private final DataProviderStrategy strategy
```
    The strategy to use to fill data.
    The default is RandomDataProviderStrategy.
  - excludeAnnotations
```
private List<Class<? extends Annotation>> excludeAnnotations
```
    A list of Annotations for attributes that PODAM shouldn't consider
  - ConstructorComparator
```
public static Comparator<Constructor<?>> ConstructorComparator
```
    Comparator for sorting constructors.
    We would like to have constructor with less parameters to speed up creation.
- Constructor Detail
  - PodamFactoryImpl
```
public PodamFactoryImpl()
```
    Default constructor.
  - PodamFactoryImpl
```
public PodamFactoryImpl(DataProviderStrategy strategy)
```
    Full constructor.
    
    Parameters:
    strategy - The strategy to use to fill data
- Method Detail
  - 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 RandomDataProviderStrategy 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 filled with dummy values
  - getStrategy
```
public DataProviderStrategy getStrategy()
```
    It returns the strategy for this factory.
    
    Specified by:
    
    getStrategy in interface PodamFactory
    
    Returns:
    the strategy
  - fillTypeArgMap
```
private Type[] fillTypeArgMap(Map<String,Type> typeArgsMap,
                    TypeVariable<?>[] typeParameters,
                    Type[] genericTypeArgs)
```
    Fills type agruments map
    This method places required and provided types for object creation into a map, which will be used for type mapping.
    
    Parameters:
    typeArgsMap - a map to fill
    typeParameters - Type arguments needed for a generics object creation
    genericTypeArgs - Type arguments provided for a generics object by caller
    
    Returns:
    Array of unused provided generic type arguments
  - createNewInstanceForClassWithoutConstructors
```
private Object createNewInstanceForClassWithoutConstructors(Class<?> pojoClass,
                                                  Class<?> clazz,
                                                  Type... genericTypeArgs)
                                                     throws IllegalArgumentException,
                                                            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:
    clazz - The class for which a new instance is required
    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
  - resolveGenericParameter
```
private Class<?> resolveGenericParameter(Type paramType,
                               Map<String,Type> typeArgsMap,
                               AtomicReference<Type[]> methodGenericTypeArgs)
```
    It resolves generic parameter type
    
    Parameters:
    paramType - The generic parameter type
    typeArgsMap - A map of resolved types
    methodGenericTypeArgs - Return value posible generic types of the generic parameter type
    
    Returns:
    value for class representing the generic parameter type
  - resolvePrimitiveValue
```
private Object resolvePrimitiveValue(Class<?> primitiveClass,
                           List<Annotation> annotations,
                           AttributeMetadata attributeMetadata)
```
    It resolves and returns the primitive value depending on the type
    
    Parameters:
    primitiveClass - The primitive type class
    annotations - The annotations to consider for this attribute
    attributeMetadata -
    
    Returns:
    the primitive value depending on the type
    
    Throws:
    
    IllegalArgumentException - If a specific value was set in an annotation but it was not possible to convert such value in the desired type
  - getBooleanValueForAnnotation
```
private Boolean getBooleanValueForAnnotation(List<Annotation> annotations)
```
    It returns the boolean value indicated in the annotation.
    
    Parameters:
    annotations - The collection of annotations for the annotated attribute
    
    Returns:
    The boolean value indicated in the annotation
  - getByteValueWithinRange
```
private Byte getByteValueWithinRange(List<Annotation> annotations,
                           AttributeMetadata attributeMetadata)
```
    It returns a random byte if the attribute was annotated with PodamByteValue or null otherwise
    
    Parameters:
    annotations - The list of annotations for this attribute
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    A random byte if the attribute was annotated with
    
    Throws:
    
    IllegalArgumentException - If the PodamByteValue.numValue() value has been set and it is not convertible to a byte type
  - getShortValueWithinRange
```
private Short getShortValueWithinRange(List<Annotation> annotations,
                             AttributeMetadata attributeMetadata)
```
    It returns a random short if the attribute was annotated with PodamShortValue or null otherwise
    
    Parameters:
    annotations - The annotations with which the attribute was annotated
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    A random short if the attribute was annotated with PodamShortValue or null otherwise
    
    Throws:
    
    IllegalArgumentException - If PodamShortValue.numValue() was set and its value could not be converted to a Short type
  - getCharacterValueWithinRange
```
private Character getCharacterValueWithinRange(List<Annotation> annotations,
                                     AttributeMetadata attributeMetadata)
```
    It creates and returns a random Character value
    
    Parameters:
    annotations - The list of annotations which might customise the return value
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    A random Character value
  - getIntegerValueWithinRange
```
private Integer getIntegerValueWithinRange(List<Annotation> annotations,
                                 AttributeMetadata attributeMetadata)
```
    Returns either a customised int value if a PodamIntValue annotation was provided or a random integer if this was not the case
    
    Parameters:
    annotations - The list of annotations for the int attribute
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    Either a customised int value if a PodamIntValue annotation was provided or a random integer if this was not the case
    
    Throws:
    
    IllegalArgumentException - If it was not possible to convert the PodamIntValue.numValue() to an Integer
  - getFloatValueWithinRange
```
private Float getFloatValueWithinRange(List<Annotation> annotations,
                             AttributeMetadata attributeMetadata)
```
    Returns either a customised float value if a PodamFloatValue annotation was provided or a random float if this was not the case
    
    Parameters:
    annotations - The list of annotations for the int attribute
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    Either a customised float value if a PodamFloatValue annotation was provided or a random float if this was not the case
    
    Throws:
    
    IllegalArgumentException - If PodamFloatValue.numValue() contained a value not convertible to a Float type
  - getDoubleValueWithinRange
```
private Double getDoubleValueWithinRange(List<Annotation> annotations,
                               AttributeMetadata attributeMetadata)
```
    It creates and returns a random Double value
    
    Parameters:
    annotations - The list of annotations which might customise the return value
    attributeMetadata - The attribute's metadata, if any, used for customisation *
    
    Returns:
    a random Double value
  - getLongValueWithinRange
```
private Long getLongValueWithinRange(List<Annotation> annotations,
                           AttributeMetadata attributeMetadata)
```
    Returns either a customised long value if a PodamLongValue annotation was provided or a random long if this was not the case
    
    Parameters:
    annotations - The list of annotations for the int attribute
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    Either a customised long value if a PodamLongValue annotation was provided or a random long if this was not the case
    
    Throws:
    
    IllegalArgumentException - If it was not possible to convert PodamLongValue.numValue() to a Long
  - resolveWrapperValue
```
private Object resolveWrapperValue(Class<?> candidateWrapperClass,
                         List<Annotation> annotations,
                         AttributeMetadata attributeMetadata)
```
    It attempts to resolve the given class as a wrapper class and if this is the case it assigns a random value
    
    Parameters:
    candidateWrapperClass - The class which might be a wrapper class
    attributeMetadata - The attribute's metadata, if any, used for customisation
    
    Returns:
    null if this is not a wrapper class, otherwise an Object with the value for the wrapper class
  - resolvePojoWithoutSetters
```
private <T> T resolvePojoWithoutSetters(Class<T> pojoClass,
                              int depth,
                              Type... genericTypeArgs)
                             throws IllegalArgumentException,
                                    InstantiationException,
                                    IllegalAccessException,
                                    InvocationTargetException,
                                    ClassNotFoundException
```
    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
    depth - How many instances of the same class have been created so far
    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:
    
    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
  - manufacturePojoInternal
```
private <T> T manufacturePojoInternal(Class<T> pojoClass,
                            int depth,
                            Type... genericTypeArgs)
```
    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
    depth - How many times pojoClass has been found. This will be used for reentrant objects
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    Returns:
    An instance of filled with dummy values
    
    Throws:
    
    PodamMockeryException - if a problem occurred while creating a POJO instance or while setting its state
  - manufactureAttributeValue
```
private Object manufactureAttributeValue(Class<?> pojoClass,
                               Class<?> attributeType,
                               List<Annotation> annotations,
                               String attributeName,
                               Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         IllegalArgumentException,
                                         ClassNotFoundException
```
    It manufactures and returns the value for a POJO attribute.
    Parameters:
    pojoClass - The POJO class being filled with values
    attributeType - The type of the attribute for which a value is being manufactured
    annotations - The annotations for the attribute being considered
    attributeName - The attribute name
    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
  - manufactureAttributeValue
```
private Object manufactureAttributeValue(Class<?> pojoClass,
                               Class<?> attributeType,
                               List<Annotation> annotations,
                               String attributeName,
                               Map<String,Type> typeArgsMap,
                               Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         IllegalArgumentException,
                                         ClassNotFoundException
```
    It manufactures and returns the value for a POJO attribute.
    Parameters:
    pojoClass - The POJO class being filled with values
    attributeType - The 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 ("" 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
  - resolveStringValue
```
private String resolveStringValue(List<Annotation> annotations,
                        AttributeMetadata attributeMetadata)
                           throws InstantiationException,
                                  IllegalAccessException
```
    It creates and returns a String value, eventually customised by annotations
    
    Parameters:
    annotations - The list of annotations used to customise the String value, if any
    attributeMetadata -
    
    Returns:
    a String value, eventually customised by annotations
    
    Throws:
    
    IllegalAccessException - If an exception occurred while creating an instance of the strategy
    
    InstantiationException - If an exception occurred while creating an instance of the strategy
    
    IllegalArgumentException - If PodamStrategyValue was specified but the type was not correct for the attribute being set
  - containsAttributeStrategyAnnotation
```
private PodamStrategyValue containsAttributeStrategyAnnotation(List<Annotation> annotations)
```
    It returns a PodamStrategyValue if one was specified, or null otherwise.
    
    Parameters:
    annotations - The list of annotations
    
    Returns:
    true if the list of annotations contains at least one PodamStrategyValue annotation.
  - isWrapper
```
private boolean isWrapper(Class<?> candidateWrapperClass)
```
    It returns true if this class is a wrapper class, false otherwise
    
    Parameters:
    candidateWrapperClass - The class to check
    
    Returns:
    true if this class is a wrapper class, false otherwise
  - retrieveFieldAnnotations
```
private List<Annotation> retrieveFieldAnnotations(Class<?> clazz,
                                        Method setter)
```
    Given the original class and the setter method, it returns all annotations for the field or an empty collection if no custom annotations were found on the field
    
    Parameters:
    clazz - The class containing the annotated attribute
    setter - The setter method
    
    Returns:
    all annotations for the field
    
    Throws:
    
    NoSuchFieldException - If the field could not be found
    
    SecurityException - if a security exception occurred
  - resolveCollectionValueWhenCollectionIsPojoAttribute
```
private Collection<? super Object> resolveCollectionValueWhenCollectionIsPojoAttribute(Class<?> pojoClass,
                                                                             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:
    pojoClass - The POJO being analysed
    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 ("" 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(Class<?> pojoClass,
                  String attributeName,
                  List<Annotation> annotations,
                  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:
    pojoClass - The POJO where the collection attribute is defined
    attributeName - The attribute name
    annotations - The annotations for this attribute
    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(Class<?> pojoClass,
                                                                       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:
    pojoClass - The POJO being initialised
    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 ("" 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(Class<?> pojoClass,
           String attributeName,
           List<Annotation> annotations,
           Map<? super Object,? super Object> mapToBeFilled,
           Class<?> keyClass,
           Class<?> elementClass,
           Type[] keyGenericTypeArgs,
           Type[] elementGenericTypeArgs)
              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:
    pojoClass - The POJO where the Map attribute has been declared
    attributeName - The attribute name
    annotations - The annotations for the attribute
    mapToBeFilled - The Map to be returned
    keyClass - The type of the Map key
    elementClass - The type of the Map element
    keyGenericTypeArgs - The generic type arguments for the current key generic class instance
    elementGenericTypeArgs - The generic type arguments for the current element 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
  - getMapKeyOrElementValue
```
private Object getMapKeyOrElementValue(Class<?> pojoClass,
                             String attributeName,
                             List<Annotation> annotations,
                             Class<?> keyOrValueType,
                             PodamCollection collectionAnnotation,
                             AttributeStrategy<?> elementStrategy,
                             Type... genericTypeArgs)
                                throws InstantiationException,
                                       IllegalAccessException,
                                       InvocationTargetException,
                                       ClassNotFoundException
```
    It fills a Map key or value with the appropriate value, considering attribute-level customisation.
    Parameters:
    pojoClass - The class containing the annotated attribute
    attributeName - The attribute name
    annotations - The list of annotations for this attribute
    keyOrValueType - The Map key / element type
    collectionAnnotation - The PodamCollection annotation
    elementStrategy - The strategy to use to fill the Map key or value element
    genericTypeArgs - The generic type arguments for the current generic class instance
    
    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
  - resolveArrayElementValue
```
private Object resolveArrayElementValue(Class<?> attributeType,
                              List<Annotation> annotations,
                              Class<?> pojoClass,
                              String attributeName,
                              Map<String,Type> typeArgsMap)
                                 throws IllegalArgumentException,
                                        InstantiationException,
                                        IllegalAccessException,
                                        InvocationTargetException,
                                        ClassNotFoundException
```
    It returns an Array with the first element set
    
    Parameters:
    attributeType - The array type
    annotations - The annotations to be considered
    pojoClass -
    attributeName -
    typeArgsMap - a map relating the generic class arguments ("" 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
  - resolveCollectionType
```
private Collection<? super Object> resolveCollectionType(Class<?> collectionType)
```
    Given a collection type it returns an instance
    - The default type for a List is an ArrayList
    - The default type for a Queue is a LinkedList
    - The default type for a Set is a HashSet
    Parameters:
    collectionType - The collection type *
    
    Returns:
    an instance of the collection type
  - resolveMapType
```
private Map<? super Object,? super Object> resolveMapType(Class<?> attributeType)
```
    It manufactures and returns a default instance for each map type
    The default implementation for a ConcurrentMap is ConcurrentHashMap
    
    The default implementation for a SortedMap is a TreeMap
    
    The default Map is none of the above was recognised is a HashMap
    
    Parameters:
    attributeType - The attribute type
    
    Returns:
    A default instance for each map type
  - validateAttributeName
```
private void validateAttributeName(String attributeName)
```
    It validates that the attribute name is not null or empty
    
    Parameters:
    attributeName - The attribute to be validated
    
    Throws:
    
    IllegalArgumentException - If the attribute name is null or empty
  - getParameterValuesForConstructor
```
private Object[] getParameterValuesForConstructor(Constructor<?> constructor,
                                        Class<?> pojoClass,
                                        Type... genericTypeArgs)
                                           throws IllegalArgumentException,
                                                  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
    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
  - mergeTypeArrays
```
private Type[] mergeTypeArrays(Type[] original,
                     Type[] extra)
```
    Utility method to merge two arrays
    
    Parameters:
    original - The main array
    extra - The additional array, optionally may be null
    
    Returns:
    A merged array of original and extra arrays
  - returnAttributeDataStrategyValue
```
private Object returnAttributeDataStrategyValue(Class<?> attributeType,
                                      AttributeStrategy<?> attributeStrategy)
                                         throws InstantiationException,
                                                IllegalAccessException
```
    It retrieves the value for the PodamStrategyValue annotation with which the attribute was annotated
    
    Parameters:
    attributeType - The attribute type, used for type checking
    attributeStrategy - The AttributeStrategy to use
    
    Returns:
    The value for the PodamStrategyValue annotation with which the attribute was annotated
    
    Throws:
    
    InstantiationException - If an exception occurred while creating an instance of the strategy contained within the PodamStrategyValue annotation
    
    IllegalAccessException - If an exception occurred while creating an instance of the strategy contained within the PodamStrategyValue annotation
    
    IllegalArgumentException - If the type of the data strategy defined for the PodamStrategyValue annotation is not assignable to the annotated attribute. This de facto guarantees type safety.
  - getExcludeAnnotations
```
public List<Class<? extends Annotation>> getExcludeAnnotations()
```
    Returns:
    the excludeAnnotations
  - setExcludeAnnotations
```
public void setExcludeAnnotations(List<Class<? extends Annotation>> excludeAnnotations)
```
    Parameters:
    excludeAnnotations - the excludeAnnotations to set

Class PodamFactoryImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

strategy

excludeAnnotations

ConstructorComparator

Constructor Detail

PodamFactoryImpl

PodamFactoryImpl

Method Detail

manufacturePojo

getStrategy

fillTypeArgMap

createNewInstanceForClassWithoutConstructors

resolveGenericParameter

resolvePrimitiveValue

getBooleanValueForAnnotation

getByteValueWithinRange

getShortValueWithinRange

getCharacterValueWithinRange

getIntegerValueWithinRange

getFloatValueWithinRange

getDoubleValueWithinRange

getLongValueWithinRange

resolveWrapperValue

resolvePojoWithoutSetters

manufacturePojoInternal

manufactureAttributeValue

manufactureAttributeValue

resolveStringValue

containsAttributeStrategyAnnotation

isWrapper

retrieveFieldAnnotations

resolveCollectionValueWhenCollectionIsPojoAttribute

fillCollection

resolveMapValueWhenMapIsPojoAttribute

fillMap

getMapKeyOrElementValue

resolveArrayElementValue

resolveCollectionType

resolveMapType

validateAttributeName

getParameterValuesForConstructor

mergeTypeArrays

returnAttributeDataStrategyValue

getExcludeAnnotations

setExcludeAnnotations