org.springframework.data.convert

## Class CustomConversions

- java.lang.Object
- - org.springframework.data.convert.CustomConversions

    public class CustomConversions
    extends Object

Value object to capture custom conversion. That is essentially a `List` of converters and some additional logic around them. The converters build up two sets of types which store-specific basic types can be converted into and from. These types will be considered simple ones (which means they neither need deeper inspection nor nested conversion. Thus the `CustomConversions` also act as factory for `SimpleTypeHolder` .

Since:
  2.0
Author:
  Oliver Gierke, Thomas Darimont, Christoph Strobl, Mark Paluch

### Nested Class Summary

Nested Classes
`protected static class` `CustomConversions.ConverterConfiguration` Value object holding the actual `CustomConversions.StoreConversions` and custom `converters` configured for registration.
`protected static class` `CustomConversions.ConverterRegistrationIntent` Value class tying together a `ConverterRegistration` and its `origin` to allow fine grained registration based on store supported types.
`static class` `CustomConversions.StoreConversions` Value type to capture store-specific extensions to the `CustomConversions`.

### Constructor Summary

Constructors
Constructor and Description
`CustomConversions(CustomConversions.ConverterConfiguration converterConfiguration)`
`CustomConversions(CustomConversions.StoreConversions storeConversions, Collection<?> converters)` Creates a new `CustomConversions` instance registering all given user defined converters and selecting `converters` from `CustomConversions.StoreConversions` depending on `store simple types` only considering those that either convert to/from a store supported type.

### Method Summary

All Methods Instance Methods Concrete Methods
`Optional<Class<?>>` `getCustomWriteTarget(Class<?> sourceType)` Returns the target type to convert to in case we have a custom conversion registered to convert the given source type into a store native one.
`Optional<Class<?>>` `getCustomWriteTarget(Class<?> sourceType, Class<?> requestedTargetType)` Returns the target type we can read an inject of the given source type to.
`SimpleTypeHolder` `getSimpleTypeHolder()` Returns the underlying `SimpleTypeHolder`.
`boolean` `hasCustomReadTarget(Class<?> sourceType, Class<?> targetType)` Returns whether we have a custom conversion registered to read the given source into the given target type.
`boolean` `hasCustomWriteTarget(Class<?> sourceType)` Returns whether we have a custom conversion registered to read `sourceType` into a native type.
`boolean` `hasCustomWriteTarget(Class<?> sourceType, Class<?> targetType)` Returns whether we have a custom conversion registered to read an object of the given source type into an object of the given native target type.
`boolean` `isSimpleType(Class<?> type)` Returns whether the given type is considered to be simple.
`void` `registerConvertersIn(ConverterRegistry conversionService)` Populates the given `GenericConversionService` with the converters registered.

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### CustomConversions

    public CustomConversions(CustomConversions.ConverterConfiguration converterConfiguration)

Parameters:
  `converterConfiguration` - the `CustomConversions.ConverterConfiguration` to apply.
Since:
  2.3

#### CustomConversions

    public CustomConversions(CustomConversions.StoreConversions storeConversions,
                             Collection<?> converters)

Creates a new `CustomConversions` instance registering all given user defined converters and selecting `converters` from `CustomConversions.StoreConversions` depending on `store simple types` only considering those that either convert to/from a store supported type.

Parameters:
  `storeConversions` - must not be null.
  `converters` - must not be null.

### Method Detail

#### getSimpleTypeHolder

    public SimpleTypeHolder getSimpleTypeHolder()

Returns the underlying `SimpleTypeHolder`.

Returns:

#### isSimpleType

    public boolean isSimpleType(Class<?> type)

Returns whether the given type is considered to be simple. That means it's either a general simple type or we have a writing `Converter` registered for a particular type.

Parameters:
  `type` -
Returns:
See Also:
  `SimpleTypeHolder.isSimpleType(Class)`

#### registerConvertersIn

    public void registerConvertersIn(ConverterRegistry conversionService)

Populates the given `GenericConversionService` with the converters registered.

Parameters:
  `conversionService` -

#### getCustomWriteTarget

    public Optional<Class<?>> getCustomWriteTarget(Class<?> sourceType)

Returns the target type to convert to in case we have a custom conversion registered to convert the given source type into a store native one.

Parameters:
  `sourceType` - must not be null
Returns:

#### getCustomWriteTarget

    public Optional<Class<?>> getCustomWriteTarget(Class<?> sourceType,
                                                   Class<?> requestedTargetType)

Returns the target type we can read an inject of the given source type to. The returned type might be a subclass of the given expected type though. If `requestedTargetType` is null we will simply return the first target type matching or null if no conversion can be found.

Parameters:
  `sourceType` - must not be null
  `requestedTargetType` - must not be null.
Returns:

#### hasCustomWriteTarget

    public boolean hasCustomWriteTarget(Class<?> sourceType)

Returns whether we have a custom conversion registered to read `sourceType` into a native type. The returned type might be a subclass of the given expected type though.

Parameters:
  `sourceType` - must not be null
Returns:

#### hasCustomWriteTarget

    public boolean hasCustomWriteTarget(Class<?> sourceType,
                                        Class<?> targetType)

Returns whether we have a custom conversion registered to read an object of the given source type into an object of the given native target type.

Parameters:
  `sourceType` - must not be null.
  `targetType` - must not be null.
Returns:

#### hasCustomReadTarget

    public boolean hasCustomReadTarget(Class<?> sourceType,
                                       Class<?> targetType)

Returns whether we have a custom conversion registered to read the given source into the given target type.

Parameters:
  `sourceType` - must not be null
  `targetType` - must not be null
Returns: