PodamFactoryImpl (podam 4.7.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
`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 Map<Class<?>,Object>`	`memoizationTable` A map to keep one object for each class.
`private static Type[]`	`NO_TYPES`
`private static String`	`RAWTYPES_STR`
`private static String`	`RESOLVING_COLLECTION_EXCEPTION_STR`
`private DataProviderStrategy`	`strategy` The strategy to use to fill data.
`private static String`	`THE_ANNOTATION_VALUE_STR`
`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

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, Map<Class<?>,Integer> pojos, Class<?> clazz, Type... genericTypeArgs)` It attempts to create an instance of the given class
`private void`	`fillCollection(Class<?> pojoClass, Map<Class<?>,Integer> pojos, 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`	`fillCollection(Collection<? super Object> collection, Map<Class<?>,Integer> pojos, 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, Map<Class<?>,Integer> pojos, Type... genericTypeArgs)` It fills a Map with the required number of elements of the required type.
`private void`	`fillMap(MapArguments mapArguments)` It fills a Map with the required number of elements of the required type.
`private Type[]`	`fillTypeArgMap(Map<String,Type> typeArgsMap, Class<?> pojoClass, 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 <T> T`	`getDefaultFieldValue(Class<?> pojoClass, String attributeName)` It returns an default value for a `Field` matching the attribute name or null if a field was not found.
`private Double`	`getDoubleValueWithinRange(List<Annotation> annotations, AttributeMetadata attributeMetadata)` It creates and returns a random `Double` value
`private Field`	`getField(Class<?> pojoClass, String attributeName)` It returns a `Field` matching the attribute name or null if a field was not found.
`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(MapKeyOrElementsArguments keyOrElementsArguments)` It fills a Map key or value with the appropriate value, considering attribute-level customisation.
`private Object[]`	`getParameterValuesForConstructor(Constructor<?> constructor, Class<?> pojoClass, Map<Class<?>,Integer> pojos, 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 <T> T`	`instantiatePojo(Class<T> pojoClass, Map<Class<?>,Integer> pojos, 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 boolean`	`isWrapper(Class<?> candidateWrapperClass)` It returns `true` if this class is a wrapper class, `false` otherwise
`private Object`	`manufactureAttributeValue(Class<?> pojoClass, Map<Class<?>,Integer> pojos, 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, Map<Class<?>,Integer> pojos, 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)` Generic method which returns an instance of the given class filled with dummy values, using the default data provider strategy.
`<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, Map<Class<?>,Integer> pojos, 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, Map<Class<?>,Integer> pojos, 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, Map<Class<?>,Integer> pojos, 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<?> mapType)` It manufactures and returns a default instance for each map type
`private Map<? super Object,? super Object>`	`resolveMapValueWhenMapIsPojoAttribute(Class<?> pojoClass, Map<Class<?>,Integer> pojos, 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 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

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
  - RAWTYPES_STR
```
private static final String RAWTYPES_STR
```
    See Also:
    Constant Field Values
  - UNCHECKED_STR
```
private static final String UNCHECKED_STR
```
    See Also:
    Constant Field Values
  - THE_ANNOTATION_VALUE_STR
```
private static final String THE_ANNOTATION_VALUE_STR
```
    See Also:
    Constant Field Values
  - NO_TYPES
```
private static final Type[] NO_TYPES
```
  - LOG
```
private static final org.slf4j.Logger LOG
```
    Application logger
  - externalFactory
```
private final PodamFactory externalFactory
```
    External factory to delegate production this factory cannot handle
    The default is LoggingExternalFactory.
  - strategy
```
private final DataProviderStrategy strategy
```
    The strategy to use to fill data.
    The default is RandomDataProviderStrategy.
  - memoizationTable
```
private Map<Class<?>,Object> memoizationTable
```
    A map to keep one object for each class. If memoization is enabled, the factory will use this table to avoid creating objects of the same class multiple times.
- 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
  - manufacturePojo
```
public <T> T manufacturePojo(Class<T> pojoClass)
```
    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
    
    Parameters:
    pojoClass - The name of the class for which an instance filled with values is required
    
    Returns:
    An instance of 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 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,
                    Class<?> pojoClass,
                    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
    pojoClass - Typed class
    genericTypeArgs - Type arguments provided for a generics object by caller
    
    Returns:
    Array of unused provided generic type arguments
    
    Throws:
    
    IllegalStateException - If number of typed parameters doesn't match number of provided generic types
  - createNewInstanceForClassWithoutConstructors
```
private Object createNewInstanceForClassWithoutConstructors(Class<?> pojoClass,
                                                  Map<Class<?>,Integer> pojos,
                                                  Class<?> clazz,
                                                  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
    pojos - Set of manufactured pojos' types
    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
  - instantiatePojo
```
private <T> T instantiatePojo(Class<T> pojoClass,
                    Map<Class<?>,Integer> pojos,
                    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
    pojos - 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
    
    SecurityException
  - manufacturePojoInternal
```
private <T> T manufacturePojoInternal(Class<T> pojoClass,
                            Map<Class<?>,Integer> pojos,
                            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
    pojos - 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:
    
    ClassNotFoundException
    
    InvocationTargetException
    
    IllegalAccessException
    
    InstantiationException
    
    PodamMockeryException - if a problem occurred while creating a POJO instance or while setting its state
  - manufactureAttributeValue
```
private Object manufactureAttributeValue(Class<?> pojoClass,
                               Map<Class<?>,Integer> pojos,
                               Class<?> attributeType,
                               List<Annotation> annotations,
                               String attributeName,
                               Type... genericTypeArgs)
                                  throws InstantiationException,
                                         IllegalAccessException,
                                         InvocationTargetException,
                                         ClassNotFoundException
```
    It manufactures and returns the value for a POJO attribute.
    Parameters:
    pojoClass - The POJO class being filled with values
    pojos - Set of manufactured pojos' types
    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,
                               Map<Class<?>,Integer> pojos,
                               Class<?> attributeType,
                               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:
    pojoClass - The POJO class being filled with values
    pojos - Set of manufactured pojos' types
    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
  - getDefaultFieldValue
```
private <T> T getDefaultFieldValue(Class<?> pojoClass,
                         String attributeName)
```
    It returns an default value for a Field matching the attribute name or null if a field was not found.
    
    Parameters:
    pojoClass - The class supposed to contain the field
    attributeName - The field name
    
    Returns:
    an instance of Field matching the attribute name or null if a field was not found.
  - getField
```
private Field getField(Class<?> pojoClass,
             String attributeName)
```
    It returns a Field matching the attribute name or null if a field was not found.
    
    Parameters:
    pojoClass - The class supposed to contain the field
    attributeName - The field name
    
    Returns:
    a Field matching the attribute name or null if a field was not found.
  - 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,
                                                                             Map<Class<?>,Integer> pojos,
                                                                             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
    pojos - Set of manufactured pojos' types
    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(Collection<? super Object> collection,
                  Map<Class<?>,Integer> pojos,
                  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
    pojos - Set of manufactured pojos' 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(Class<?> pojoClass,
                  Map<Class<?>,Integer> pojos,
                  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
    pojos - Set of manufactured pojos' types
    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,
                                                                       Map<Class<?>,Integer> pojos,
                                                                       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
    pojos - Set of manufactured pojos' types
    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(Map<? super Object,? super Object> map,
           Map<Class<?>,Integer> pojos,
           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:
    pojoClass - The POJO being initialised
    pojos - Set of manufactured pojos' 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)
              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
    
    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)
                                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
    
    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,
                              Map<Class<?>,Integer> pojos,
                              List<Annotation> annotations,
                              Class<?> pojoClass,
                              String attributeName,
                              Map<String,Type> typeArgsMap)
                                 throws InstantiationException,
                                        IllegalAccessException,
                                        InvocationTargetException,
                                        ClassNotFoundException
```
    It returns an Array with the first element set
    
    Parameters:
    attributeType - The array type
    pojos - Set of manufactured pojos' types
    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<?> mapType)
```
    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:
    mapType - The attribute type implementing Map
    
    Returns:
    A default instance for each map type
  - getParameterValuesForConstructor
```
private Object[] getParameterValuesForConstructor(Constructor<?> constructor,
                                        Class<?> pojoClass,
                                        Map<Class<?>,Integer> pojos,
                                        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
    pojos - Set of manufactured pojos' 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
  - 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.

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

RAWTYPES_STR

UNCHECKED_STR

THE_ANNOTATION_VALUE_STR

NO_TYPES

LOG

externalFactory

strategy

memoizationTable

Constructor Detail

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

PodamFactoryImpl

Method Detail

manufacturePojo

manufacturePojo

getStrategy

fillTypeArgMap

createNewInstanceForClassWithoutConstructors

resolveGenericParameter

resolvePrimitiveValue

getBooleanValueForAnnotation

getByteValueWithinRange

getShortValueWithinRange

getCharacterValueWithinRange

getIntegerValueWithinRange

getFloatValueWithinRange

getDoubleValueWithinRange

getLongValueWithinRange

resolveWrapperValue

instantiatePojo

manufacturePojoInternal

manufactureAttributeValue

manufactureAttributeValue

resolveStringValue

getDefaultFieldValue

getField

containsAttributeStrategyAnnotation

isWrapper

retrieveFieldAnnotations

resolveCollectionValueWhenCollectionIsPojoAttribute

fillCollection

fillCollection

resolveMapValueWhenMapIsPojoAttribute

fillMap

fillMap

getMapKeyOrElementValue

resolveArrayElementValue

resolveCollectionType

resolveMapType

getParameterValuesForConstructor

mergeTypeArrays

returnAttributeDataStrategyValue