AbstractRandomDataProviderStrategy (podam 8.0.1-SNAPSHOT API)

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

All Implemented Interfaces:

DataProviderStrategy, RandomDataProviderStrategy

Direct Known Subclasses:

RandomDataProviderStrategyImpl
```
@ThreadSafe
public abstract class AbstractRandomDataProviderStrategy
extends Object
implements RandomDataProviderStrategy
```
Default abstract implementation of a DataProviderStrategy
This default implementation returns values based on a random generator. Convinient for subclassing and redefining behaviour. Don't use this implementation if you seek deterministic values

All values returned by this implementation are different from zero.

Since:

1.0.0

Author:

mtedone

Nested Class Summary
- Nested classes/interfaces inherited from interface uk.co.jemos.podam.api.DataProviderStrategy
  DataProviderStrategy.Order

Field Summary

Fields
Modifier and Type	Field and Description
`private Map<Class<?>,Map<String,AttributeStrategy<?>>>`	`attributeClassStrategies` Mapping between attributes and attribute strategies
`private Map<Class<? extends Annotation>,AttributeStrategy<?>>`	`attributeStrategies` Mapping between annotations and attribute strategies
`private AbstractConstructorComparator`	`constructorHeavyComparator` The constructor comparator
`private AbstractConstructorComparator`	`constructorLightComparator` The constructor comparator
`private Map<Class<?>,Class<?>>`	`factoryTypes` A list of user-submitted factories to build interfaces and abstract classes
`private AtomicBoolean`	`isMemoizationEnabled` Flag to enable/disable the memoization setting.
`private static org.slf4j.Logger`	`LOG` Application logger
`private int`	`maxDepth` How many times it is allowed to PODAM to create an instance of the same class in a recursive hierarchy
`private Map<Class<?>,Map<Type[],Object>>`	`memoizationTable` A map to keep one object for each class.
`private AbstractMethodComparator`	`methodHeavyComparator` The constructor comparator
`private AbstractMethodComparator`	`methodLightComparator` The constructor comparator
`private AtomicInteger`	`nbrOfCollectionElements` The number of collection elements.
`private Map<Class<?>,Class<?>>`	`specificTypes` A list of user-submitted specific implementations for interfaces and abstract classes
`private ConcurrentHashMap<Class<?>,TypeManufacturer<?>>`	`typeManufacturers` A mapping between types and their registered manufacturers

Constructor Summary

Constructors
Constructor and Description

AbstractRandomDataProviderStrategy()
Implementation of the Singleton pattern

AbstractRandomDataProviderStrategy(int nbrOfCollectionElements)

