DefaultMapperFactory (Orika

java.lang.Object
- ma.glasnost.orika.impl.DefaultMapperFactory

All Implemented Interfaces:

MapperFactory, StateReporter.Reportable
```
public class DefaultMapperFactory
extends Object
implements MapperFactory, StateReporter.Reportable
```
The mapper factory is the heart of Orika, a small container where metadata are stored, it's used by other components, to look up for generated mappers, converters, object factories ... etc.

Author:

S.M. El Aatifi

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`DefaultMapperFactory.Builder` Use this builder to generate instances of DefaultMapperFactory with the desired customizations. For example, an instance with no customizations could be generated with the following code:
`static class`	`DefaultMapperFactory.MapperFactoryBuilder<F extends DefaultMapperFactory,B extends DefaultMapperFactory.MapperFactoryBuilder<F,B>>` MapperFactoryBuilder provides an extensible Builder definition usable for providing your own Builder class for subclasses of DefaultMapperFactory. See the defined `DefaultMapperFactory.Builder` below for example of how to subclass.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`alwaysCreateMultipleMapperWrapper`
`protected ClassMapBuilderFactory`	`chainClassMapBuilderFactory`
`protected ClassMapBuilderFactory`	`classMapBuilderFactory`
`protected ConcurrentHashMap<MapperKey,ClassMap<Object,Object>>`	`classMapRegistry`
`protected CompilerStrategy`	`compilerStrategy`
`protected Map<Type,Type<?>>`	`concreteTypeRegistry`
`protected MappingContextFactory`	`contextFactory`
`protected ConverterFactory`	`converterFactory`
`protected List<DefaultFieldMapper>`	`defaultFieldMappers`
`protected ConcurrentHashMap<Type<?>,Set<Type<?>>>`	`dynamicAToBRegistry`
`protected ExceptionUtility`	`exceptionUtil`
`protected ConcurrentHashMap<Type<?>,Set<Type<?>>>`	`explicitAToBRegistry`
`protected boolean`	`favorExtension`
`protected SortedCollection<Filter<Object,Object>>`	`filtersRegistry`
`protected boolean`	`isBuilding`
`protected boolean`	`isBuilt`
`protected MapperFacade`	`mapperFacade`
`protected MapperGenerator`	`mapperGenerator`
`protected SortedCollection<Mapper<Object,Object>>`	`mappersRegistry`
`protected MappingContextFactory`	`nonCyclicContextFactory`
`protected ObjectFactoryGenerator`	`objectFactoryGenerator`
`protected ConcurrentHashMap<Type<? extends Object>,ConcurrentHashMap<Type<? extends Object>,ObjectFactory<? extends Object>>>`	`objectFactoryRegistry`
`protected PropertyResolverStrategy`	`propertyResolverStrategy`
`protected UnenhanceStrategy`	`unenhanceStrategy`
`protected boolean`	`useAutoMapping`
`protected boolean`	`useBuiltinConverters`
`protected Map<MapperKey,Set<ClassMap<Object,Object>>>`	`usedMapperMetadataRegistry`
`protected UnenhanceStrategy`	`userUnenahanceStrategy`

Constructor Summary

Constructors
Modifier Constructor and Description

protected DefaultMapperFactory(DefaultMapperFactory.MapperFactoryBuilder<?,?> builder)
Constructs a new instance of DefaultMapperFactory

Constructors
Modifier	Constructor and Description
`protected`	`DefaultMapperFactory(DefaultMapperFactory.MapperFactoryBuilder<?,?> builder)` Constructs a new instance of DefaultMapperFactory

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`addClassMapBuilderFactory(ClassMapBuilderFactory factory)` Add factory to the factories chain
`void`	`build()` Builds this MapperFactory.
`protected MapperFacade`	`buildMapperFacade(MappingContextFactory contextFactory, UnenhanceStrategy unenhanceStrategy)` Builds the MapperFacade for this factory.
`protected UnenhanceStrategy`	`buildUnenhanceStrategy(UnenhanceStrategy unenhanceStrategy, SuperTypeResolverStrategy superTypeStrategy)` Generates the UnenhanceStrategy to be used for this MapperFactory, applying the passed delegateStrategy if not null. This allows the MapperFactory a chance to fill in the unenhance strategy with references to other parts of the factory (registered mappers, converters, object factories) which may be important in the "unenhancing" process.
`<A,B> ClassMapBuilder<A,B>`	`classMap(Class<A> aType, Class<B> bType)` Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types. The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the `registerClassMap` method.
`<A,B> ClassMapBuilder<A,B>`	`classMap(Class<A> aType, Type<B> bType)` Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types. The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the `registerClassMap` method.
`<A,B> ClassMapBuilder<A,B>`	`classMap(Type<A> aType, Class<B> bType)` Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types. The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the `registerClassMap` method.
`<A,B> ClassMapBuilder<A,B>`	`classMap(Type<A> aType, Type<B> bType)` Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types. The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the `registerClassMap` method.
`boolean`	`existsRegisteredMapper(Type<?> sourceType, Type<?> destinationType, boolean includeAutoGeneratedMappers)` Tests for the existence of a registered mapper which corresponds to the supplied mapperKey
`<A,B> ClassMap<A,B>`	`getClassMap(MapperKey mapperKey)` Gets the ClassMap instance (if any) which has been associated with the types represented by the given MapperKey instance.
`protected ClassMapBuilderFactory`	`getClassMapBuilderFactory()`
`ConverterFactory`	`getConverterFactory()` Get an instance of the ConverterFactory associated with this MapperFactory; it may be used to register Converter instances to be used during mapping.
`MapperFacade`	`getMapperFacade()`
`<A,B> BoundMapperFacade<A,B>`	`getMapperFacade(Class<A> aType, Class<B> bType)` Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
`<A,B> BoundMapperFacade<A,B>`	`getMapperFacade(Class<A> aType, Class<B> bType, boolean containsCycles)` Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed. In the case that `false` is provided for the 'containsCycles' parameter, an optimized mapper instance will be provided.
`<S,D> BoundMapperFacade<S,D>`	`getMapperFacade(Type<S> sourceType, Type<D> destinationType)` Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
`<S,D> BoundMapperFacade<S,D>`	`getMapperFacade(Type<S> sourceType, Type<D> destinationType, boolean containsCycles)` Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed. In the case that `false` is provided for the 'containsCycles' parameter, an optimized mapper instance will be provided.
`protected <A,B> Mapper<A,B>`	`getRegisteredMapper(MapperKey mapperKey)`
`UnenhanceStrategy`	`getUserUnenhanceStrategy()` Returns the `UnenhanceStrategy` associated with this MapperFactory, provided when this MapperFactory was constructed.
`<S,D> Type<? extends D>`	`lookupConcreteDestinationType(Type<S> sourceType, Type<D> destinationType, MappingContext context)`
`protected <T,S> ObjectFactory<T>`	`lookupExistingObjectFactory(Type<T> destinationType, Type<S> sourceType, MappingContext context)`
`Set<Type<? extends Object>>`	`lookupMappedClasses(Type<?> type)` Get the set of classes which have been mapped for the specified type.
`<A,B> Mapper<A,B>`	`lookupMapper(MapperKey mapperKey)` Get the Mapper (if any) which has been associated with the given MapperKey.
`Mapper<Object,Object>`	`lookupMapper(MapperKey mapperKey, MappingContext context)` Searches for a Mapper which is capable of mapping the classes identified by the provided MapperKey instance
`<T> ObjectFactory<T>`	`lookupObjectFactory(Type<T> targetType)` Return the object factory (if any) which has been registered for the given type.
`<T,S> ObjectFactory<T>`	`lookupObjectFactory(Type<T> targetType, Type<S> sourceType)` Return the object factory (if any) which has been registered for the given type.
`<T,S> ObjectFactory<T>`	`lookupObjectFactory(Type<T> destinationType, Type<S> sourceType, MappingContext context)` Return the object factory (if any) which has been registered for the given type.
`Set<ClassMap<Object,Object>>`	`lookupUsedClassMap(MapperKey mapperKey)` Lookup the class map hierarchy used for the mapping defined by the specified MapperKey, if any exists
`protected <S,D> void`	`register(Type<S> sourceType, Type<D> destinationType, boolean isAutoGenerated)` Registers that a mapping exists from the specified source type to the specified destination type
`<A,B> void`	`registerClassMap(ClassMap<A,B> classMap)` Registers the given ClassMap instance with the factory; it will be used to configure an appropriate mapping.
`<A,B> void`	`registerClassMap(ClassMapBuilder<A,B> builder)` Registers the ClassMap configured by the specified ClassMapBuilder; it will be used to configure an appropriate mapping.
`void`	`registerConcreteType(Class<?> abstractType, Class<?> concreteType)` Register a concrete type to use when a need arises to generate a new instance of a given abstract type (abstract class or interface)
`void`	`registerConcreteType(Type<?> abstractType, Type<?> concreteType)` Register a concrete type to use when a need arises to generate a new instance of a given abstract type (abstract class or interface)
`void`	`registerDefaultFieldMapper(DefaultFieldMapper... mappers)` Register one or more DefaultFieldMapper instances to be used by this MapperFactory; these instances will be used whenever automatically generating a Mapper for a given pair of types.
`void`	`registerFilter(Filter<?,?> filter)` Registers a filter to be applied in the mapping process; such filters may be used to alter source and destination values of the fields as they are processed by mappers.
`<A,B> void`	`registerMapper(Mapper<A,B> mapper)` Registers the specified custom mapper with the factory; it will be used for mapping between it's configured types.
`void`	`registerMappingHint(MappingHint... hints)` Deprecated.
`<D> void`	`registerObjectFactory(ObjectFactory<D> objectFactory, Type<D> destinationType)` Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType.
`<D,S> void`	`registerObjectFactory(ObjectFactory<D> objectFactory, Type<D> destinationType, Type<S> sourceType)` Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType when it is being mapped from the specified source type.
`<T> void`	`registerObjectFactory(ObjectFactory<T> objectFactory, Class<T> targetClass)` Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType.
`void`	`reportCurrentState(StringBuilder out)` Writes details of the current state of this object to the provided StringBuilder.
`protected Type<?>`	`resolveConcreteType(Type<?> type, Type<?> originalType)`

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

- Field Detail
 - mapperFacade
```
protected final MapperFacade mapperFacade
```
 - mapperGenerator
```
protected final MapperGenerator mapperGenerator
```
 - objectFactoryGenerator
```
protected final ObjectFactoryGenerator objectFactoryGenerator
```
 - classMapRegistry
```
protected final ConcurrentHashMap<MapperKey,ClassMap<Object,Object>> classMapRegistry
```
 - mappersRegistry
```
protected final SortedCollection<Mapper<Object,Object>> mappersRegistry
```
 - filtersRegistry
```
protected final SortedCollection<Filter<Object,Object>> filtersRegistry
```
 - contextFactory
```
protected final MappingContextFactory contextFactory
```
 - nonCyclicContextFactory
```
protected final MappingContextFactory nonCyclicContextFactory
```
 - objectFactoryRegistry
```
protected final ConcurrentHashMap<Type<? extends Object>,ConcurrentHashMap<Type<? extends Object>,ObjectFactory<? extends Object>>> objectFactoryRegistry
```
 - explicitAToBRegistry
```
protected final ConcurrentHashMap<Type<?>,Set<Type<?>>> explicitAToBRegistry
```
 - dynamicAToBRegistry
```
protected final ConcurrentHashMap<Type<?>,Set<Type<?>>> dynamicAToBRegistry
```
 - defaultFieldMappers
```
protected final List<DefaultFieldMapper> defaultFieldMappers
```
 - unenhanceStrategy
```
protected final UnenhanceStrategy unenhanceStrategy
```
 - userUnenahanceStrategy
```
protected final UnenhanceStrategy userUnenahanceStrategy
```
 - converterFactory
```
protected final ConverterFactory converterFactory
```
 - compilerStrategy
```
protected final CompilerStrategy compilerStrategy
```
 - propertyResolverStrategy
```
protected final PropertyResolverStrategy propertyResolverStrategy
```
 - concreteTypeRegistry
```
protected final Map<Type,Type<?>> concreteTypeRegistry
```
 - alwaysCreateMultipleMapperWrapper
```
protected boolean alwaysCreateMultipleMapperWrapper
```
 See Also:
 
 DefaultMapperFactory.MapperFactoryBuilder.alwaysCreateMultipleMapperWrapper
 - classMapBuilderFactory
```
protected final ClassMapBuilderFactory classMapBuilderFactory
```
 - chainClassMapBuilderFactory
```
protected ClassMapBuilderFactory chainClassMapBuilderFactory
```
 - usedMapperMetadataRegistry
```
protected final Map<MapperKey,Set<ClassMap<Object,Object>>> usedMapperMetadataRegistry
```
 - useAutoMapping
```
protected final boolean useAutoMapping
```
 - useBuiltinConverters
```
protected final boolean useBuiltinConverters
```
 - favorExtension
```
protected final boolean favorExtension
```
 - isBuilt
```
protected volatile boolean isBuilt
```
 - isBuilding
```
protected volatile boolean isBuilding
```
 - exceptionUtil
```
protected final ExceptionUtility exceptionUtil
```
- Constructor Detail
 - DefaultMapperFactory
```
protected DefaultMapperFactory(DefaultMapperFactory.MapperFactoryBuilder<?,?> builder)
```
 Constructs a new instance of DefaultMapperFactory
 
 Parameters:
 
 builder -
- Method Detail
 - addClassMapBuilderFactory
```
protected void addClassMapBuilderFactory(ClassMapBuilderFactory factory)
```
 Add factory to the factories chain
 
 Parameters:
 
 factory -
 - buildUnenhanceStrategy
```
protected UnenhanceStrategy buildUnenhanceStrategy(UnenhanceStrategy unenhanceStrategy,
 SuperTypeResolverStrategy superTypeStrategy)
```
 Generates the UnenhanceStrategy to be used for this MapperFactory, applying the passed delegateStrategy if not null.
 This allows the MapperFactory a chance to fill in the unenhance strategy with references to other parts of the factory (registered mappers, converters, object factories) which may be important in the "unenhancing" process.
 
 Parameters:
 
 unenhanceStrategy -
 
 superTypeStrategy - true if the passed UnenhanceStrategy should take full responsibility for un-enhancement; false if the default behavior should be applied as a fail-safe after consulting the passed strategy.
 
 Returns:
 
 the resulting UnenhanceStrategy
 - buildMapperFacade
```
protected MapperFacade buildMapperFacade(MappingContextFactory contextFactory,
 UnenhanceStrategy unenhanceStrategy)
```
 Builds the MapperFacade for this factory. Subclasses can override this method to build a custom MapperFacade. Please note that this method is called from the constructor and as such properties of the factory may not yet be initialized.
 
 Parameters:
 
 contextFactory -
 
 unenhanceStrategy -
 
 Returns:
 
 the MapperFacade to use
 - lookupMapper
```
public <A,B> Mapper<A,B> lookupMapper(MapperKey mapperKey)
```
 Description copied from interface: MapperFactory
 
 Get the Mapper (if any) which has been associated with the given MapperKey. If one does not exist, and the Mapper supports automatic generation, an appropriate mapper will be generated.
 
 Specified by:
 
 lookupMapper in interface MapperFactory
 
 Parameters:
 
 mapperKey - the MapperKey for which to look up an associated Mapper
 
 Returns:
 
 the Mapper associated with mapperKey;
 - lookupMapper
```
public Mapper<Object,Object> lookupMapper(MapperKey mapperKey,
 MappingContext context)
```
 Searches for a Mapper which is capable of mapping the classes identified by the provided MapperKey instance
 
 Specified by:
 
 lookupMapper in interface MapperFactory
 
 Parameters:
 
 mapperKey -
 
 context -
 
 Returns:
 
 the Mapper instance which is able to support the set of classes identified by the passed MapperKey
 - existsRegisteredMapper
```
public boolean existsRegisteredMapper(Type<?> sourceType,
 Type<?> destinationType,
 boolean includeAutoGeneratedMappers)
```
 Description copied from interface: MapperFactory
 
 Tests for the existence of a registered mapper which corresponds to the supplied mapperKey
 
 Specified by:
 
 existsRegisteredMapper in interface MapperFactory
 
 Parameters:
 
 sourceType - the source type
 
 destinationType - the destination type
 
 includeAutoGeneratedMappers - specifies whether an auto-generated mapper for the given source and destination type should be considered
 
 Returns:
 
 true if such a mapper is registered with this factory
 - getRegisteredMapper
```
protected <A,B> Mapper<A,B> getRegisteredMapper(MapperKey mapperKey)
```
 Parameters:
 
 mapperKey -
 
 Returns:
 
 a registered Mapper which is able to map the specified types
 - getMapperFacade
```
public MapperFacade getMapperFacade()
```
 Specified by:
 
 getMapperFacade in interface MapperFactory
 
 Returns:
 
 a thread-safe MapperFacade instance as configured by this MapperFactory
 - registerObjectFactory
```
public <D> void registerObjectFactory(ObjectFactory<D> objectFactory,
 Type<D> destinationType)
```
 Description copied from interface: MapperFactory
 
 Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType. Any ObjectFactory registered with a specific source type instance will take precedence.
 
 Specified by:
 
 registerObjectFactory in interface MapperFactory
 
 Parameters:
 
 objectFactory - the object factory to register
 
 destinationType - the type which is generated by the given object factory
 - registerObjectFactory
```
public <D,S> void registerObjectFactory(ObjectFactory<D> objectFactory,
 Type<D> destinationType,
 Type<S> sourceType)
```
 Description copied from interface: MapperFactory
 
 Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType when it is being mapped from the specified source type.
 
 Specified by:
 
 registerObjectFactory in interface MapperFactory
 
 Parameters:
 
 objectFactory - the object factory to register
 
 destinationType - the type which is generated by the given object factory
 
 sourceType - the source type from which the destination type is mapped
 - registerMappingHint
```
@Deprecated
public void registerMappingHint(MappingHint... hints)
```
 Deprecated.
 
 Specified by:
 
 registerMappingHint in interface MapperFactory
 - registerDefaultFieldMapper
```
public void registerDefaultFieldMapper(DefaultFieldMapper... mappers)
```
 Description copied from interface: MapperFactory
 
 Register one or more DefaultFieldMapper instances to be used by this MapperFactory; these instances will be used whenever automatically generating a Mapper for a given pair of types.
 
 Specified by:
 
 registerDefaultFieldMapper in interface MapperFactory
 
 Parameters:
 
 mappers - one or more DefaultFieldMapper instances to register
 - registerConcreteType
```
public void registerConcreteType(Type<?> abstractType,
 Type<?> concreteType)
```
 Description copied from interface: MapperFactory
 
 Register a concrete type to use when a need arises to generate a new instance of a given abstract type (abstract class or interface)
 
 Specified by:
 
 registerConcreteType in interface MapperFactory
 
 Parameters:
 
 abstractType - the type of the abstract class or interface
 
 concreteType - the concrete type to instantiate
 - registerConcreteType
```
public void registerConcreteType(Class<?> abstractType,
 Class<?> concreteType)
```
 Description copied from interface: MapperFactory
 
 Register a concrete type to use when a need arises to generate a new instance of a given abstract type (abstract class or interface)
 
 Specified by:
 
 registerConcreteType in interface MapperFactory
 
 Parameters:
 
 abstractType - the abstract class or interface
 
 concreteType - the concrete class to instantiate
 - lookupObjectFactory
```
public <T> ObjectFactory<T> lookupObjectFactory(Type<T> targetType)
```
 Description copied from interface: MapperFactory
 
 Return the object factory (if any) which has been registered for the given type.
 
 Specified by:
 
 lookupObjectFactory in interface MapperFactory
 
 Parameters:
 
 targetType - the type for which to lookup a registered ObjectFactory.
 
 Returns:
 
 the ObjectFactory registered for the given targetType; null if no ObjectFactory has been registered for the given type.
 - lookupObjectFactory
```
public <T,S> ObjectFactory<T> lookupObjectFactory(Type<T> targetType,
 Type<S> sourceType)
```
 Description copied from interface: MapperFactory
 
 Return the object factory (if any) which has been registered for the given type.
 
 Specified by:
 
 lookupObjectFactory in interface MapperFactory
 
 Parameters:
 
 targetType - the type for which to lookup a registered ObjectFactory.
 
 sourceType - the source type from which the target is mapped
 
 Returns:
 
 the ObjectFactory registered for the given targetType; null if no ObjectFactory has been registered for the given type.
 - lookupExistingObjectFactory
```
protected <T,S> ObjectFactory<T> lookupExistingObjectFactory(Type<T> destinationType,
 Type<S> sourceType,
 MappingContext context)
```
 Parameters:
 
 destinationType -
 
 sourceType -
 
 context -
 
 Returns:
 
 an object factory capable of generating the provided destination type, if any exists.
 - lookupObjectFactory
```
public <T,S> ObjectFactory<T> lookupObjectFactory(Type<T> destinationType,
 Type<S> sourceType,
 MappingContext context)
```
 Description copied from interface: MapperFactory
 
 Return the object factory (if any) which has been registered for the given type.
 
 Specified by:
 
 lookupObjectFactory in interface MapperFactory
 
 Parameters:
 
 destinationType -
 
 sourceType -
 
 context -
 
 Returns:
 
 an ObjectFactory instance which is able to instantiate the specified type
 - lookupConcreteDestinationType
```
public <S,D> Type<? extends D> lookupConcreteDestinationType(Type<S> sourceType,
 Type<D> destinationType,
 MappingContext context)
```
 Specified by:
 
 lookupConcreteDestinationType in interface MapperFactory
 
 Returns:
 
 a concrete type registered to be used in place of the provided destination type
 - resolveConcreteType
```
protected Type<?> resolveConcreteType(Type<?> type,
 Type<?> originalType)
```
 Parameters:
 
 type -
 
 originalType -
 
 Returns:
 
 a concrete type (if any) which has been registered for the specified abstract type
 - registerClassMap
```
public <A,B> void registerClassMap(ClassMap<A,B> classMap)
```
 Description copied from interface: MapperFactory
 
 Registers the given ClassMap instance with the factory; it will be used to configure an appropriate mapping.
 
 Specified by:
 
 registerClassMap in interface MapperFactory
 
 Parameters:
 
 classMap - the ClassMap instance to register
 - registerClassMap
```
public <A,B> void registerClassMap(ClassMapBuilder<A,B> builder)
```
 Description copied from interface: MapperFactory
 
 Registers the ClassMap configured by the specified ClassMapBuilder; it will be used to configure an appropriate mapping.
 
 Specified by:
 
 registerClassMap in interface MapperFactory
 
 Parameters:
 
 builder - the ClassMapBuilder to register
 - build
```
public void build()
```
 Description copied from interface: MapperFactory
 
 Builds this MapperFactory.
 
 Specified by:
 
 build in interface MapperFactory
 - lookupUsedClassMap
```
public Set<ClassMap<Object,Object>> lookupUsedClassMap(MapperKey mapperKey)
```
 Description copied from interface: MapperFactory
 
 Lookup the class map hierarchy used for the mapping defined by the specified MapperKey, if any exists
 
 Specified by:
 
 lookupUsedClassMap in interface MapperFactory
 
 Parameters:
 
 mapperKey - the mapper key defining the mapping to resolve
 
 Returns:
 
 the set of class mappings in the hierarchy of mappings used for the specified mapper key
 - register
```
protected <S,D> void register(Type<S> sourceType,
 Type<D> destinationType,
 boolean isAutoGenerated)
```
 Registers that a mapping exists from the specified source type to the specified destination type
 
 Parameters:
 
 sourceType -
 
 destinationType -
 - getClassMap
```
public <A,B> ClassMap<A,B> getClassMap(MapperKey mapperKey)
```
 Description copied from interface: MapperFactory
 
 Gets the ClassMap instance (if any) which has been associated with the types represented by the given MapperKey instance.
 
 Specified by:
 
 getClassMap in interface MapperFactory
 
 Parameters:
 
 mapperKey - the MapperKey which should be used to look up an associated ClassMap
 
 Returns:
 
 the ClassMap which has been associated with the given MapperKey; null if no instance has been associated with this MapperKey instance.
 - lookupMappedClasses
```
public Set<Type<? extends Object>> lookupMappedClasses(Type<?> type)
```
 Description copied from interface: MapperFactory
 
 Get the set of classes which have been mapped for the specified type.
 
 Specified by:
 
 lookupMappedClasses in interface MapperFactory
 
 Parameters:
 
 type - the type for which to look up mapped types
 
 Returns:
 
 the set of types which have been mapped for the specified type.
 - getConverterFactory
```
public ConverterFactory getConverterFactory()
```
 Description copied from interface: MapperFactory
 
 Get an instance of the ConverterFactory associated with this MapperFactory; it may be used to register Converter instances to be used during mapping.
 
 Specified by:
 
 getConverterFactory in interface MapperFactory
 
 Returns:
 
 the ConverterFactory instance associated with this MapperFactory;
 - registerObjectFactory
```
public <T> void registerObjectFactory(ObjectFactory<T> objectFactory,
 Class<T> targetClass)
```
 Description copied from interface: MapperFactory
 
 Register the given ObjectFactory with the MapperFactory; it will be used when constructing new instances of the specified targetType.
 
 Specified by:
 
 registerObjectFactory in interface MapperFactory
 
 Parameters:
 
 objectFactory - the object factory to register
 
 targetClass - the type which is generated by the given object factory
 - getClassMapBuilderFactory
```
protected ClassMapBuilderFactory getClassMapBuilderFactory()
```
 Returns:
 
 the (initialized) ClassMapBuilderFactory configured for this mapper factory
 - classMap
```
public <A,B> ClassMapBuilder<A,B> classMap(Type<A> aType,
 Type bType)
```
 Description copied from interface: MapperFactory
 
 Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types.
 
 The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the registerClassMap method.
 
 Specified by:
 
 classMap in interface MapperFactory
 
 Parameters:
 
 aType - the Type instance representing the "A" side of the mapping
 
 bType - the Type instance representing the "B" side of the mapping
 
 Returns:
 
 a ClassMapBuilder instance for defining mapping between the provided types
 - classMap
```
public <A,B> ClassMapBuilder<A,B> classMap(Class<A> aType,
 Type bType)
```
 Description copied from interface: MapperFactory
 
 Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types.
 
 The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the registerClassMap method.
 
 Specified by:
 
 classMap in interface MapperFactory
 
 Parameters:
 
 aType - the Class instance representing the "A" side of the mapping
 
 bType - the Type instance representing the "B" side of the mapping
 
 Returns:
 
 a ClassMapBuilder instance for defining mapping between the provided types
 - classMap
```
public <A,B> ClassMapBuilder<A,B> classMap(Type<A> aType,
 Class bType)
```
 Description copied from interface: MapperFactory
 
 Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types.
 
 The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the registerClassMap method.
 
 Specified by:
 
 classMap in interface MapperFactory
 
 Parameters:
 
 aType - the Type instance representing the "A" side of the mapping
 
 bType - the Class instance representing the "B" side of the mapping
 
 Returns:
 
 a ClassMapBuilder instance for defining mapping between the provided types
 - classMap
```
public <A,B> ClassMapBuilder<A,B> classMap(Class<A> aType,
 Class bType)
```
 Description copied from interface: MapperFactory
 
 Constructs a new ClassMapBuilder instance initialized with the provided types which can be used to configure/customize the mapping between the two types.
 
 The returned ClassMapBuilder instance, after being fully configured, should finally be registered with the factory using the registerClassMap method.
 
 Specified by:
 
 classMap in interface MapperFactory
 
 Parameters:
 
 aType - the Class instance representing the "A" side of the mapping
 
 bType - the Class instance representing the "B" side of the mapping
 
 Returns:
 
 a ClassMapBuilder instance for defining mapping between the provided types
 - registerMapper
```
public <A,B> void registerMapper(Mapper<A,B> mapper)
```
 Description copied from interface: MapperFactory
 
 Registers the specified custom mapper with the factory; it will be used for mapping between it's configured types.
 
 Specified by:
 
 registerMapper in interface MapperFactory
 
 Parameters:
 
 mapper - the mapper to register
 - getMapperFacade
```
public <S,D> BoundMapperFacade<S,D> getMapperFacade(Type<S> sourceType,
 Type<D> destinationType)
```
 Description copied from interface: MapperFactory
 
 Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
 
 Specified by:
 
 getMapperFacade in interface MapperFactory
 
 Parameters:
 
 sourceType - the 'A' type for the returned DedicatedMapperFacade
 
 destinationType - the 'B' type for the returned DedicatedMapperFacade
 
 Returns:
 
 a BoundMapperFacade instance dedicated to mapping the specified types
 - getMapperFacade
```
public <S,D> BoundMapperFacade<S,D> getMapperFacade(Type<S> sourceType,
 Type<D> destinationType,
 boolean containsCycles)
```
 Description copied from interface: MapperFactory
 
 Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
 In the case that false is provided for the 'containsCycles' parameter, an optimized mapper instance will be provided.
 
 Specified by:
 
 getMapperFacade in interface MapperFactory
 
 Parameters:
 
 sourceType - the 'A' type for the returned DedicatedMapperFacade
 
 destinationType - the 'B' type for the returned DedicatedMapperFacade
 
 containsCycles - true if the object graph for the source and destination types may contain cycles in it's graph
 
 Returns:
 
 a BoundMapperFacade instance dedicated to mapping the specified types
 - getMapperFacade
```
public <A,B> BoundMapperFacade<A,B> getMapperFacade(Class<A> aType,
 Class bType)
```
 Description copied from interface: MapperFactory
 
 Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
 
 Specified by:
 
 getMapperFacade in interface MapperFactory
 
 Parameters:
 
 aType - the 'A' type for the returned DedicatedMapperFacade
 
 bType - the 'B' type for the returned DedicatedMapperFacade
 
 Returns:
 
 a BoundMapperFacade instance dedicated to mapping the specified types
 - getMapperFacade
```
public <A,B> BoundMapperFacade<A,B> getMapperFacade(Class<A> aType,
 Class bType,
 boolean containsCycles)
```
 Description copied from interface: MapperFactory
 
 Returns a BoundMapperFacade for the specified source and destination types; this mapper is bidirectional by default, and provides signatures for mapping in place, or with instantiation, as needed.
 In the case that false is provided for the 'containsCycles' parameter, an optimized mapper instance will be provided.
 
 Specified by:
 
 getMapperFacade in interface MapperFactory
 
 Parameters:
 
 aType - the 'A' type for the returned DedicatedMapperFacade
 
 bType - the 'B' type for the returned DedicatedMapperFacade
 
 containsCycles - true if the object graph for the source and destination types may contain cycles in it's graph
 
 Returns:
 
 a BoundMapperFacade instance dedicated to mapping the specified types
 - getUserUnenhanceStrategy
```
public UnenhanceStrategy getUserUnenhanceStrategy()
```
 Description copied from interface: MapperFactory
 
 Returns the UnenhanceStrategy associated with this MapperFactory, provided when this MapperFactory was constructed.
 
 Specified by:
 
 getUserUnenhanceStrategy in interface MapperFactory
 
 Returns:
 
 the UnenhanceStrategy associated with this MapperFactory.
 - registerFilter
```
public void registerFilter(Filter<?,?> filter)
```
 Description copied from interface: MapperFactory
 
 Registers a filter to be applied in the mapping process; such filters may be used to alter source and destination values of the fields as they are processed by mappers.
 
 Specified by:
 
 registerFilter in interface MapperFactory
 
 Parameters:
 
 filter - the filter to be registered
 - reportCurrentState
```
public void reportCurrentState(StringBuilder out)
```
 Description copied from interface: StateReporter.Reportable
 
 Writes details of the current state of this object to the provided StringBuilder.
 
 Specified by:
 
 reportCurrentState in interface StateReporter.Reportable

Class DefaultMapperFactory

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

mapperFacade

mapperGenerator

objectFactoryGenerator

classMapRegistry

mappersRegistry

filtersRegistry

contextFactory

nonCyclicContextFactory

objectFactoryRegistry

explicitAToBRegistry

dynamicAToBRegistry

defaultFieldMappers

unenhanceStrategy

userUnenahanceStrategy

converterFactory

compilerStrategy

propertyResolverStrategy

concreteTypeRegistry

alwaysCreateMultipleMapperWrapper

classMapBuilderFactory

chainClassMapBuilderFactory

usedMapperMetadataRegistry

useAutoMapping

useBuiltinConverters

favorExtension

isBuilt

isBuilding

exceptionUtil

Constructor Detail

DefaultMapperFactory

Method Detail

addClassMapBuilderFactory

buildUnenhanceStrategy

buildMapperFacade

lookupMapper

lookupMapper

existsRegisteredMapper

getRegisteredMapper

getMapperFacade

registerObjectFactory

registerObjectFactory

registerMappingHint

registerDefaultFieldMapper

registerConcreteType

registerConcreteType

lookupObjectFactory

lookupObjectFactory

lookupExistingObjectFactory

lookupObjectFactory

lookupConcreteDestinationType

resolveConcreteType

registerClassMap

registerClassMap

build

lookupUsedClassMap

register

getClassMap

lookupMappedClasses

getConverterFactory

registerObjectFactory

getClassMapBuilderFactory

classMap

classMap

classMap

classMap

registerMapper

getMapperFacade

getMapperFacade

getMapperFacade

getMapperFacade

getUserUnenhanceStrategy

registerFilter

reportCurrentState