diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/PropertyMapping.java b/processor/src/main/java/org/mapstruct/ap/internal/model/PropertyMapping.java index d5ae07544..0261a09e5 100644 --- a/processor/src/main/java/org/mapstruct/ap/internal/model/PropertyMapping.java +++ b/processor/src/main/java/org/mapstruct/ap/internal/model/PropertyMapping.java @@ -51,6 +51,7 @@ import static org.mapstruct.ap.internal.model.assignment.Assignment.AssignmentTy import static org.mapstruct.ap.internal.model.assignment.Assignment.AssignmentType.MAPPED_TYPE_CONVERTED; import static org.mapstruct.ap.internal.model.assignment.Assignment.AssignmentType.TYPE_CONVERTED; import static org.mapstruct.ap.internal.model.assignment.Assignment.AssignmentType.TYPE_CONVERTED_MAPPED; +import org.mapstruct.ap.internal.util.MapperConfiguration; /** * Represents the mapping between a source and target property, e.g. from {@code String Source#foo} to @@ -429,6 +430,9 @@ public class PropertyMapping extends ModelElement { else { PropertyEntry lastPropertyEntry = propertyEntries.get( propertyEntries.size() - 1 ); + // copy mapper configuration from the source method, its the same mapper + MapperConfiguration config = method.getMapperConfiguration(); + // forge a method from the parameter type to the last entry type. String forgedName = Strings.joinAndCamelize( sourceReference.getElementNames() ); forgedName = Strings.getSaveVariableName( forgedName, ctx.getNamesOfMappingsToGenerate() ); @@ -436,6 +440,7 @@ public class PropertyMapping extends ModelElement { forgedName, sourceReference.getParameter().getType(), lastPropertyEntry.getType(), + config, method.getExecutable() ); NestedPropertyMappingMethod.Builder builder = new NestedPropertyMappingMethod.Builder(); @@ -515,7 +520,9 @@ public class PropertyMapping extends ModelElement { if ( ( sourceType.isCollectionType() || sourceType.isArrayType() ) && ( targetType.isCollectionType() || targetType.isArrayType() ) ) { - ForgedMethod methodRef = new ForgedMethod( name, sourceType, targetType, element ); + // copy mapper configuration from the source method, its the same mapper + MapperConfiguration config = method.getMapperConfiguration(); + ForgedMethod methodRef = new ForgedMethod( name, sourceType, targetType, config, element ); IterableMappingMethod.Builder builder = new IterableMappingMethod.Builder(); IterableMappingMethod iterableMappingMethod = builder @@ -538,7 +545,9 @@ public class PropertyMapping extends ModelElement { } else if ( sourceType.isMapType() && targetType.isMapType() ) { - ForgedMethod methodRef = new ForgedMethod( name, sourceType, targetType, element ); + // copy mapper configuration from the source method, its the same mapper + MapperConfiguration config = method.getMapperConfiguration(); + ForgedMethod methodRef = new ForgedMethod( name, sourceType, targetType, config, element ); MapMappingMethod.Builder builder = new MapMappingMethod.Builder(); MapMappingMethod mapMappingMethod = builder diff --git a/processor/src/main/java/org/mapstruct/ap/internal/model/source/ForgedMethod.java b/processor/src/main/java/org/mapstruct/ap/internal/model/source/ForgedMethod.java index a973580cd..d34b0afd5 100644 --- a/processor/src/main/java/org/mapstruct/ap/internal/model/source/ForgedMethod.java +++ b/processor/src/main/java/org/mapstruct/ap/internal/model/source/ForgedMethod.java @@ -44,6 +44,7 @@ public class ForgedMethod implements Method { private final String name; private final ExecutableElement positionHintElement; private final List thrownTypes; + private final MapperConfiguration mapperConfiguration; /** * Creates a new forged method with the given name. @@ -53,13 +54,15 @@ public class ForgedMethod implements Method { * @param targetType the target type. * @param positionHintElement element used to for reference to the position in the source file. */ - public ForgedMethod(String name, Type sourceType, Type targetType, ExecutableElement positionHintElement) { + public ForgedMethod(String name, Type sourceType, Type targetType, MapperConfiguration mapperConfiguration, + ExecutableElement positionHintElement) { String sourceParamName = Strings.decapitalize( sourceType.getName().replace( "[]", "" ) ); String sourceParamSafeName = Strings.getSaveVariableName( sourceParamName ); this.parameters = Arrays.asList( new Parameter( sourceParamSafeName, sourceType ) ); this.returnType = targetType; this.thrownTypes = new ArrayList(); this.name = name; + this.mapperConfiguration = mapperConfiguration; this.positionHintElement = positionHintElement; } @@ -72,6 +75,7 @@ public class ForgedMethod implements Method { this.parameters = forgedMethod.parameters; this.returnType = forgedMethod.returnType; this.thrownTypes = new ArrayList(); + this.mapperConfiguration = forgedMethod.mapperConfiguration; this.positionHintElement = forgedMethod.positionHintElement; this.name = name; } @@ -204,7 +208,7 @@ public class ForgedMethod implements Method { @Override public MapperConfiguration getMapperConfiguration() { - return null; + return mapperConfiguration; } @Override diff --git a/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMapperNullValueMappingReturnDefault.java b/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMapperNullValueMappingReturnDefault.java new file mode 100644 index 000000000..632860d02 --- /dev/null +++ b/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMapperNullValueMappingReturnDefault.java @@ -0,0 +1,33 @@ +/** + * Copyright 2012-2015 Gunnar Morling (http://www.gunnarmorling.de/) + * and/or other contributors as indicated by the @authors tag. See the + * copyright.txt file in the distribution for a full listing of all + * contributors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.mapstruct.ap.test.collection.forged; + +import org.mapstruct.Mapper; +import org.mapstruct.NullValueMappingStrategy; +import org.mapstruct.factory.Mappers; + +@Mapper( nullValueMappingStrategy = NullValueMappingStrategy.RETURN_DEFAULT ) +public interface CollectionMapperNullValueMappingReturnDefault { + + CollectionMapperNullValueMappingReturnDefault INSTANCE = + Mappers.getMapper( CollectionMapperNullValueMappingReturnDefault.class ); + + Target sourceToTarget( Source source ); + Source targetToSource( Target target ); +} diff --git a/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMappingTest.java b/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMappingTest.java index 434778ebe..593318d12 100644 --- a/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMappingTest.java +++ b/processor/src/test/java/org/mapstruct/ap/test/collection/forged/CollectionMappingTest.java @@ -121,5 +121,72 @@ public class CollectionMappingTest { } + @Test + @IssueKey( "640" ) + @WithClasses({ CollectionMapper.class, Source.class, Target.class }) + public void shouldForgeNewIterableMappingMethodReturnNullOnNullSource() { + + Source source = new Source(); + source.setFooSet( null ); + + Target target = CollectionMapper.INSTANCE.sourceToTarget( source ); + assertThat( target ).isNotNull(); + assertThat( target.getFooSet() ).isNull(); + + Source source2 = CollectionMapper.INSTANCE.targetToSource( target ); + assertThat( source2 ).isNotNull(); + assertThat( source2.getFooSet() ).isNull(); + } + + @Test + @IssueKey( "640" ) + @WithClasses({ CollectionMapper.class, Source.class, Target.class }) + public void shouldForgeNewMapMappingMethodReturnNullOnNullSource() { + + Source source = new Source(); + source.setBarMap( null ); + + Target target = CollectionMapper.INSTANCE.sourceToTarget( source ); + assertThat( target ).isNotNull(); + assertThat( target.getBarMap() ).isNull(); + + Source source2 = CollectionMapper.INSTANCE.targetToSource( target ); + assertThat( source2 ).isNotNull(); + assertThat( source2.getBarMap() ).isNull(); + } + + @Test + @IssueKey( "640" ) + @WithClasses({ CollectionMapperNullValueMappingReturnDefault.class, Source.class, Target.class }) + public void shouldForgeNewIterableMappingMethodReturnEmptyOnNullSource() { + + Source source = new Source(); + source.setFooSet( null ); + + Target target = CollectionMapperNullValueMappingReturnDefault.INSTANCE.sourceToTarget( source ); + assertThat( target ).isNotNull(); + assertThat( target.getFooSet() ).isEmpty(); + + Source source2 = CollectionMapperNullValueMappingReturnDefault.INSTANCE.targetToSource( target ); + assertThat( source2 ).isNotNull(); + assertThat( source2.getFooSet() ).isEmpty(); + } + + @Test + @IssueKey( "640" ) + @WithClasses({ CollectionMapperNullValueMappingReturnDefault.class, Source.class, Target.class }) + public void shouldForgeNewMapMappingMethodReturnEmptyOnNullSource() { + + Source source = new Source(); + source.setBarMap( null ); + + Target target = CollectionMapperNullValueMappingReturnDefault.INSTANCE.sourceToTarget( source ); + assertThat( target ).isNotNull(); + assertThat( target.getBarMap() ).isEmpty(); + + Source source2 = CollectionMapperNullValueMappingReturnDefault.INSTANCE.targetToSource( target ); + assertThat( source2 ).isNotNull(); + assertThat( source2.getBarMap() ).isEmpty(); + } }