ma.glasnost.orika.metadata

Class ClassMapBuilderFactory

java.lang.Object

ma.glasnost.orika.metadata.ClassMapBuilderFactory

Direct Known Subclasses:

CaseInsensitiveClassMapBuilder.Factory, ClassMapBuilder.Factory, ClassMapBuilderForArrays.Factory, ClassMapBuilderForLists.Factory, ClassMapBuilderForMaps.Factory, ScoringClassMapBuilder.Factory

public abstract class ClassMapBuilderFactory
extends Object

ClassMapBuilderFactory should be used to construct the new instances of ClassMapBuilder needed to register a mapping from one class/type to another class/type.

Author:

matt.deboer@gmail.com

Field Summary

Fields

Modifier and Type	Field and Description
protected DefaultFieldMapper[]	defaults The DefaultFieldMappers applied by this factory
protected MapperFactory	mapperFactory The MapperFactory used by this factory
protected ClassMapBuilderFactory	nextClassMapBuilderFactory The next factory in the chain
protected PropertyResolverStrategy	propertyResolver The PropertyResolver used by this factory

Constructor Summary

Constructors

Constructor and Description
ClassMapBuilderFactory()

Method Summary

Modifier and Type	Method and Description
protected <A,B> boolean	appliesTo(Type<A> aType, Type<B> bType) Return true if this implementation of factory is suitable for received types
<A,B> ClassMapBuilderFactory	chooseClassMapBuilderFactory(Type<A> aType, Type<B> bType) Choose suitable ClassMapBuilderFactory for types from factories chain
boolean	isInitialized() Verifies whether the factory has been properly initialized
<A,B> ClassMapBuilder<A,B>	map(Class<A> aType, Class<B> bType) Begin a new mapping for the specified classes.
<A,B> ClassMapBuilder<A,B>	map(Class<A> aType, Type<B> bType) Begin a new mapping for the specified class and type.
<A,B> ClassMapBuilder<A,B>	map(Type<A> aType, Class<B> bType) Begin a new mapping for the specified type and class.
<A,B> ClassMapBuilder<A,B>	map(Type<A> aType, Type<B> bType) Begin a new mapping for the specified types.
protected abstract <A,B> ClassMapBuilder<A,B>	newClassMapBuilder(Type<A> aType, Type<B> bType, MapperFactory mapperFactory, PropertyResolverStrategy propertyResolver, DefaultFieldMapper[] defaults) Generates a new ClassMapBuilder instance
void	setChainClassMapBuilderFactory(ClassMapBuilderFactory classMapBuilderFactory) Set the next ClassMapBuilderFactory in the chain
void	setDefaultFieldMappers(DefaultFieldMapper... defaults)
void	setMapperFactory(MapperFactory mapperFactory)
void	setPropertyResolver(PropertyResolverStrategy propertyResolver)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

nextClassMapBuilderFactory

protected ClassMapBuilderFactory nextClassMapBuilderFactory

The next factory in the chain

mapperFactory

protected MapperFactory mapperFactory

The MapperFactory used by this factory

propertyResolver

protected PropertyResolverStrategy propertyResolver

The PropertyResolver used by this factory

defaults

protected DefaultFieldMapper[] defaults

The DefaultFieldMappers applied by this factory

Constructor Detail

ClassMapBuilderFactory

public ClassMapBuilderFactory()

Method Detail

setMapperFactory

public void setMapperFactory(MapperFactory mapperFactory)

Parameters:

mapperFactory - the MapperFactory which will be used to register the ClassMapBuilder instances via their 'register()' method

appliesTo

protected <A,B> boolean appliesTo(Type<A> aType,
                                  Type<B> bType)

Return true if this implementation of factory is suitable for received types

Parameters:

aType -

bType -

Returns:

true if this factory applies to the specified pair of types

setChainClassMapBuilderFactory

public void setChainClassMapBuilderFactory(ClassMapBuilderFactory classMapBuilderFactory)

Set the next ClassMapBuilderFactory in the chain

Parameters:

classMapBuilderFactory -

chooseClassMapBuilderFactory

public <A,B> ClassMapBuilderFactory chooseClassMapBuilderFactory(Type<A> aType,
                                                                 Type<B> bType)

Choose suitable ClassMapBuilderFactory for types from factories chain

Type Parameters:

A -

B -

Parameters:

aType -

bType -

Returns:

this ClassMapBuilderFactory

setPropertyResolver

public void setPropertyResolver(PropertyResolverStrategy propertyResolver)

Parameters:

propertyResolver - the PropertyResolverStrategy instance to use when resolving properties of the mapped types

setDefaultFieldMappers

public void setDefaultFieldMappers(DefaultFieldMapper... defaults)

Parameters:

defaults - zero or more DefaultFieldMapper instances that should be applied when the byDefault method of the ClassMapBuilder is called.

isInitialized

public boolean isInitialized()

Verifies whether the factory has been properly initialized

Returns:

true if the factory has been initialized

newClassMapBuilder

protected abstract <A,B> ClassMapBuilder<A,B> newClassMapBuilder(Type<A> aType,
                                                                 Type<B> bType,
                                                                 MapperFactory mapperFactory,
                                                                 PropertyResolverStrategy propertyResolver,
                                                                 DefaultFieldMapper[] defaults)

Generates a new ClassMapBuilder instance

Parameters:

aType -

bType -

Returns:

a new ClassMapBuilder for the provided types

map

public <A,B> ClassMapBuilder<A,B> map(Type<A> aType,
                                      Type<B> bType)

Begin a new mapping for the specified types.

Parameters:

aType -

bType -

Returns:

a new ClassMapBuilder instance for the specified types

map

public <A,B> ClassMapBuilder<A,B> map(Class<A> aType,
                                      Type<B> bType)

Begin a new mapping for the specified class and type.

Parameters:

aType -

bType -

Returns:

a new ClassMapBuilder instance for the specified types

map

public <A,B> ClassMapBuilder<A,B> map(Type<A> aType,
                                      Class<B> bType)

Begin a new mapping for the specified type and class.

Parameters:

aType -

bType -

Returns:

a new ClassMapBuilder instance for the specified types

map

public <A,B> ClassMapBuilder<A,B> map(Class<A> aType,
                                      Class<B> bType)

Begin a new mapping for the specified classes.

Parameters:

aType -

bType -

Returns:

a new ClassMapBuilder instance for the specified types