Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Spring Data Commons
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.data.mapping.context
Class AbstractMappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>

    java.lang.Object
      org.springframework.data.mapping.context.AbstractMappingContext<E,P>

All Implemented Interfaces:
  InitializingBean, ApplicationEventPublisherAware, MappingContext<E,P>

    public abstract class AbstractMappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>

extends Object
implements MappingContext<E,P>, InitializingBean, ApplicationEventPublisherAware

Base class to build mapping metadata and thus create instances of `PersistentEntity` and `PersistentProperty`.

Author:
  Jon Brisbin , Oliver Gierke

Constructor Summary
`AbstractMappingContext()`

Method Summary
`protected E` | `addPersistentEntity(Class<?> type)` Adds the given type to the `MappingContext`.
`protected E` | `addPersistentEntity(TypeInformation<?> typeInformation)` Adds the given `TypeInformation` to the `MappingContext`.
`void` | `afterPropertiesSet()`
`protected abstract
`<T> E`
` | `createPersistentEntity(TypeInformation<T> typeInformation)` Creates the concrete `PersistentEntity` instance.
`protected abstract P` | `createPersistentProperty(Field field, PropertyDescriptor descriptor, E owner, SimpleTypeHolder simpleTypeHolder)` Creates the concrete instance of `PersistentProperty`.
`List<Validator>` | `getEntityValidators(E entity)` Obtains a validator for the given entity TODO: Why do we need validators at the `MappingContext`?
`Collection<E>` | `getPersistentEntities()` Returns all `PersistentEntity`s held in the context.
`E` | `getPersistentEntity(Class<?> type)` Returns a `PersistentEntity` for the given `Class`.
`E` | `getPersistentEntity(TypeInformation<?> type)` Returns a `PersistentEntity` for the given `TypeInformation`.
`
`<T> Iterable<P>`
` | `getPersistentPropertyPath(Class<T> type, String path)` Returns all `PersistentProperty`s for the given path expression based on the given root `Class`.
`void` | `setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)`
`void` | `setInitialEntitySet(Set<? extends Class<?>> initialEntitySet)` Sets the `Set` of types to populate the context initially.
`void` | `setSimpleTypeHolder(SimpleTypeHolder simpleTypes)` Configures the `SimpleTypeHolder` to be used by the `MappingContext`.
`void` | `setStrict(boolean strict)` Configures whether the `MappingContext` is in strict mode which means, that it will throw `MappingException`s in case one tries to lookup a `PersistentEntity` not already in the context.

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

Constructor Detail

### AbstractMappingContext

    public AbstractMappingContext()

Method Detail

### setApplicationEventPublisher

    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)

  Specified by:
    `setApplicationEventPublisher` in interface `ApplicationEventPublisherAware`

### setInitialEntitySet

    public void setInitialEntitySet(Set<? extends Class<?>> initialEntitySet)

  Sets the `Set` of types to populate the context initially.

  Parameters:
    `initialEntitySet` -

### setStrict

    public void setStrict(boolean strict)

  Configures whether the `MappingContext` is in strict mode which means, that it will throw `MappingException`s in case one tries to lookup a `PersistentEntity` not already in the context. This defaults to false so that unknown types will be transparently added to the MappingContext if not known in advance.

  Parameters:
    `strict` -

### setSimpleTypeHolder

    public void setSimpleTypeHolder(SimpleTypeHolder simpleTypes)

  Configures the `SimpleTypeHolder` to be used by the `MappingContext`. Allows customization of what types will be regarded as simple types and thus not recursively analysed. Setting this to null will reset the context to use the default `SimpleTypeHolder`.

  Parameters:
    `simpleTypes` -

### getPersistentEntities

    public Collection<E> getPersistentEntities()

  Description copied from interface: `MappingContext`
  Returns all `PersistentEntity`s held in the context.

  Specified by:
    `getPersistentEntities` in interface `MappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>`
  Returns:

### getPersistentEntity

    public E getPersistentEntity(Class<?> type)

  Description copied from interface: `MappingContext`
  Returns a `PersistentEntity` for the given `Class`.

  Specified by:
    `getPersistentEntity` in interface `MappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>`
  Returns:

### getPersistentEntity

    public E getPersistentEntity(TypeInformation<?> type)

  Description copied from interface: `MappingContext`
  Returns a `PersistentEntity` for the given `TypeInformation`.

  Specified by:
    `getPersistentEntity` in interface `MappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>`
  Returns:

### getPersistentPropertyPath

    public <T> Iterable<P> getPersistentPropertyPath(Class<T> type,
                                                     String path)

  Description copied from interface: `MappingContext`
  Returns all `PersistentProperty`s for the given path expression based on the given root `Class`. Path expression are dot separated, e.g. `person.firstname`.

  Specified by:
    `getPersistentPropertyPath` in interface `MappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>`
  Returns:

### getEntityValidators

    public List<Validator> getEntityValidators(E entity)

  Description copied from interface: `MappingContext`
  Obtains a validator for the given entity TODO: Why do we need validators at the `MappingContext`?

  Specified by:
    `getEntityValidators` in interface `MappingContext<E extends MutablePersistentEntity<?,P>,P extends PersistentProperty<P>>`
  Parameters:
    `entity` - The entity
  Returns:
    A validator or null if none exists for the given entity

### addPersistentEntity

    protected E addPersistentEntity(Class<?> type)

  Adds the given type to the `MappingContext`.

  Parameters:
    `type` -
  Returns:

### addPersistentEntity

    protected E addPersistentEntity(TypeInformation<?> typeInformation)

  Adds the given `TypeInformation` to the `MappingContext`.

  Parameters:
    `typeInformation` -
  Returns:

### createPersistentEntity

    protected abstract <T> E createPersistentEntity(TypeInformation<T> typeInformation)

  Creates the concrete `PersistentEntity` instance.

  Type Parameters:
    `T` -
  Parameters:
    `typeInformation` -
  Returns:

### createPersistentProperty

    protected abstract P createPersistentProperty(Field field,
                                                  PropertyDescriptor descriptor,
                                                  E owner,
                                                  SimpleTypeHolder simpleTypeHolder)

  Creates the concrete instance of `PersistentProperty`.

  Parameters:
    `field` -
    `descriptor` -
    `owner` -
    `simpleTypeHolder` -
  Returns:

### afterPropertiesSet

    public void afterPropertiesSet()

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Spring Data Commons
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2011. All Rights Reserved.