Package org.modelmapper

Interface TypeMap<S,D>

Type Parameters:
S - source type
D - destination type
public interface TypeMap<S,D>
Encapsulates mapping configuration for a source and destination type pair.

  • Method Details

    • addMappings

      TypeMap<S,D> addMappings(PropertyMap<S,D> propertyMap)
      Loads mappings from the propertyMap into the TypeMap. Mappings defined in the propertyMap will override any implicit mappings for the same properties.
      Parameters:
      propertyMap - from which mappings should be loaded
      Returns:
      this type map
      Throws:
      IllegalArgumentException - if propertyMap is null
      ConfigurationException - if a configuration error occurs while adding mappings for the propertyMap

    • getCondition

      Condition<?,?> getCondition()
      Returns the Condition that must apply for the source and destination in order for mapping to take place, else null if no condition has been configured.
      See Also:

    • getConverter

      Converter<S,D> getConverter()
      Returns the Converter configured for this TypeMap, else null if no Converter has been configured.
      See Also:

    • getDestinationType

      Class<D> getDestinationType()
      Returns the destination type for the TypeMap.

    • getMappings

      List<Mapping> getMappings()
      Returns a snapshot of the TypeMap's mappings.

      This method is part of the ModelMapper SPI.

    • getName

      String getName()
      Returns the name of the TypeMap, else null if the TypeMap has no name.

    • getPostConverter

      Converter<S,D> getPostConverter()
      Returns the converter to be used after mapping between the source and destination types, else null if no post-Converter has been configured.
      See Also:

    • getPreConverter

      Converter<S,D> getPreConverter()
      Returns the converter to be used before mapping between the source and destination types, else null if no post-Converter has been configured.
      See Also:

    • getPropertyCondition

      Condition<?,?> getPropertyCondition()
      Returns the Condition that must apply in properties in this TypeMap to be mapped, else null if no condition has been configured.
      See Also:

    • getPropertyConverter

      Converter<?,?> getPropertyConverter()
      Returns the Converter used for converting properties in the TypeMap, else null if no Converter has been configured.
      See Also:

    • getPropertyProvider

      Provider<?> getPropertyProvider()
      Returns the Provider configured for this TypeMap, else null if no Provider has been configured.
      See Also:

    • getProvider

      Provider<D> getProvider()
      Returns the Provider configured for this TypeMap, else null if no Provider has been configured.
      See Also:

    • getSourceType

      Class<S> getSourceType()
      Returns the source type for the TypeMap.

    • getUnmappedProperties

      List<PropertyInfo> getUnmappedProperties()
      Returns a snapshot list of destination properties that do not have mappings defined, else empty list if all destination properties are mapped.

      This method is part of the ModelMapper SPI.

    • map

      D map(S source)
      Maps source to an instance of type D.
      Parameters:
      source - object to map from
      Returns:
      fully mapped instance of type D
      Throws:
      IllegalArgumentException - if source is null
      MappingException - if an error occurs while mapping

    • map

      void map(S source, D destination)
      Maps source to destination.
      Parameters:
      source - object to map from
      destination - object to map to
      Throws:
      IllegalArgumentException - if source or destination are null
      MappingException - if an error occurs while mapping

    • setCondition

      TypeMap<S,D> setCondition(Condition<?,?> condition)
      Sets the condition that must apply for the source and destination in order for mapping to take place.
      Throws:
      IllegalArgumentException - if condition is null

    • setConverter

      TypeMap<S,D> setConverter(Converter<S,D> converter)
      Sets the converter to be used for any conversion requests for the TypeMap's source to destination type. This converter will be used in place of any mappings that have been added to the TypeMap.
      Throws:
      IllegalArgumentException - if converter is null

    • setPostConverter

      TypeMap<S,D> setPostConverter(Converter<S,D> converter)
      Sets the converter to be used after mapping between the source and destination types.
      Throws:
      IllegalArgumentException - if converter is null

    • setPreConverter

      TypeMap<S,D> setPreConverter(Converter<S,D> converter)
      Sets the converter to be used before mapping between the source and destination types.
      Throws:
      IllegalArgumentException - if converter is null

    • setPropertyCondition

      TypeMap<S,D> setPropertyCondition(Condition<?,?> condition)
      Sets the condition that must apply in order for properties in this TypeMap to be mapped. This is overridden by any conditions defined in a PropertyMap.
      Throws:
      IllegalArgumentException - if condition is null

    • setPropertyConverter

      TypeMap<S,D> setPropertyConverter(Converter<?,?> converter)
      Sets the converter to be used for converting properties in the TypeMap. This is overridden by any converters defined in a PropertyMap.
      Throws:
      IllegalArgumentException - if converter is null

    • setPropertyProvider

      TypeMap<S,D> setPropertyProvider(Provider<?> provider)
      Sets the provider to be used for providing instances of properties during mapping. This is overriden by any providers defined in a PropertyMap.
      Throws:
      IllegalArgumentException - if provider is null

    • setProvider

      TypeMap<S,D> setProvider(Provider<D> provider)
      Sets the provider to be used for providing instances of destination type D during mapping.
      Throws:
      IllegalArgumentException - if provider is null

    • validate

      void validate()
      Validates that every top level destination property is mapped to one and only one source property, or that a Converter was set. If not, a ConfigurationException is thrown detailing any missing mappings.
      Throws:
      ValidationException - if any TypeMaps contain unmapped properties

    • addMapping

      <V> TypeMap<S,D> addMapping(SourceGetter<S> sourceGetter, DestinationSetter<D,V> destinationSetter)
      Adds a mapping into TypeMap by defining sourceGetter -> destinationSetter 
       
   typeMap.addMapping(Src::getA, Dest::setB);
   typeMap.<String>addMapping(src -> src.getC().getD(), (dest, value) -> dest.getE().setF(value))
      Type Parameters:
      V - type of destination property wants to be set
      Parameters:
      sourceGetter - source property getter
      destinationSetter - destination property setter

    • addMappings

      TypeMap<S,D> addMappings(ExpressionMap<S,D> mapper)
      Add a mapping into TypeMap by defining a mapper action You can chain addMappings contains only one property mapping like 
       
   typeMap.addMappings(mapper -> mapper.<String>map(Src::getA, Dest::setB))
          .addMappings(mapper -> mapper.<String>skip(Dest::setB))
          .addMappings(mapper -> mapper.when(condition).<String>map(Src::getA, Dest::setB))
          .addMappings(mapper -> mapper.when(condition).<String>skip(Dest::setB))
          .addMappings(mapper -> mapper.using(converter).<String>map(Src::getA, Dest::setB))
          .addMappings(mapper -> mapper.with(provider).<String>map(Src::getA, Dest::setB));
      Or you can define all property mappings in one addMappings like 
       
   typeMap.addMappings(mapper -> {
     mapper.<String>map(Src::getA, Dest::setB);
     mapper.<String>skip(Dest::setB);
     mapper.when(condition).<String>map(Src::getA, Dest::setB);
   });
      Parameters:
      mapper - a mapper defined a mapping action
      Returns:
      this typeMap

    • include

      <DS extends S, DD extends D> TypeMap<S,D> include(Class<DS> sourceType, Class<DD> destinationType)
      Constructs a new TypeMap derived from this. The derived TypeMap will include all mappings from the base TypeMap, but will NOT include converter, condition, and provider from the base TypeMap.
      Type Parameters:
      DS - derived type of source class
      DD - derived type of destination class
      Parameters:
      sourceType - source type
      destinationType - destination type
      Returns:
      this type map
      Throws:
      IllegalArgumentException - if TypePair.of(sourceType, destinationType) already defined in modelMapper.getTypeMaps()

    • include

      TypeMap<S,D> include(Class<? super D> baseDestinationType)
      Makes this TypeMap is also supporting on the mapping from sourceType to baseDestinationType.
      Parameters:
      baseDestinationType - the base destination type
      Returns:
      this type map.
      Throws:
      IllegalArgumentException - if TypePair.of(sourceType, baseDestinationType) already defined in modelMapper.getTypeMaps()

    • includeBase

      TypeMap<S,D> includeBase(Class<? super S> sourceType, Class<? super D> destinationType)
      Includes mappings from a base TypeMap.
      Parameters:
      sourceType - source type
      destinationType - destination type
      Returns:
      this type map
      Throws:
      IllegalArgumentException - if TypePair.of(sourceType, destinationType) already defined in modelMapper.getTypeMaps()

    • include

      <P> TypeMap<S,D> include(TypeSafeSourceGetter<S,P> sourceGetter, Class<P> propertyType)
      Includes mappings from property's TypeMap. If we want to map Source to Destination and we already have a TypeMap map a property of the source to destination, then we can include this property's TypeMap by include(Source::getProperty, Property.class).
      Parameters:
      sourceGetter - the source getter
      propertyType - the property type
      Returns:
      this type map

    • implicitMappings

      TypeMap<S,D> implicitMappings()
      Performs implicit mapping.
      Returns:
      this type map