Constructors
Constructor and Description
`AbstractRandomDataProviderStrategy()` Implementation of the Singleton pattern
`AbstractRandomDataProviderStrategy(int nbrOfCollectionElements)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RandomDataProviderStrategy`	`addOrReplaceAttributeStrategy(Class<?> type, String attributeName, AttributeStrategy<?> attributeStrategy)` Registers @AttributeStrategy implementation, which will be used to instantiate objects of a specified type.
`RandomDataProviderStrategy`	`addOrReplaceAttributeStrategy(Class<? extends Annotation> annotationClass, AttributeStrategy<?> attributeStrategy)` Bind an annotation to attribute strategy class.
`<T> AbstractRandomDataProviderStrategy`	`addOrReplaceFactory(Class<T> abstractClass, Class<?> factoryClass)` Binds an interface/abstract class to its factory.
`<T> DataProviderStrategy`	`addOrReplaceSpecific(Class<T> abstractClass, Class<? extends T> specificClass)` Bind an interface/abstract class to a specific implementation.
`<T> DataProviderStrategy`	`addOrReplaceTypeManufacturer(Class<? extends T> type, TypeManufacturer<T> typeManufacturer)` Registers @TypeManufacturer implementation, which will be used to instantiate objects of a specified type.
`void`	`cacheMemoizedObject(AttributeMetadata attributeMetadata, Object instance)` Saves object in memoization cache
`void`	`clearMemoizationCache()` Clears memoization cache
`AbstractConstructorComparator`	`getConstructorHeavyComparator()` Getter for constructor heavy comparator.
`AbstractConstructorComparator`	`getConstructorLightComparator()` Getter for constructor light comparator.
`Class<?>`	`getFactoryClass(Class<?> nonInstantiatableClass)` Resolves factory classes for abstract classes and interfaces.
`int`	`getMaxDepth(Class<?> type)` Returns how many times it is allowed to PODAM to create an instance of the same class in a recursive hierarchy
`Object`	`getMemoizedObject(AttributeMetadata attributeMetadata)` Obtains object from memoization cache
`AbstractMethodComparator`	`getMethodHeavyComparator()` Getter for method heavy comparator.
`AbstractMethodComparator`	`getMethodLightComparator()` Getter for method light comparator.
`int`	`getNumberOfCollectionElements(Class<?> type)` Returns the number of default collection elements.
`<T> Class<? extends T>`	`getSpecificClass(Class<T> nonInstantiatableClass)` Resolves abstract classes and interfaces.
`AttributeStrategy<?>`	`getStrategyForAnnotation(Class<? extends Annotation> annotationClass)` Finds attribute strategies for annotations.
`AttributeStrategy<?>`	`getStrategyForAttribute(ClassAttribute attribute)` Finds attribute strategies for attribute.
`<T> T`	`getTypeValue(AttributeMetadata attributeMetadata, ManufacturingContext manufacturingCtx, Class<T> pojoType)` Obtains a type value
`boolean`	`isMemoizationEnabled()` Returns whether the memoization setting is enabled.
`private void`	`log(AttributeMetadata attributeMetadata)`
`RandomDataProviderStrategy`	`removeAttributeStrategy(Class<?> type, String attributeName)` Removes @AttributeStrategy implementation from for the specific attribute
`RandomDataProviderStrategy`	`removeAttributeStrategy(Class<? extends Annotation> annotationClass)` Remove binding of an annotation to attribute strategy
`<T> AbstractRandomDataProviderStrategy`	`removeFactory(Class<T> abstractClass)` Remove binding of an interface/abstract class to its factory
`<T> DataProviderStrategy`	`removeSpecific(Class<T> abstractClass)` Remove binding of an interface/abstract class to a specific implementation
`<T> DataProviderStrategy`	`removeTypeManufacturer(Class<T> type)` Remove binding of a class type to a specific implementation of type manufacturer
`void`	`setConstructorHeavyComparator(AbstractConstructorComparator constructorHeavyComparator)` Setter for constructor heavy comparator.
`void`	`setConstructorLightComparator(AbstractConstructorComparator constructorLightComparator)` Setter for constructor öight comparator.
`void`	`setDefaultNumberOfCollectionElements(int newNumberOfCollectionElements)` Sets the new default number of default collection elements.
`void`	`setMaxDepth(int maxDepth)` Max depth setter
`void`	`setMemoization(boolean isMemoizationEnabled)` Sets whether memoization is enabled
`void`	`setMethodHeavyComparator(AbstractMethodComparator methodHeavyComparator)` Setter for method heavy comparator.
`void`	`setMethodLightComparator(AbstractMethodComparator methodLightComparator)` Setter for method light comparator.
`void`	`sort(Constructor<?>[] constructors, DataProviderStrategy.Order order)` Rearranges POJO's constructors in order they will be tried to produce the POJO.
`void`	`sort(Method[] methods, DataProviderStrategy.Order order)` Rearranges POJO's methods in order they will be tried to produce the POJO.

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

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
    Application logger
  - maxDepth
```
private int maxDepth
```
    How many times it is allowed to PODAM to create an instance of the same class in a recursive hierarchy
  - nbrOfCollectionElements
```
private final AtomicInteger nbrOfCollectionElements
```
    The number of collection elements.
  - isMemoizationEnabled
```
private final AtomicBoolean isMemoizationEnabled
```
    Flag to enable/disable the memoization setting.
  - memoizationTable
