Configuration (42 Bean Mapper 2.4.0 API)

All Known Implementing Classes:

CoreConfiguration, OverrideConfiguration
```
public interface Configuration
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addAfterClearFlusher(AfterClearFlusher afterClearFlusher)` After BeanMapper calls the clear() method on a collection, it will check for the presence of AfterClearFlusher instances.
`void`	`addBeanPairWithStrictSource(Class source, Class target)` Adds a new pair of classes of which the source is strict.
`void`	`addBeanPairWithStrictTarget(Class source, Class target)` Adds a new pair of classes of which the target is strict.
`void`	`addCollectionHandler(CollectionHandler collectionHandler)` Registers a collection handler to the configuration.
`void`	`addConverter(BeanConverter converter)` Add a converter class (must inherit from abstract BeanConverter class) to the beanMapper.
`void`	`addLogicSecuredCheck(LogicSecuredCheck logicSecuredCheck)` Add a check instance that takes the source and target instances and on the basis of those two determines whether access must be provided
`void`	`addPackagePrefix(Class<?> clazz)` Adds a package on the basis of a class.
`void`	`addPackagePrefix(String packagePrefix)` Adds a package on the basis of a class.
`void`	`addProxySkipClass(Class<?> clazz)` Add classes to skip while unproxying to prevent failing of the BeanMapper while mapping proxy classes or classes containing synthetic fields (Like ENUM types).
`Class`	`determineTargetClass()` On the basis of the target, the targetClass will be determined
`void`	`downsizeSource(List<String> includeFields)` Sets the field to downsize the source class.
`void`	`downsizeTarget(List<String> includeFields)` Sets the only fields that are allowed in the target class.
`List<BeanConverter>`	`getBeanConverters()`
`BeanInitializer`	`getBeanInitializer()`
`BeanMatchStore`	`getBeanMatchStore()` Always use the CoreConfiguration beanmatch store
`List<BeanPair>`	`getBeanPairs()` Returns the entire list of strict bean pairs.
`BeanUnproxy`	`getBeanUnproxy()`
`ClassStore`	`getClassStore()` Always use the CoreConfiguration class store
`Class`	`getCollectionClass()` The class that represents the collection itself.
`CollectionFlusher`	`getCollectionFlusher()` Returns the collection clearer, which takes care of calling the clear method on a collection.
`CollectionHandler`	`getCollectionHandlerFor(Class<?> clazz)` Finds the correction handler for the class.
`CollectionHandler`	`getCollectionHandlerForCollectionClass()` Finds the collection handler for the collection class, null if not exists
`List<CollectionHandler>`	`getCollectionHandlers()` Returns the list of registered collection handlers.
`BeanCollectionUsage`	`getCollectionUsage()` Returns the type of collection usage for the current collection mapping
`List<String>`	`getDownsizeSource()` When include fields are passed, BeanMapper will assume that the generation (or reuse) of a dynamic class is required.
`List<String>`	`getDownsizeTarget()` When include fields are passed, BeanMapper will assume that the generation (or reuse) of a dynamic class is required.
`Boolean`	`getEnforceSecuredProperties()` Property that determines if secured properties must be handled.
`Map<Class<? extends LogicSecuredCheck>,LogicSecuredCheck>`	`getLogicSecuredChecks()`
`List<String>`	`getPackagePrefixes()`
`Object`	`getParent()` The active parent for the field that is currently being mapped.
`Class<?>`	`getPreferredCollectionClass()` Gets the preferred collection class to be instantiated.
`RoleSecuredCheck`	`getRoleSecuredCheck()` The RoleSecuredCheck is responsible for checking if a Principal may access a field or method annotated with @BeanRoleSecured.
`StrictMappingProperties`	`getStrictMappingProperties()` Returns the collection of strictSourceSuffix, strictTargetSuffix and applyStrictMappingConvention properties.
`String`	`getStrictSourceSuffix()` Returns the classname suffix that determines a source class is to be treated as strict with regards to mapping.
`String`	`getStrictTargetSuffix()` Returns the classname suffix that determines a target class is to be treated as strict with regards to mapping.
`Object`	`getTarget()` The target to map to.
`Class`	`getTargetClass()` The class that represents the target class.
`boolean`	`isAddDefaultConverters()`
`Boolean`	`isApplyStrictMappingConvention()` Determines if strict mapping convention will be applied.
`Boolean`	`isConverterChoosable()`
`Boolean`	`isFlushAfterClear()` Determines if the flush-chain must be called after a clear() operation on a collection has taken place.
`Boolean`	`isFlushEnabled()` Determines if flushing has been enabled.
`Boolean`	`mustFlush()` Works on the combination of the global flush setting (flushEnabled) and the specific flush setting (flushAfterClear).
`void`	`setApplyStrictMappingConvention(Boolean applyStrictMappingConvention)` Determines if strict mapping convention will be applied.
`void`	`setBeanInitializer(BeanInitializer beanInitializer)`
`void`	`setBeanUnproxy(BeanUnproxy beanUnproxy)`
`void`	`setCollectionClass(Class collectionClass)` Sets the collection class of the collection.
`void`	`setCollectionUsage(BeanCollectionUsage collectionUsage)` Sets the collection usage for the current collection mapping
`void`	`setConverterChoosable(boolean converterChoosable)`
`void`	`setEnforceSecuredProperties(Boolean enforceSecuredProperties)` Property that determines if secured properties must be handled.
`void`	`setFlushAfterClear(Boolean flushAfterClear)` Determines whether the flush-chain must be called after a clear has taken place.
`void`	`setFlushEnabled(Boolean flushEnabled)` Set whether flushing must be enabled.
`void`	`setParent(Object parent)` The active parent for the field that is currently being mapped.
`void`	`setPreferredCollectionClass(Class<?> preferredCollectionClass)` Sets the preferred collection class to be instantiated.
`void`	`setRoleSecuredCheck(RoleSecuredCheck roleSecuredCheck)` The RoleSecuredCheck is responsible for checking if a Principal may access a field or method annotated with @BeanRoleSecured.
`void`	`setStrictSourceSuffix(String strictSourceSuffix)` Sets the classname suffix that determines a source class is to be treated as strict with regards to mapping.
`void`	`setStrictTargetSuffix(String strictTargetSuffix)` Sets the classname suffix that determines a target class is to be treated as strict with regards to mapping.
`void`	`setTarget(Object target)` Sets the target.
`void`	`setTargetClass(Class targetClass)` Sets the target class.
`void`	`withoutDefaultConverters()`

