TypeMappingFactory (Java Simple Exchange Format API (parent) 1.0.1.RELEASE API)

java.lang.Object
- org.jsefa.common.annotation.TypeMappingFactory<N,R>

Type Parameters:
N - the type of the data type name
R - the type of the type mapping registry

Direct Known Subclasses:

RbfTypeMappingFactory, XmlTypeMappingFactory
```
public abstract class TypeMappingFactory<N,R extends TypeMappingRegistry<N>>
extends Object
```
Abstract super class for factories which can create TypeMappings from annotated classes.
All subclasses should be thread-safe.

Author:

Norman Lahme-Huetig

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TypeMappingFactory.TypeMappingPlaceholder` A placeholder for a type mapping used during the construction of a type mapping, i.

Constructor Summary

Constructors
Constructor and Description
`TypeMappingFactory(R typeMappingRegistry, SimpleTypeConverterProvider simpleTypeConverterProvider, ValidatorProvider validatorProvider, ObjectAccessorProvider objectAccessorProvider)` Constructs a new `TypeMappingFactory`.

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`assertHasSimpleType(Class<?> objectType)` Asserts that a given object type is a simple type.
`protected void`	`assertNoCollectionType(Class<?> objectType)` Asserts that a given object type is not a collection class.
`protected void`	`assertTypeMappingExists(N dataTypeName)` Asserts that a type mapping exists for the given data type name.
`protected void`	`assertTypeMappingIsSimple(N dataTypeName)` Asserts that a type mapping exists for the given data type name and is simple.
`abstract N`	`createIfAbsent(Class<?> objectType)` Creates a type mapping for the given object type, registers it with the type mapping registry and returns its data type name.
`protected SimpleTypeConverter`	`createSimpleTypeConverter(Class<?> objectType, Field field, Annotation annotation)` Creates a simple type converter.
`protected abstract N`	`getAnnotatedDataTypeName(Annotation annotation, Class<?> annotationContextClass)` Returns the data type name as declared through the given annotation.
`protected Class<?>`	`getCollectionItemType(Annotation annotation, Field field, boolean fromFieldDeclarationAllowed)` Returns the type of the items of a collection.
`protected Class<?>`	`getMapKeyType(Annotation annotation, Field field)` Returns the type of the keys of a map.
`protected Class<?>`	`getMapValueType(Annotation annotation, Field field, boolean fromFieldDeclarationAllowed)` Returns the type of the values of a map.
`protected ObjectAccessorProvider`	`getObjectAccessorProvider()` Returns the object accessor provider.
`protected SimpleTypeConverterProvider`	`getSimpleTypeConverterProvider()` Returns the simple type converter provider.
`R`	`getTypeMappingRegistry()` Returns the type mapping registry.
`protected ValidatorFactory`	`getValidatorFactory()` Returns the validator factory.
`protected ValidatorProvider`	`getValidatorProvider()` Returns the validator provider.
`protected boolean`	`hasCollectionType(Class<?> objectType)` Returns true if and only if the given object type is a collection type.
`protected boolean`	`hasMapType(Class<?> objectType)` Returns true if and only if the given object type is a map type.
`protected boolean`	`hasSimpleType(Class<?> objectType)` Returns true if and only if the given object type is a simple type.
`protected boolean`	`prepareToCreate(Class<?> objectType, N dataTypeName)` Called before creating a new type mapping with the given data type name for the given object type.

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

- Constructor Detail
  - TypeMappingFactory
```
public TypeMappingFactory(R typeMappingRegistry,
                  SimpleTypeConverterProvider simpleTypeConverterProvider,
                  ValidatorProvider validatorProvider,
                  ObjectAccessorProvider objectAccessorProvider)
```
    Constructs a new TypeMappingFactory.
    
    Parameters:
    typeMappingRegistry - the type mapping registry. New types will be registered using that registry.
    simpleTypeConverterProvider - the simple type converter provider to use
    validatorProvider - the validator provider to use
    objectAccessorProvider - the object accessor provider to use
- Method Detail
  - createIfAbsent
```
public abstract N createIfAbsent(Class<?> objectType)
```
    Creates a type mapping for the given object type, registers it with the type mapping registry and returns its data type name. The first two steps are omitted if a type mapping is already registered for the given object type.
    
    Parameters:
    objectType - the object type to create a type mapping for.
    
    Returns:
    the name of the created or found data type.
  - getTypeMappingRegistry
```
public final R getTypeMappingRegistry()
```
    Returns the type mapping registry.
    
    Returns:
    the type mapping registry.
  - prepareToCreate
```
protected final boolean prepareToCreate(Class<?> objectType,
                      N dataTypeName)