```
private final Map<Class<?>,Map<Type[],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.
  - typeManufacturers
```
private final ConcurrentHashMap<Class<?>,TypeManufacturer<?>> typeManufacturers
```
    A mapping between types and their registered manufacturers
  - specificTypes
```
private final Map<Class<?>,Class<?>> specificTypes
```
    A list of user-submitted specific implementations for interfaces and abstract classes
  - factoryTypes
```
private final Map<Class<?>,Class<?>> factoryTypes
```
    A list of user-submitted factories to build interfaces and abstract classes
  - attributeStrategies
```
private final Map<Class<? extends Annotation>,AttributeStrategy<?>> attributeStrategies
```
    Mapping between annotations and attribute strategies
  - attributeClassStrategies
```
private final Map<Class<?>,Map<String,AttributeStrategy<?>>> attributeClassStrategies
```
    Mapping between attributes and attribute strategies
  - constructorHeavyComparator
```
private AbstractConstructorComparator constructorHeavyComparator
```
    The constructor comparator
  - constructorLightComparator
```
private AbstractConstructorComparator constructorLightComparator
```
    The constructor comparator
  - methodHeavyComparator
```
private AbstractMethodComparator methodHeavyComparator
```
    The constructor comparator
  - methodLightComparator
```
private AbstractMethodComparator methodLightComparator
```
    The constructor comparator
- Constructor Detail
  - AbstractRandomDataProviderStrategy
```
public AbstractRandomDataProviderStrategy()
```
    Implementation of the Singleton pattern
  - AbstractRandomDataProviderStrategy
```
public AbstractRandomDataProviderStrategy(int nbrOfCollectionElements)
```
- Method Detail
  - getNumberOfCollectionElements
```
public int getNumberOfCollectionElements(Class<?> type)
```
    Returns the number of default collection elements.
    Implementations of this interface need to provide this value.
    
    Specified by:
    
    getNumberOfCollectionElements in interface DataProviderStrategy
    
    Parameters:
    
    type - Type of collection's elements
    
    Returns:
    
    The number of default collection elements
  - setDefaultNumberOfCollectionElements
```
public void setDefaultNumberOfCollectionElements(int newNumberOfCollectionElements)
```
    Sets the new default number of default collection elements.
    
    Specified by:
    
    setDefaultNumberOfCollectionElements in interface DataProviderStrategy
    
    Parameters:
    
    newNumberOfCollectionElements - The new number of collection elements.
  - getMaxDepth
```
public int getMaxDepth(Class<?> type)
```
    Returns how many times it is allowed to PODAM to create an instance of the same class in a recursive hierarchy
    Implementations of this interface need to provide this value.
    
    Specified by:
    
    getMaxDepth in interface DataProviderStrategy
    
    Parameters:
    
    type - Type of POJO to be created
    
    Returns:
    
    How many times it is allowed to create an instance of the same class in a recursive hierarchy
  - setMaxDepth
```
public void setMaxDepth(int maxDepth)
```
    Max depth setter
    
    Parameters:
    
    maxDepth - defines new max depth
  - isMemoizationEnabled
```
public boolean isMemoizationEnabled()
```
    Returns whether the memoization setting is enabled. When memoization is enabled, only one object will be created for each type. Every next property of the same type will be a reference to the same object. This can dramatically improve performance but with the expense of not having objects with different values.
    Implementations of this interface need to provide this value.
    
    Specified by:
    
    isMemoizationEnabled in interface DataProviderStrategy
    
    Returns:
    
    Whether the memoization setting is enabled.
  - setMemoization
```
public void setMemoization(boolean isMemoizationEnabled)
```
    Sets whether memoization is enabled
    
    Specified by:
    
    setMemoization in interface DataProviderStrategy
    
    Parameters:
    
    isMemoizationEnabled - whether memoization is enabled
  - getMemoizedObject
```
public Object getMemoizedObject(AttributeMetadata attributeMetadata)
```
    Obtains object from memoization cache
    
    Specified by:
    
    getMemoizedObject in interface DataProviderStrategy
    
    Parameters:
    
    attributeMetadata - attribute metadata for instance to be fetched
    
    Returns:
    
    object instance from memoization cache
  - cacheMemoizedObject
```
public void cacheMemoizedObject(AttributeMetadata attributeMetadata,
                                Object instance)
```
    Saves object in memoization cache
    
    Specified by:
    
    cacheMemoizedObject in interface DataProviderStrategy
    
    Parameters:
    
    attributeMetadata - attribute metadata for instance being memoized
    
    instance - object instance to save in memoization cache
  - clearMemoizationCache
```
public void clearMemoizationCache()
```
    Clears memoization cache
    
    Specified by:
    
    clearMemoizationCache in interface DataProviderStrategy
  - sort
```
public void sort(Constructor<?>[] constructors,
                 DataProviderStrategy.Order order)
