Instead of importing all classes, inner classes will be used through their top level classes only.
This also fixes the problem in #2593 since inner classes are no longer imported but used through their top classes
Add new `@SubclassMapping` for creating Downcast mapping.
When a parent mapping method is annotated with `@SubclassMapping`
it will now generate an instanceof check inside the parent mapping
and generate the subclass mappings if they are not manually defined.
There is also `SubclassExhaustiveStrategy` for controlling what MapStruct should do in case the target type is abstract and there is no suitable way to create it.
* GetDateTimeFormatterField
** a FieldReference that creates DateTimeFormatters
for given dateFormat as mapper fields
** variableName is created using given dateFormat
* AbstractJavaTimeToStringConversion
provides GetDateTimeFormatterField as required helper field
using DateTimeFormatter instances provided as mapper fields
by GetDateTimeFormatterField
* ConversionProvider
might provide supporting fields directly
* Refactoring
moved/renamed BuiltInFieldReference, BuiltInConstuctorFragment to
package model/common
* MappingBuilderContext provides access to mapper support fields
(that are independent of mapper methods)
* MappingResolverImpl / MapperCreationProcessor
process supporting fields provided by ConversionProvider
* HelperMethod
** extended to supply additional template parameters to
be more flexible in freemarker templates
** extended to support mapper field reference / constructor fragment
* SupportingMappingMethod
** provide templateParameters to freemarker
** hashCode/equals base on name property instead of template name,
as we use one specific template multiple times with different
parameters generating multiple methods
** #getSafeField extracted to SupportingField
* SupportingField
** removed hashCode/equals based on template name,
as we use one specific template multiple times with different
parameters generating multiple methods
(superclass equals/hashcode is fine for that)
** added support for template parameters to be more flexible when
compiling templates
* Tests to verify DateTimeFormatter instance field creation
With JUnit Jupiter it is still not possible to set the ClassLoader for loading the test class.
However, since 5.8 M1 there is a way to hook into the launcher discovery process and change the Current Thread ContextClassLoader which would load the classes with our customer ClassLoader.
Once JUnit Jupiter 201 is resolved we can simplify this.
The CompilationCache is stored in the GlobalCache with the CompilationRequest as key.
This means that even when methods are not executed in some particular order if they have same WithClasses then they would reuse the cache.
This allows to easily avoid the runtime dependency on mapstruct.jar:
we can avoid Mappers.getMapper(...) for instantiating used mappers if
the code follows the conventional pattern for creating mapper singletons.
Co-authored-by: GIBOU Damien <damien.gibou@biomerieux.com>
Make sure that MappingReferences are taken into consideration when comparing whether 2 mapping methods are equal.
This makes sure that when using nested target mappings that have the same property mappings, but different mappings 2 distinct methods will be created
Add a new EnumNamingStrategy SPI which can be used for customising the way enums are matched by name.
It is similar to the AccessorNamingStrategy such that it allows implementors to provide a custom way of defining a property.
Related to #796, #1220, #1789 and #1667
By default the constructor argument names are used to extract the target properties.
If a constructor is annotated with an annotation named `@ConstructorProperties` (from any package) then it would be used to extract the target properties.
If a mapping target has a parameterless empty constructor it would be used to instantiate the target.
When there are multiple constructors then an annotation named `@Default` (from any package) can be used to mark a constructor that should be used by default when instantiating the target.
Supports mapping into Java 14 Records and Kotlin data classes out of the box
Adapt checkstyle configuration with new changes:
* Move cacheFile to Checker module
* Move LineLength to Checker module
* Use SuppressWithPlainTextCommentFilter
* SetterWrapperForCollectionsAndMaps - Does a simple assignment without doing any null checks
* SetterWrapperForCollectionsAndMapsWithNullCheck - Does an assignment that does a null check before assignment and takes direct assignment into consideration
* ExistingInstanceSetterWrapperForCollectionsAndMaps - Used for wrapping an assignment when the method is an update method
Additionally don't do local var assignment if there are presence checkers