- Method Detail
  - getDownsizeTarget
```
List<String> getDownsizeTarget()
```
    When include fields are passed, BeanMapper will assume that the generation (or reuse) of a dynamic class is required. For this, DynamicBeanMapper is used. Note that include fields is a marker field which impact the selection of the mapping strategy. Include fields never refer to the parent configuration.
    
    Returns:
    
    the fields to include in the target
  - getDownsizeSource
```
List<String> getDownsizeSource()
```
    When include fields are passed, BeanMapper will assume that the generation (or reuse) of a dynamic class is required. For this, DynamicBeanMapper is used. Note that include fields is a marker field which impact the selection of the mapping strategy. Include fields never refer to the parent configuration.
    
    Returns:
    
    the fields to include in the source
  - getCollectionClass
```
Class getCollectionClass()
```
    The class that represents the collection itself. Used to instantiate a collection. Note that collection class is a marker field which impact the selection of the mapping strategy. Collection class never refers to the parent configuration.
    
    Returns:
    
    class of the collection
  - getTargetClass
```
Class getTargetClass()
```
    The class that represents the target class. Used to instantiate a target for the mapping. Note that target class is a marker field which impact the selection of the mapping strategy. Target class never refers to the parent configuration.
    
    Returns:
    
    class of the target
  - getTarget