```
    Rearranges POJO's constructors in order they will be tried to produce the POJO. Default strategy consist of putting constructors with less parameters to be tried first.
    
    Specified by:
    
    sort in interface DataProviderStrategy
    
    Parameters:
    
    constructors - Array of POJO's constructors
    
    order - DataProviderStrategy.Order how to sort constructors
  - sort
```
public void sort(Method[] methods,
                 DataProviderStrategy.Order order)
```
    Rearranges POJO's methods in order they will be tried to produce the POJO. Default strategy consist of putting methods with more parameters to be tried first.
    
    Specified by:
    
    sort in interface DataProviderStrategy
    
    Parameters:
    
    methods - Array of POJO's methods
    
    order - DataProviderStrategy.Order how to sort constructors
  - addOrReplaceTypeManufacturer
```
public <T> DataProviderStrategy addOrReplaceTypeManufacturer(Class<? extends T> type,
                                                             TypeManufacturer<T> typeManufacturer)
```
    Registers @TypeManufacturer implementation, which will be used to instantiate objects of a specified type. Use this to alter factory behaviour.
    
    Specified by:
    
    addOrReplaceTypeManufacturer in interface DataProviderStrategy
    
    Type Parameters:
    
    T - type of objects to be produced by the manufacturer
    
    Parameters:
    
    type - the specific class type the specified manufacturer will instantiate.
    
    typeManufacturer - type manufacturer implementation to be registered
    
    Returns:
    
    itself
  - removeTypeManufacturer
```
public <T> DataProviderStrategy removeTypeManufacturer(Class<T> type)
```
    Remove binding of a class type to a specific implementation of type manufacturer
    
    Specified by:
    
    removeTypeManufacturer in interface DataProviderStrategy
    
    Type Parameters:
    
    T - type of objects to be produced by the manufacturer
    
    Parameters:
    
    type - the specific class type to remove binding
    
    Returns:
    
    itself
  - getTypeValue
```
public <T> T getTypeValue(AttributeMetadata attributeMetadata,
                          ManufacturingContext manufacturingCtx,
                          Class<T> pojoType)
```
    Obtains a type value
    
    Specified by:
    
    getTypeValue in interface DataProviderStrategy
    
    Type Parameters:
    
    T - type of returned object
    
    Parameters:
    
    attributeMetadata - The AttributeMetadata information
    
    manufacturingCtx - The pojo manufacturing context with generic attribute type argument types
    
    pojoType - The class of the requested type
    
    Returns:
    
    The type value
  - addOrReplaceFactory
```
public <T> AbstractRandomDataProviderStrategy addOrReplaceFactory(Class<T> abstractClass,
                                                                  Class<?> factoryClass)
```
    Binds an interface/abstract class to its factory. If the strategy previously contained a binding for the interface/abstract class, the old value is replaced by the new value. If you want to implement more sophisticated binding strategy, override this class.
    
    Specified by:
    
    addOrReplaceFactory in interface RandomDataProviderStrategy
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    abstractClass - the interface/abstract class to bind
    
    factoryClass - factory class for instantiation of abstractClass.
    
    Returns:
    
    itself
  - removeFactory
```
public <T> AbstractRandomDataProviderStrategy removeFactory(Class<T> abstractClass)
```
    Remove binding of an interface/abstract class to its factory
    
    Specified by:
    
    removeFactory in interface RandomDataProviderStrategy
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    abstractClass - the interface/abstract class to remove binding
    
    Returns:
    
    itself
  - getFactoryClass
```
public Class<?> getFactoryClass(Class<?> nonInstantiatableClass)
```
    Resolves factory classes for abstract classes and interfaces.
    Should return factory class type, which can be used to instantiate an abstract class type or interface.
    
    Specified by:
    
    getFactoryClass in interface DataProviderStrategy
    
    Parameters:
    
    nonInstantiatableClass - Abstract class type or interface
    
    Returns:
    
    Non-abstract factory class type to instantiate nonInstantiatableClass.
  - addOrReplaceSpecific
```
public <T> DataProviderStrategy addOrReplaceSpecific(Class<T> abstractClass,
                                                     Class<? extends T> specificClass)