```
    Called before creating a new type mapping with the given data type name for the given object type. Returns true, if the type mapping registry has no entry for the data type name and if it is the first time this method is called with the given argument; otherwise false.
    The purpose of this method is to prevent from creating duplicates and from falling in an endless loop in case of a cycle in the type mapping graph.
    In case the method returns true, a TypeMappingFactory.TypeMappingPlaceholder is registered so that object type information can be retrieved during the construction of a type mapping. That type mapping is replaced by the real type mapping after finishing its construction.
    
    Parameters:
    objectType - the object type
    dataTypeName - the data type name
    
    Returns:
    true, if no type mapping with the given name already exists or is already under construction.
  - getObjectAccessorProvider
```
protected final ObjectAccessorProvider getObjectAccessorProvider()
```
    Returns the object accessor provider.
    
    Returns:
    the object accessor provider.
  - getSimpleTypeConverterProvider
```
protected final SimpleTypeConverterProvider getSimpleTypeConverterProvider()
```
    Returns the simple type converter provider.
    
    Returns:
    the simple type converter provider.
  - getValidatorProvider
```
protected final ValidatorProvider getValidatorProvider()
```
    Returns the validator provider.
    
    Returns:
    the validator provider
  - createSimpleTypeConverter
```
protected final SimpleTypeConverter createSimpleTypeConverter(Class<?> objectType,
                                            Field field,
                                            Annotation annotation)
```
    Creates a simple type converter.
    
    Parameters:
    objectType - the object type to create a converter for
    field - the field to create a converter for. May be null.
    annotation - the annotation providing parameters for constructing the converter. May be null.
    
    Returns:
    a simple type converter
  - getCollectionItemType
```
protected final Class<?> getCollectionItemType(Annotation annotation,
                             Field field,
                             boolean fromFieldDeclarationAllowed)
```
    Returns the type of the items of a collection.
    
    Parameters:
    annotation - the annotation of the field
    field - the field
    fromFieldDeclarationAllowed - true, if the field is a collection which contains only values of one type so that the type may be deduced from the actual parameter type of the parameterized type of the field; false otherwise.
    
    Returns:
    an object type
  - getMapValueType
```
protected final Class<?> getMapValueType(Annotation annotation,
                       Field field,
                       boolean fromFieldDeclarationAllowed)
```
    Returns the type of the values of a map.
    
    Parameters:
    annotation - the annotation of the field
    field - the field
    fromFieldDeclarationAllowed - true, if the field is a map which contains only values of one type so that the type may be deduced from the actual parameter type of the parameterized type of the field; false otherwise.
    
    Returns:
    an object type
  - getMapKeyType
```
protected final Class<?> getMapKeyType(Annotation annotation,
                     Field field)
```
    Returns the type of the keys of a map.
    
    Parameters:
    annotation - the annotation of the field
    field - the field
    
    Returns:
    an object type
  - getAnnotatedDataTypeName
```
protected abstract N getAnnotatedDataTypeName(Annotation annotation,
                         Class<?> annotationContextClass)
```
    Returns the data type name as declared through the given annotation.
    
    Parameters:
    annotation - the annotation
    annotationContextClass - the context class of the annotation. This class may be needed to interpret the annotation data.
    
    Returns:
    a data type name
  - getValidatorFactory
```
protected final ValidatorFactory getValidatorFactory()
```
    Returns the validator factory.
    
    Returns:
    the validator factory
  - hasSimpleType
```
protected final boolean hasSimpleType(Class<?> objectType)
```
    Returns true if and only if the given object type is a simple type.
    
    Parameters:
    objectType - the object type
    
    Returns:
    true, if the object type is a simple type; false otherwise.
  - hasCollectionType
```
protected final boolean hasCollectionType(Class<?> objectType)
```
    Returns true if and only if the given object type is a collection type.
    
    Parameters:
    objectType - the object type
    
    Returns:
    true, if the given object type is a collection type; false otherwise.
  - hasMapType
```
protected final boolean hasMapType(Class<?> objectType)
```
    Returns true if and only if the given object type is a map type.
    
    Parameters:
    objectType - the object type
    
    Returns:
    true, if the given object type is a map type; false otherwise.
  - assertTypeMappingExists
```
protected final void assertTypeMappingExists(N dataTypeName)
```
    Asserts that a type mapping exists for the given data type name.
    
    Parameters:
    dataTypeName - the data type name.
    
    Throws:
    
    AnnotationException - if the assertion fails.
  - assertTypeMappingIsSimple
```
protected final void assertTypeMappingIsSimple(N dataTypeName)
```
    Asserts that a type mapping exists for the given data type name and is simple.
    
    Parameters:
    dataTypeName - the data type name.
    
    Throws:
    
    AnnotationException - if the assertion fails.
  - assertNoCollectionType
```
protected final void assertNoCollectionType(Class<?> objectType)
```
    Asserts that a given object type is not a collection class.
    
    Parameters:
    objectType - the object type to check
    
    Throws:
    
    AnnotationException - if the assertion fails.
  - assertHasSimpleType
```
protected final void assertHasSimpleType(Class<?> objectType)
```
    Asserts that a given object type is a simple type.
    
    Parameters:
    objectType - the object type to check
    
    Throws:
    
    AnnotationException - if the assertion fails.

Class TypeMappingFactory<N,R extends TypeMappingRegistry<N>>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TypeMappingFactory

Method Detail

createIfAbsent

getTypeMappingRegistry

prepareToCreate

getObjectAccessorProvider

getSimpleTypeConverterProvider

getValidatorProvider

createSimpleTypeConverter

getCollectionItemType

getMapValueType

getMapKeyType

getAnnotatedDataTypeName

getValidatorFactory

hasSimpleType

hasCollectionType

hasMapType

assertTypeMappingExists

assertTypeMappingIsSimple

assertNoCollectionType

assertHasSimpleType