```
Object getTarget()
```
    The target to map to. Note that collection class is a marker field which impact the selection of the mapping strategy. Target never refers to the parent configuration.
    
    Returns:
    
    class of the collection
  - getParent
```
Object getParent()
```
    The active parent for the field that is currently being mapped. This is always a parent on the target side of BeanMapper. @BeanParent makes us of this variable to assign to a field
    
    Returns:
    
    the parent of the active field
  - getBeanInitializer
```
BeanInitializer getBeanInitializer()
```
  - getBeanUnproxy
```
BeanUnproxy getBeanUnproxy()
```
  - getBeanMatchStore
```
BeanMatchStore getBeanMatchStore()
```
    Always use the CoreConfiguration beanmatch store
    
    Returns:
    
    the one beanmatch store
  - getClassStore
```
ClassStore getClassStore()
```
    Always use the CoreConfiguration class store
    
    Returns:
    
    the one class store
  - getPackagePrefixes
```
List<String> getPackagePrefixes()
```
  - getBeanConverters
```
List<BeanConverter> getBeanConverters()
```
  - getLogicSecuredChecks
```
Map<Class<? extends LogicSecuredCheck>,LogicSecuredCheck> getLogicSecuredChecks()
```
  - getCollectionHandlers
```
List<CollectionHandler> getCollectionHandlers()
```
    Returns the list of registered collection handlers. The handlers are used to deal with the complexities of mapping between collections. Methods for copying, clearing and construction are supplied.
    
    Returns:
    
    the list of registered collection handlers
  - getCollectionHandlerFor
```
CollectionHandler getCollectionHandlerFor(Class<?> clazz)
```
    Finds the correction handler for the class. Null, if not found.
    
    Parameters:
    
    clazz - class to find the correct collection handler for
    
    Returns:
    
    collection handler for the class, or null if not found
  - getCollectionHandlerForCollectionClass
```
CollectionHandler getCollectionHandlerForCollectionClass()
```
    Finds the collection handler for the collection class, null if not exists
    
    Returns:
    
    the collection handler for the collection class, null if not exists
  - getBeanPairs
```
List<BeanPair> getBeanPairs()
```
    Returns the entire list of strict bean pairs. The properties on the strict side must have matching properties on the other, non-strict side.
    
    Returns:
    
    the entire list of strict bean pairs.
  - isConverterChoosable
```
Boolean isConverterChoosable()
```
  - withoutDefaultConverters
```
void withoutDefaultConverters()
```
  - getStrictSourceSuffix
```
String getStrictSourceSuffix()
```
    Returns the classname suffix that determines a source class is to be treated as strict with regards to mapping. Default is "Form"
    
    Returns:
    
    the source classname suffix for a class to be treated as strict
  - getStrictTargetSuffix
```
String getStrictTargetSuffix()
```
    Returns the classname suffix that determines a target class is to be treated as strict with regards to mapping. Default is "Result"
    
    Returns:
    
    the target classname suffix for a class to be treated as strict
  - isApplyStrictMappingConvention
```
Boolean isApplyStrictMappingConvention()
```
    Determines if strict mapping convention will be applied. This means that if a source class has the strict source suffix, or a target class has the strict target suffix, the classes will be treated as if they are strict. This implies that all of their properties will require matching properties on the other side. Default is true.
    
    Returns:
    
    if true, the strict mapping convention will be applied
  - getStrictMappingProperties
```
StrictMappingProperties getStrictMappingProperties()
```
    Returns the collection of strictSourceSuffix, strictTargetSuffix and applyStrictMappingConvention properties.
    
    Returns:
    
    all properties required for dealing with the strict mapping convention
  - getCollectionUsage
```
BeanCollectionUsage getCollectionUsage()
```
    Returns the type of collection usage for the current collection mapping
    
    Returns:
    
    collection usage to apply
  - getPreferredCollectionClass