```
    Bind an interface/abstract class to a specific implementation. If the strategy previously contained a binding for the interface/abstract class, the old value will not be replaced by the new value. If you want to force the value replacement, invoke removeSpecific before invoking this method. If you want to implement more sophisticated binding strategy, override this class.
    
    Specified by:
    
    addOrReplaceSpecific in interface DataProviderStrategy
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    abstractClass - the interface/abstract class to bind
    
    specificClass - the specific class implementing or extending abstractClass.
    
    Returns:
    
    itself
  - removeSpecific
```
public <T> DataProviderStrategy removeSpecific(Class<T> abstractClass)
```
    Remove binding of an interface/abstract class to a specific implementation
    
    Specified by:
    
    removeSpecific in interface DataProviderStrategy
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    abstractClass - the interface/abstract class to remove binding
    
    Returns:
    
    itself
  - getSpecificClass
```
public <T> Class<? extends T> getSpecificClass(Class<T> nonInstantiatableClass)
```
    Resolves abstract classes and interfaces.
    Should return specific class type, which can be instantiated and assigned to abstract class type or interface.
    
    Specified by:
    
    getSpecificClass in interface DataProviderStrategy
    
    Type Parameters:
    
    T - The type of class being resolved
    
    Parameters:
    
    nonInstantiatableClass - Abstract class type or interface
    
    Returns:
    
    Non-abstract class type derived from nonInstantiatableClass.
  - addOrReplaceAttributeStrategy
```
public RandomDataProviderStrategy addOrReplaceAttributeStrategy(Class<? extends Annotation> annotationClass,
                                                                AttributeStrategy<?> attributeStrategy)
```
    Bind an annotation to attribute strategy class. If the strategy previously contained a binding for the annotation, the old will be replaced. If you want to implement more sophisticated binding strategy, override this class.
    
    Specified by:
    
    addOrReplaceAttributeStrategy in interface RandomDataProviderStrategy
    
    Parameters:
    
    annotationClass - the annotation class
    
    attributeStrategy - the attribute strategy
    
    Returns:
    
    itself
  - removeAttributeStrategy
```
public RandomDataProviderStrategy removeAttributeStrategy(Class<? extends Annotation> annotationClass)
```
    Remove binding of an annotation to attribute strategy
    
    Specified by:
    
    removeAttributeStrategy in interface RandomDataProviderStrategy
    
    Parameters:
    
    annotationClass - the annotation class to remove binding
    
    Returns:
    
    itself
  - getStrategyForAnnotation
```
public AttributeStrategy<?> getStrategyForAnnotation(Class<? extends Annotation> annotationClass)
```
    Finds attribute strategies for annotations.
    Searches for mapping between annotations and attribute strategies, which will be used then for populating fields or constructor parameters.
    
    Specified by:
    
    getStrategyForAnnotation in interface DataProviderStrategy
    
    Parameters:
    
    annotationClass - Annotation class to inspect
    
    Returns:
    
    attribute strategy associated with given annotation
  - addOrReplaceAttributeStrategy
```
public RandomDataProviderStrategy addOrReplaceAttributeStrategy(Class<?> type,
                                                                String attributeName,
                                                                AttributeStrategy<?> attributeStrategy)
```
    Registers @AttributeStrategy implementation, which will be used to instantiate objects of a specified type. Use this to alter factory behaviour.
    
    Specified by:
    
    addOrReplaceAttributeStrategy in interface DataProviderStrategy
    
    Parameters:
    
    type - the specific class type the specified manufacturer will instantiate.
    
    attributeName - attribute name to use attributeStrategy for
    
    attributeStrategy - attribute strategy to be registered
    
    Returns:
    
    itself
  - removeAttributeStrategy
```
public RandomDataProviderStrategy removeAttributeStrategy(Class<?> type,
                                                          String attributeName)
