All Classes and Interfaces
Class
Description
MapStruct specific abstract implementation of
ElementUtils.
Base type for mapping Java 8 time types to String and vice versa.
Base class for conversions between Joda-Time types and String.
An abstract builder that can be reused for building
MappingMethod(s).Abstract base class for
PrimitiveToStringConversion, WrapperToStringConversion,
BigDecimalToStringConversion and BigIntegerToStringConversion
Contains shared utility methods.Class acts as a common base class for
TargetReference and SourceReference.Base class for built-in methods for converting from a particular type to
XMLGregorianCalendar.Replaces the usage of
TypeUtils within MapStruct by delegating to the original implementation or to our
specific workarounds if necessary.Accessibility of an element
This represents an Accessor that can be used for writing/reading a property to/from a bean.
A service provider interface for the mapping between method names and properties.
Utils for working with the
AccessorNamingStrategy.Wraps the assignment in a target setter.
Helper class which is responsible for collecting all additional annotations that should be added.
Provider for any additional supported options required for custom SPI implementations.
A
PresenceCheck that checks if all the given presence checks are present.Represents a constructor that is used for constructor injection.
A method in a generated type that represents a setter with annotations.
Represents a Java 5 annotation.
An
ModelElementProcessor which converts the given Mapper object into an annotation based component
model in case a matching model is selected as target component model for this mapper.Represents an annotation element.
Mapper reference which is retrieved via Annotation-based dependency injection.
The dependency injection may vary between field and constructor injection.
The dependency injection may vary between field and constructor injection.
Indicates an error during annotation processing.
Keeps contextual data in the scope of the entire annotation processor ("application scope").
A
PresenceCheck that checks if any of the given presence checks are present.Decorates the assignment as a Map or Collection constructor
Assignment represents all kind of manners a source can be assigned to a target.
Base class for decorators (wrappers).
A contract to be implemented by other annotation processors which - against the design philosophy of JSR 269 - alter
the types under compilation.
A
MappingMethod implemented by a Mapper class which maps one bean type to another, optionally
configured by one or more PropertyMappings.Represents an bean mapping as configured via
@BeanMapping.Conversion between
BigDecimal and BigInteger.Conversion between
BigDecimal and native number types.Conversion between
BigDecimal and String.Conversion between
BigDecimal and wrappers of native number types.Conversion between
BigInteger and native number types.Conversion between
BigInteger and String.Conversion between
BigInteger and wrappers of native number types.Factory for creating the appropriate builder finisher method.
Holder for the builder information.
A service provider interface that is used to detect types that require a builder for mapping.
Represents the information about a builder.
Registry for all built-in methods.
Represents a "built-in" mapping method which will be added as private method to the generated mapper.
A built-in method for converting from
Calendar to XMLGregorianCalendar.Applies case transformation to the source enum
A
ModelElementProcessor which converts the given Mapper
object into an application-scoped CDI bean in case CDI is configured as the
target component model for this mapper.Conversion between
char and String.A builder that is used for creating an assignment to a collection.
Provides utility methods around collections.
Encapsulates all options specific for a condition check method.
Represents a condition configuration as configured via
@Condition.Basic interface class that facilitates an empty constructor.
ConstructorFragments are 'code snippets' added to the constructor to initialize fields used by
BuiltInMethod/HelperMethod
A
MappingMethod implemented by a Mapper class which does mapping of generic types.Builder that can be used to build
ContainerMappingMethod(s).Context object passed to conversion providers and built-in methods.
Implementations create inline
TypeConversions such as
(long)source,
Integer.valueOf(source) or
new SimpleDateFormat().format( source ).
Methods mainly used in
SimpleConversion classes, e. g.HelperMethod that creates a
DecimalFormat
DecimalFormat df = new DecimalFormat( numberFormat )
with setParseBigDecimal set to true.Selection based on type of method (create - or update method).
A built-in method for converting from
Date to XMLGregorianCalendar.Represents a decorator applied to a generated mapper type.
Represents the constructor of a decorator.
The default JavaBeans-compliant implementation of the
AccessorNamingStrategy service provider interface.Default implementation of
BuilderProvider.Default implementation of the
ConversionContext passed to conversion providers.The default implementation of the
EnumMappingStrategy service provider interface.Mapper reference which is retrieved via the
Mappers#getMapper() method.Default implementation of the processor context.
Provides information about the processor version and the processor context implementation version.
A method of a decorator which delegates to the corresponding method of the generated mapper implementation.
Chain Of Responsibility Pattern.
Decorates the assignment as an
Enum constant access.Represents an enum mapping as configured via
@EnumMapping.A service provider interface for the mapping between different enum constants
A service provider interface for transforming name based value mappings.
Provides functionality around
ExecutableElements.This wrapper handles the situation where an assignment is done for an update method.
This is a helper interface until we migrate to Java 8.
For factory methods, the candidate list is checked if it contains a method with a source parameter which is to be
favored compared to factory methods without a source parameter.
A field of a mapper type, e.g. a reference to another mapper.
reference used by BuiltInMethod/HelperMethod to create an additional field in the mapper.
Provides functionality around
VariableElements.Filter methods for working with
Element collections.A mapper instance field, initialized as null
This method will be generated in absence of a suitable abstract method to implement.
Keeps the context where the ForgedMethod is generated, especially handy with nested forged methods
Prints out diagnostics raised by the annotation processor.
Represent information about the configured formatting.
Accessor naming strategy for FreeBuilder.
Helper for holding FreeBuilder FQN.
A
Writable which uses the FreeMarker template engine to generate the output.An inline conversion from an optional source to it's value.
A type generated by MapStruct, e.g. representing a mapper type.
Base class for methods available in a generated type.
This wrapper handles the situation were an assignment must be done via a target getter method because there
is no setter available.
Analyzes graphs: Discovers all descendants of given nodes and detects cyclic dependencies between nodes if present.
A non mapping method to be generated.
Accessor naming strategy for Immutables.
Builder provider for Immutables.
Helper for holding Immutables FQN.
This is a wrapper class for the Implementation types that are used within MapStruct.
Selects on inheritance distance, e.g. the amount of inheritance steps from the parameter type.
Utilities for tools to learn about the properties, events, and methods supported by a target Java Bean.
A
MappingMethod implemented by a Mapper class which maps one iterable type to another.Represents an iterable mapping as configured via
@IterableMapping.A
ModelElementProcessor which converts the given Mapper
object into an application-scoped Jakarta CDI bean in case Jakarta CDI
is configured as the target component model for this mapper.A
ModelElementProcessor which converts the given Mapper
object into a Jakarta Inject style bean in case "jakarta" is configured as the
target component model for this mapper.Wraps the assignment in a Function to be used in Java 8 map methods
Helper holding Java collections full qualified class names for conversion registration,
to achieve Java compatibility.
Represents the javadoc information that should be generated for a
Mapper.A
PresenceCheck that calls a Java expression.SimpleConversion for mapping
LocalDateTime to
Date and vice versa.SimpleConversion for mapping
LocalDateTime to
LocalDate and vice versa.Specialization of
AbstractJavaTimeToStringConversion for converting LocalDateTimeSpecialization of
AbstractJavaTimeToStringConversion for converting LocalDateSpecialization of
AbstractJavaTimeToStringConversion for converting LocalTimeHelper holding Java Stream full qualified class names for conversion registration
SimpleConversion for mapping
ZonedDateTime to
Date and vice versa.Specialization of
AbstractJavaTimeToStringConversion for converting ZonedDateTimeHelper holding JAXB time full qualified class names for conversion registration
Conversion between
DateTime and Calendar.Conversion between
DateTime and String.A built-in method for converting from Joda
DateTime to XMLGregorianCalendar.Conversion between
LocalDateTime and String.A built-in method for converting from Joda
LocalDateTime to XMLGregorianCalendar.Conversion between
LocalDate and String.A built-in method for converting from Joda
LocalDate to XMLGregorianCalendar.Conversion between
LocalTime and String.A built-in method for converting from Joda
LocalTime to XMLGregorianCalendar.Helper holding constants for working with Joda-Time.
Conversion between the following Joda types and
Date:
org.joda.time.DateTime
org.joda.time.LocalDateTime
org.joda.time.LocalDate
A
ModelElementProcessor which converts the given Mapper
object into a JSR 330 style bean in case "jsr330" is configured as the
target component model for this mapper.Information about a type in case it's a Kotlin type.
Represents a reference to a method that is annotated with
@BeforeMapping or @AfterMapping.Factory for creating lists of appropriate
LifecycleCallbackMethodReferencesSelector for deduplicating overloaded lifecycle callback methods
whose parameter signatures differ only by type hierarchy.
A built-in method for converting from
LocalDateTime to XMLGregorianCalendar.A built-in method for converting from
LocalDate to XMLGregorianCalendar.Decorates an assignment as local variable.
Represents a map mapping as configured via
@MapMapping.Represents a type implementing a mapper interface (annotated with
@Mapper).Handles redirection of errors/warnings so that they're shown on the mapper instead of hidden on a superclass.
A reference to another mapper class, which itself may be generated or hand-written.
A
ModelElementProcessor which creates a Java source file representing
the given Mapper object, unless the given mapper type is erroneous.A
ModelElementProcessor which creates files in the META-INF/services
hierarchy for classes with custom implementation class or package name.This class provides the context for the builders.
Resolves the most suitable way for mapping an element (property, iterable element etc.) from source to target.
A service provider interface that is used to control if MapStruct is allowed to generate automatic sub-mapping for
a given
TypeElement.A method implemented or referenced by a
Mapper class.Encapsulates all options specifiable on a mapping method
Utility class for mapping methods.
The different compiler mapping options that are available in MapStruct.
Represents a property mapping as configured via
@Mapping (no intermediate state).A JSR 269 annotation
Processor which generates the implementations for mapper interfaces (interfaces
annotated with @Mapper).Represents the intermediate (nesting) state of the
MappingOptions in this class.The one and only implementation of
MappingBuilderContext.MappingResolver.MapStruct will provide the implementations of its SPIs with on object implementing this interface so they can use
facilities provided by it.
An
Accessor that wraps a Map value.A message used in warnings/errors raised by the annotation processor.
A base helper class that provides utility methods for working with meta annotations.
This interface makes available common method properties and a matching method There are 2 known implementors:
BuiltInMethod and SourceMethodSelects those methods from the given input set which match for the requested family of methods: factory methods,
lifecycle callback methods, or any other mapping methods.
SourceMethodMatcher $8.4 of the JavaLanguage specification describes a method body as such:
Represents a reference to another method, e.g. used to map a bean property from source to target type or to
instantiate the return value of a mapping method (rather than calling the
new operator).A
PresenceCheck that is based on a MethodReference.A
ModelElementProcessor which retrieves a list of SourceMethods
representing all the mapping methods of the given bean mapper type as well as
all referenced mapper methods declared by other mappers referenced by the
current mapper.Applies all known
MethodSelectors in order.Different types of a method.
Base class of all model elements.
A processor which performs one task of the mapper generation, e.g. retrieving
methods from the source
TypeElement, performing validity checks or
generating the output source file.Context object passed to
ModelElementProcessor.process(ProcessorContext, TypeElement, Object)
providing access to common infrastructure objects such as TypeUtils
etc.A
TemplateDirectiveModel which allows to recursively write a graph of
Writables, with each element using its own template.Writes Java source files based on given mapper models, using a FreeMarker
template.
Indicates that a type has too many builder creation methods.
A
MethodSelector that selects the most specific result type.Provides functionality around the Java primitive data types and their wrapper types.
A
PresenceCheck that negates the result of another presence check.This method is used to convert the nested properties as listed in propertyEntries into a method
that creates a mapping from the start of this list to the end of the list.
This is a helper class that holds the generated
PropertyMapping(s) and all the information associated with
it for nested target properties.This wrapper handles the situation where an assignment is done via the setter, while creating the collection or map
using a no-args constructor.
Represents a constructor that is used for constructor injection.
A NoOp
BuilderProvider which returns null when searching for a builder.A
MappingMethod that is used by the main mapping methods (BeanMappingMethod,
MapMappingMethod, IterableMappingMethod and StreamMappingMethod (non-enum / non-value
mapping)Class taking care of Noun manipulation
A presence check that checks if the source reference is null.
Factory for creating the appropriate object factory method.
Decorates the assignment as an
Optional.get() call.Presence checker for
Optional types.A conversion provider that wraps / unwraps the underlying conversion in Optional.
The options passed to the code generator.
A parameter of a mapping method.
Represents how one parameter of a method to be called is populated.
Provides access to the
SourceMethods that are provided by Context parameters of a
Method and maintains the relationship between those methods and their originating parameter.An
EnumTransformationStrategy that prepends a prefix to the enum value.Marker interface for presence checks.
Accessor for presence checks.
Factory for creating
PresenceChecks.Conversion between primitive types such as
byte or long.Conversion between primitive types such as
byte and wrapper types
such as Integer.A PropertyEntry contains information on the name, readAccessor and presenceCheck (for source)
and return type of property.
Represents the mapping between a source and target property, e.g. from
String Source#foo to
int Target#bar.This selector selects a best match based on qualifier annotations.
An
Accessor that can be used for reading a property from a bean.ReadAccessor that delegates to another Accessor and requires an implementation of
DelegateAccessor.getSimpleName()A base helper class that provides utility methods for working with repeatable annotations.
Decorates an assignment as a return variable.
* A
ConversionProvider which creates the inversed conversions for a
given conversion provider.Keeps contextual data in the scope of one annotation processing round.
A selected method with additional metadata that might be required for further usage of the selected method.
Context passed to the selectors to get the information they need.
This class groups the selection criteria in one class
Holding parameters common to the selection process, common to IterableMapping, BeanMapping, PropertyMapping and
MapMapping
A simple locator for SPI implementations.
Represents a service entry for the service loader file.
Wraps the assignment in a target setter.
This wrapper handles the situation where an assignment is done via the setter, without doing anything special.
This wrapper handles the situation where an assignment is done via the setter and a null check is needed.
Base class for
ConversionProviders creating TypeConversions which don't declare any exception types.Represents a mapping method with source and target type and the mappings between the properties of source and target
type.
This class describes the source side of a property mapping.
Builds a
SourceReference from an @Mappping.Builds a
SourceReference from a property.Builds a
SourceReference from a property.SourceRHS Assignment.
Selector that tries to resolve an ambiguity between methods that contain source parameters and
SourceRHS type parameters.A
ModelElementProcessor which converts the given Mapper
object into a Spring bean in case Spring is configured as the
target component model for this mapper.Handles conversion between a target type
T and String,
where T#parse(String) and T#toString are inverse operations.Wraps the assignment in a target setter.
A
MappingMethod implemented by a Mapper class which maps one iterable or array type to Stream.Handles conversion between a target type
StringBuilder and String.Helper class for dealing with strings.
A built-in method for converting from
String to XMLGregorianCalendar.An
EnumTransformationStrategy that strips a prefix from the enum value.An
EnumTransformationStrategy that strips a suffix from the enum value.Represents the mapping between a Subclass and its mapping target.
Represents a subclass mapping as configured via
@SubclassMapping.Handles the validation of multiple @SubclassMapping annotations on the same method.
An
EnumTransformationStrategy that appends a suffix to the enum value.A
PresenceCheck that calls the suffix on the source reference.A mapper instance field, initialized as null
supports the
A mapping method which is not based on an actual method declared in the original mapper interface but is added as
private method to map a certain source/target type combination.
This class describes the target side of a property mapping.
Builds a
TargetReference from an @Mappping.This selector selects a best match based on the result type.
An inline conversion from a source to an optional of the source.
Represents (a reference to) the type of a bean property, parameter etc.
Reflects any Resolved Pair, examples are
T, String
?
An inline conversion between source and target type of a mapping.
Factory creating
Type instances.Indicates a type was visited whose hierarchy was erroneous, because it has a non-existing super-type.
Selects those methods from the given input set which match the given source and target types (via
MethodMatcher).Conversion between
Optional and its base type.Wraps the assignment in a target setter.
A
ValueMappingMethod which maps one value type to another, optionally configured by one or more
ValueMappingOptionss.Represents the mapping between one value constant and another.
Provides information about the processor version and the processor context implementation version
This is the base class for the
GetterWrapperForCollectionsAndMaps and
SetterWrapperForCollectionsAndMapsAn element with the ability to write itself into a given
Writer.Passed to
Writable, providing access to additional data specific to a given implementation of the model
serialization mechanism.Helper holding JAXB time full qualified class names for conversion registration
A builder that can be implemented by the user to define custom logic e.g. in the
build method, prior to creating the annotation gem.
A builder that can be implemented by the user to define custom logic e.g. in the
build method, prior to creating the annotation gem.
A built-in method for converting from
XMLGregorianCalendar to Calendar.A built-in method for converting from
XMLGregorianCalendar to Date.A built-in method for converting from Joda
DateTime to Calendar.A built-in method for converting from
XMLGregorianCalendar to Joda LocalDate.A built-in method for converting from
XMLGregorianCalendar to Joda LocalDateTime.Conversion from
XMLGregorianCalendar to Joda LocalTime.A built-in method for converting from
XMLGregorianCalendar to LocalDate.A built-in method for converting from
XMLGregorianCalendar to LocalDateTime.A built-in method for converting from
XMLGregorianCalendar to String.A built-in method for converting from
ZonedDateTime to XMLGregorianCalendar.