```
Class<?> getPreferredCollectionClass()
```
    Gets the preferred collection class to be instantiated. If it has this choice, it will use this class over the one provided by the collection handler.
    
    Returns:
    
    the collection class to prefer for instantiation
  - getCollectionFlusher
```
CollectionFlusher getCollectionFlusher()
```
    Returns the collection clearer, which takes care of calling the clear method on a collection. If required, it will also call the list of flushers registered to it.
    
    Returns:
    
    the collection clearer
  - isFlushAfterClear
```
Boolean isFlushAfterClear()
```
    Determines if the flush-chain must be called after a clear() operation on a collection has taken place.
    
    Returns:
    
    true if the flush-chain must be called after a clear
  - isFlushEnabled
```
Boolean isFlushEnabled()
```
    Determines if flushing has been enabled. Flushing is the calling of flush() on a collection after it has been cleared. This force an ORM to run its delete queries. Default setting is false, because flushing is tied closely to having a transaction context. If, this is not the case, the flush will throw an exception.
    
    Returns:
    
    whether flushing has been enabled
  - mustFlush
```
Boolean mustFlush()
```
    Works on the combination of the global flush setting (flushEnabled) and the specific flush setting (flushAfterClear). If both are true, the flush will trigger.
    
    Returns:
    
    true if a flush after clear must take place
  - getRoleSecuredCheck
```
RoleSecuredCheck getRoleSecuredCheck()
```
    The RoleSecuredCheck is responsible for checking if a Principal may access a field or method annotated with @BeanRoleSecured. Returns the RoleSecuredCheck, if it has been configured.
    
    Returns:
    
    the active RoleSecuredCheck, if set. Otherwise, null
  - getEnforceSecuredProperties
```
Boolean getEnforceSecuredProperties()
```
    Property that determines if secured properties must be handled. If this is set to true and the RoleSecuredCheck has not been set, an exception will be thrown.
    
    Returns:
    
    whether the handling of secured properties is enforced
  - addConverter
```
void addConverter(BeanConverter converter)
```
    Add a converter class (must inherit from abstract BeanConverter class) to the beanMapper. On mapping, the beanMapper will check for a suitable converter and use its from and to methods to convert the value of the fields to the correct new data type.
    
    Parameters:
    
    converter - an instance of the class that contains the conversion method implementations and inherits from the abstract BeanConverter class.
  - addLogicSecuredCheck
```
void addLogicSecuredCheck(LogicSecuredCheck logicSecuredCheck)
```
    Add a check instance that takes the source and target instances and on the basis of those two determines whether access must be provided
    
    Parameters:
    
    logicSecuredCheck - the check instance to register
  - addCollectionHandler
```
void addCollectionHandler(CollectionHandler collectionHandler)
```
    Registers a collection handler to the configuration. The Collection handlers supply the underlying mechanism for dealing with mapping from and to collections. They supply methods for copying, clearing and construction.
    
    Parameters:
    
    collectionHandler - the collection handler to register
  - addBeanPairWithStrictSource
```
void addBeanPairWithStrictSource(Class source,
                                 Class target)
```
    Adds a new pair of classes of which the source is strict. The strict side must match for all public fields and getter properties.
    
    Parameters:
    
    source - the source class that must match, also the strict side of the pair
    
    target - the target class that must match
  - addBeanPairWithStrictTarget
```
void addBeanPairWithStrictTarget(Class source,
                                 Class target)
```
    Adds a new pair of classes of which the target is strict. The strict side must match for all public fields and setter properties.
    
    Parameters:
    
    source - the source class that must match
    
    target - the target class that must match, also the strict side of the pair
  - addProxySkipClass
```
void addProxySkipClass(Class<?> clazz)
```
    Add classes to skip while unproxying to prevent failing of the BeanMapper while mapping proxy classes or classes containing synthetic fields (Like ENUM types).
    
    Parameters:
    
    clazz - the class that is added to the list of skipped classes
  - addPackagePrefix