```
    Removes @AttributeStrategy implementation from for the specific attribute
    
    Specified by:
    
    removeAttributeStrategy in interface DataProviderStrategy
    
    Parameters:
    
    type - the specific class type the specified manufacturer will instantiate.
    
    attributeName - attribute name to use attributeStrategy for
    
    Returns:
    
    itself
  - getStrategyForAttribute
```
public AttributeStrategy<?> getStrategyForAttribute(ClassAttribute attribute)
```
    Finds attribute strategies for attribute.
    Searches for mapping between class attribute and attribute strategies, which will be used then for populating fields or constructor parameters.
    
    Specified by:
    
    getStrategyForAttribute in interface DataProviderStrategy
    
    Parameters:
    
    attribute - attribute to be manufactured
    
    Returns:
    
    attribute strategy associated with given attribute
  - getConstructorLightComparator
```
public AbstractConstructorComparator getConstructorLightComparator()
```
    Getter for constructor light comparator.
    
    Specified by:
    
    getConstructorLightComparator in interface RandomDataProviderStrategy
    
    Returns:
    
    current constructor comparator used by strategy
  - setConstructorLightComparator
```
public void setConstructorLightComparator(AbstractConstructorComparator constructorLightComparator)
```
    Setter for constructor öight comparator.
    Default implementations are ConstructorHeavyFirstComparator and ConstructorLightFirstComparator.
    
    Specified by:
    
    setConstructorLightComparator in interface RandomDataProviderStrategy
    
    Parameters:
    
    constructorLightComparator - constructor comparator to set
  - getConstructorHeavyComparator
```
public AbstractConstructorComparator getConstructorHeavyComparator()
```
    Getter for constructor heavy comparator.
    
    Specified by:
    
    getConstructorHeavyComparator in interface RandomDataProviderStrategy
    
    Returns:
    
    current constructor comparator used by strategy
  - setConstructorHeavyComparator
```
public void setConstructorHeavyComparator(AbstractConstructorComparator constructorHeavyComparator)
```
    Setter for constructor heavy comparator.
    Default implementations are ConstructorHeavyFirstComparator and ConstructorLightFirstComparator.
    
    Specified by:
    
    setConstructorHeavyComparator in interface RandomDataProviderStrategy
    
    Parameters:
    
    constructorHeavyComparator - constructor comparator to set
  - getMethodLightComparator
```
public AbstractMethodComparator getMethodLightComparator()
```
    Getter for method light comparator.
    
    Specified by:
    
    getMethodLightComparator in interface RandomDataProviderStrategy
    
    Returns:
    
    current method comparator used by strategy
  - setMethodLightComparator
```
public void setMethodLightComparator(AbstractMethodComparator methodLightComparator)
```
    Setter for method light comparator.
    Default implementations is MethodHeavyFirstComparator.
    
    Specified by:
    
    setMethodLightComparator in interface RandomDataProviderStrategy
    
    Parameters:
    
    methodLightComparator - method comparator to set
  - getMethodHeavyComparator
```
public AbstractMethodComparator getMethodHeavyComparator()
```
    Getter for method heavy comparator.
    
    Specified by:
    
    getMethodHeavyComparator in interface RandomDataProviderStrategy
    
    Returns:
    
    current method comparator used by strategy
  - setMethodHeavyComparator
```
public void setMethodHeavyComparator(AbstractMethodComparator methodHeavyComparator)
```
    Setter for method heavy comparator.
    Default implementations is MethodHeavyFirstComparator.
    
    Specified by:
    
    setMethodHeavyComparator in interface RandomDataProviderStrategy
    
    Parameters:
    
    methodHeavyComparator - method comparator to set
  - log
```
private void log(AttributeMetadata attributeMetadata)
```

Class AbstractRandomDataProviderStrategy

Nested Class Summary

Nested classes/interfaces inherited from interface uk.co.jemos.podam.api.DataProviderStrategy

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

maxDepth

nbrOfCollectionElements

isMemoizationEnabled

memoizationTable

typeManufacturers

specificTypes

factoryTypes

attributeStrategies

attributeClassStrategies

constructorHeavyComparator

constructorLightComparator

methodHeavyComparator

methodLightComparator

Constructor Detail

AbstractRandomDataProviderStrategy

AbstractRandomDataProviderStrategy

Method Detail

getNumberOfCollectionElements

setDefaultNumberOfCollectionElements

getMaxDepth

setMaxDepth

isMemoizationEnabled

setMemoization

getMemoizedObject

cacheMemoizedObject

clearMemoizationCache

sort

sort

addOrReplaceTypeManufacturer

removeTypeManufacturer

getTypeValue

addOrReplaceFactory

removeFactory

getFactoryClass

addOrReplaceSpecific

removeSpecific

getSpecificClass

addOrReplaceAttributeStrategy

removeAttributeStrategy

getStrategyForAnnotation

addOrReplaceAttributeStrategy

removeAttributeStrategy

getStrategyForAttribute

getConstructorLightComparator

setConstructorLightComparator

getConstructorHeavyComparator

setConstructorHeavyComparator

getMethodLightComparator

setMethodLightComparator

getMethodHeavyComparator

setMethodHeavyComparator

log