```
void addPackagePrefix(Class<?> clazz)
```
    Adds a package on the basis of a class. All classes in that package and sub-packages are eligible for mapping. The root source and target do not need to be set as such, because the verification is only run against nested classes which should be mapped implicity as well
    
    Parameters:
    
    clazz - the class which sets the package prefix for all mappable classes
  - addPackagePrefix
```
void addPackagePrefix(String packagePrefix)
```
    Adds a package on the basis of a class. All classes in that package and sub-packages are eligible for mapping. The root source and target do not need to be set as such, because the verification is only run against nested classes which should be mapped implicity as well
    
    Parameters:
    
    packagePrefix - the String which sets the package prefix for all mappable classes
  - addAfterClearFlusher
```
void addAfterClearFlusher(AfterClearFlusher afterClearFlusher)
```
    After BeanMapper calls the clear() method on a collection, it will check for the presence of AfterClearFlusher instances. All instances found will be executed. The use case triggering this functionality is the fact that Hibernate's @OneToMany first executes insert SQL-statements, before the delete SQL statements. With constraints, this is an issue. By forcing the flush after a clear, Hibernate is forced to first execute its delete SQL-statements, before the inserts.
    
    Parameters:
    
    afterClearFlusher - the flusher to be added to the call stack after a clear call
  - setBeanInitializer
```
void setBeanInitializer(BeanInitializer beanInitializer)
```
  - setBeanUnproxy
```
void setBeanUnproxy(BeanUnproxy beanUnproxy)
```
  - isAddDefaultConverters
```
boolean isAddDefaultConverters()
```
  - setConverterChoosable
```
void setConverterChoosable(boolean converterChoosable)
```
  - downsizeSource
```
void downsizeSource(List<String> includeFields)
```
    Sets the field to downsize the source class. THe limited source class is mapped over the given target class.
    
    Parameters:
    
    includeFields - The fields to be mapped to the target class.
  - downsizeTarget
```
void downsizeTarget(List<String> includeFields)
```
    Sets the only fields that are allowed in the target class. If the include fields are set, it impacts the usage of the mapping strategy. Note that getting this field never refers to the parent configuration.
    
    Parameters:
    
    includeFields - The field that are allowed in the target class.
  - setCollectionClass
```
void setCollectionClass(Class collectionClass)
```
    Sets the collection class of the collection. Used to instantiate the collection. If the collection class is set, it impacts the usage of the mapping strategy. Note that getting this field never refers to the parent configuration.
    
    Parameters:
    
    collectionClass - the class type of the collection
  - setTargetClass
```
void setTargetClass(Class targetClass)
```
    Sets the target class. Used to instantiate the target. If this class is set, it impact the usage of the mapping strategy. Note that getting this field never refers to the parent configuration.
    
    Parameters:
    
    targetClass - the class type of the target
  - setTarget
```
void setTarget(Object target)
```
    Sets the target. If the target is set, it impact the usage of the mapping strategy. Note that getting this field never refers to the parent configuration.
    
    Parameters:
    
    target - the target instance to map to
  - setParent
```
void setParent(Object parent)
```
    The active parent for the field that is currently being mapped. This is always a parent on the target side of BeanMapper. @BeanParent makes us of this variable to assign to a field
    
    Parameters:
    
    parent - the parent of the active field
  - determineTargetClass
```
Class determineTargetClass()
```
    On the basis of the target, the targetClass will be determined
    
    Returns:
    
    the class of the target
  - setStrictSourceSuffix
```
void setStrictSourceSuffix(String strictSourceSuffix)
```
    Sets the classname suffix that determines a source class is to be treated as strict with regards to mapping. Default is "Form"
    
    Parameters:
    
    strictSourceSuffix - the source classname suffix for a class to be treated as strict
  - setStrictTargetSuffix
```
void setStrictTargetSuffix(String strictTargetSuffix)
```
    Sets the classname suffix that determines a target class is to be treated as strict with regards to mapping. Default is "Result"
    
    Parameters:
    
    strictTargetSuffix - the target classname suffix for a class to be treated as strict
  - setApplyStrictMappingConvention
```
void setApplyStrictMappingConvention(Boolean applyStrictMappingConvention)
```
    Determines if strict mapping convention will be applied. This means that if a source class has the strict source suffix, or a target class has the strict target suffix, the classes will be treated as if they are strict. This implies that all of their properties will require matching properties on the other side. Default is true.
    
    Parameters:
    
    applyStrictMappingConvention - whether the strict mapping convention must be applied
  - setCollectionUsage
```
void setCollectionUsage(BeanCollectionUsage collectionUsage)
```
    Sets the collection usage for the current collection mapping
    
    Parameters:
    
    collectionUsage - the collection usage to apply
  - setPreferredCollectionClass
```
void setPreferredCollectionClass(Class<?> preferredCollectionClass)
```
    Sets the preferred collection class to be instantiated. If it has this choice, it will use this class over the one provided by the collection handler.
    
    Parameters:
    
    preferredCollectionClass - the collection class to prefer for instantiation
  - setFlushAfterClear
```
void setFlushAfterClear(Boolean flushAfterClear)
```
    Determines whether the flush-chain must be called after a clear has taken place.
    
    Parameters:
    
    flushAfterClear - true if the flush-chain must be called
  - setFlushEnabled
```
void setFlushEnabled(Boolean flushEnabled)
```
    Set whether flushing must be enabled. Flushing is the calling of flush() on a collection after it has been cleared. This force an ORM to run its delete queries. Default setting is false, because flushing is tied closely to having a transaction context. If, this is not the case, the flush will throw an exception.
    
    Parameters:
    
    flushEnabled - whether flushing has been enabled
  - setRoleSecuredCheck
```
void setRoleSecuredCheck(RoleSecuredCheck roleSecuredCheck)
```
    The RoleSecuredCheck is responsible for checking if a Principal may access a field or method annotated with @BeanRoleSecured.
    
    Parameters:
    
    roleSecuredCheck - the new active RoleSecuredCheck
  - setEnforceSecuredProperties
```
void setEnforceSecuredProperties(Boolean enforceSecuredProperties)
```
    Property that determines if secured properties must be handled. If this is set to true and the RoleSecuredCheck has not been set, an exception will be thrown.
    
    Parameters:
    
    enforceSecuredProperties - whether the handling of secured properties is enforced

Interface Configuration

Method Summary

Method Detail

getDownsizeTarget

getDownsizeSource

getCollectionClass

getTargetClass

getTarget

getParent

getBeanInitializer

getBeanUnproxy

getBeanMatchStore

getClassStore

getPackagePrefixes

getBeanConverters

getLogicSecuredChecks

getCollectionHandlers

getCollectionHandlerFor

getCollectionHandlerForCollectionClass

getBeanPairs

isConverterChoosable

withoutDefaultConverters

getStrictSourceSuffix

getStrictTargetSuffix

isApplyStrictMappingConvention

getStrictMappingProperties

getCollectionUsage

getPreferredCollectionClass

getCollectionFlusher

isFlushAfterClear

isFlushEnabled

mustFlush

getRoleSecuredCheck

getEnforceSecuredProperties

addConverter

addLogicSecuredCheck

addCollectionHandler

addBeanPairWithStrictSource

addBeanPairWithStrictTarget

addProxySkipClass

addPackagePrefix

addPackagePrefix

addAfterClearFlusher

setBeanInitializer

setBeanUnproxy

isAddDefaultConverters

setConverterChoosable

downsizeSource

downsizeTarget

setCollectionClass

setTargetClass

setTarget

setParent

determineTargetClass

setStrictSourceSuffix

setStrictTargetSuffix

setApplyStrictMappingConvention

setCollectionUsage

setPreferredCollectionClass

setFlushAfterClear

setFlushEnabled

setRoleSecuredCheck

setEnforceSecuredProperties