Resolved #36

Resolved #35

Author: Rickvanderwaal

src/main/java/io/beanmapper/BeanMapper.java

@@ -14,8 +14,7 @@
 import io.beanmapper.core.converter.collections.CollectionMapConverter;
 import io.beanmapper.core.converter.collections.CollectionSetConverter;
 import io.beanmapper.core.converter.impl.*;
-import io.beanmapper.core.rule.BeanMapperRule;
-import io.beanmapper.core.rule.ConstantMapperRule;
+import io.beanmapper.core.rule.MappableFields;
 import io.beanmapper.core.unproxy.BeanUnproxy;
 import io.beanmapper.core.unproxy.DefaultBeanUnproxy;
 import io.beanmapper.core.unproxy.SkippingBeanUnproxy;
@@ -135,7 +134,7 @@ public <S, T> T map(S source, Class<T> targetClass, BeanInitializer beanInitiali
         BeanMatch beanMatch = getBeanMatch(source.getClass(), targetClass);
         T target = beanInitializer.instantiate(targetClass, getConstructorArguments(source, beanMatch));
 
-        return processFields(source, target, beanMatch, new ConstantMapperRule(true));
+        return processFields(source, target, beanMatch);
     }
 
     /**
@@ -182,22 +181,21 @@ public <S, T> Collection<T> map(Collection<S> sourceItems, Class<T> targetClass,
      */
     public <S, T> T map(S source, T target) {
         BeanMatch beanMatch = getBeanMatch(source.getClass(), target.getClass());
-        return processFields(source, target, beanMatch, new ConstantMapperRule(true));
+        return processFields(source, target, beanMatch);
     }
 
     /**
      * Copies the values from the source object to an existing target instance
      * @param source source instance of the properties
      * @param target target instance for the properties
-     * @param rule the matching rule
      * @param <S> the instance from which the properties get copied.
      * @param <T> the instance to which the properties get copied
      * @return the original target instance containing all applicable properties
      * @throws BeanMappingException
      */
-    public <S, T> T map(S source, T target, BeanMapperRule rule) {
+    public <S, T> T map(S source, T target, MappableFields fieldsToMap) {
         BeanMatch beanMatch = getBeanMatch(source.getClass(), target.getClass());
-        return processFields(source, target, beanMatch, rule);
+        return processFields(source, target, fieldsToMap.compressBeanMatch(beanMatch));
     }
 
     private <S> ConstructorArguments getConstructorArguments(S source, BeanMatch beanMatch) {
@@ -249,7 +247,7 @@ private <T, S> BeanMatch getBeanMatch(Class<S> sourceClazz, Class<T> targetClazz
      * @return A filled target object.
      * @throws BeanMappingException
      */
-    private <S, T> T processFields(S source, T target, BeanMatch beanMatch, BeanMapperRule rule) {
+    private <S, T> T processFields(S source, T target, BeanMatch beanMatch) {
         for (String fieldName : beanMatch.getTargetNode().keySet()) {
             BeanField sourceField = beanMatch.getSourceNode().get(fieldName);
             if(sourceField == null) {
@@ -261,7 +259,7 @@ private <S, T> T processFields(S source, T target, BeanMatch beanMatch, BeanMapp
                 // No target field found -> check for alias
                 targetField = beanMatch.getAliases().get(fieldName);
             }
-            processField(new BeanFieldMatch(source, target, sourceField, targetField, fieldName, beanMatch), rule);
+            processField(new BeanFieldMatch(source, target, sourceField, targetField, fieldName, beanMatch));
         }
         return target;
     }
@@ -271,17 +269,17 @@ private <S, T> T processFields(S source, T target, BeanMatch beanMatch, BeanMapp
      * @param beanFieldMatch contains the fields belonging to the source/target field match
      * @throws BeanMappingException
      */
-    private void processField(BeanFieldMatch beanFieldMatch, BeanMapperRule rule) {
+    private void processField(BeanFieldMatch beanFieldMatch) {
         if (!beanFieldMatch.hasMatchingSource()) {
             dealWithNonMatchingNode(beanFieldMatch);
             return;
         }
         if (!isConverterFor(beanFieldMatch.getSourceClass(), beanFieldMatch.getTargetClass()) &&
-                                !beanFieldMatch.hasSimilarClasses() &&
-                                isMappableClass(beanFieldMatch.getTargetClass()) &&
+                (!beanFieldMatch.hasSimilarClasses() || (beanFieldMatch.hasSimilarClasses() && beanFieldMatch.getTargetObject() != null)) &&
+                isMappableClass(beanFieldMatch.getTargetClass()) &&
                                 beanFieldMatch.getSourceObject() != null) {
 
-            dealWithMappableNestedClass(beanFieldMatch, rule);
+            dealWithMappableNestedClass(beanFieldMatch);
             return;
         }
         if (beanFieldMatch.isMappable()) {
@@ -326,17 +324,20 @@ private void copySourceToTarget(BeanFieldMatch beanFieldMatch) {
      * If the field is a class which can itself be mapped to another class, it must be treated
      * as such. The matching process is called recursively to deal with this pair.
      * @param beanFieldMatch contains the fields belonging to the source/target field match
-     * @param rule the matching rule
      * @throws BeanMappingException
      */
-    private void dealWithMappableNestedClass(BeanFieldMatch beanFieldMatch, BeanMapperRule rule) {
+    private void dealWithMappableNestedClass(BeanFieldMatch beanFieldMatch) {
         Object encapsulatedSource = beanFieldMatch.getSourceObject();
         Object target;
         if (encapsulatedSource != null) {
             if(beanFieldMatch.getTargetObject() == null){
                 target = map(encapsulatedSource, beanFieldMatch.getTargetClass());
             }else {
-                target = map(encapsulatedSource, beanFieldMatch.getTarget(), rule);
+                if(beanFieldMatch.getBeanMatch().getMappableFields() == null) {
+                    target = map(encapsulatedSource, beanFieldMatch.getTargetObject());
+                } else {
+                    target = map(encapsulatedSource, beanFieldMatch.getTargetObject(), beanFieldMatch.getBeanMatch().getMappableFields().splitForField(beanFieldMatch.getSourceFieldName()));
+                }
             }
             beanFieldMatch.writeObject(target);
         }

src/main/java/io/beanmapper/core/BeanFieldMatch.java

@@ -74,6 +74,10 @@ public BeanCollectionInstructions getCollectionInstructions() {
                         null;
     }
 
+    public String getSourceFieldName() {
+        return sourceBeanField.getName();
+    }
+
     public BeanMatch getBeanMatch() {
         return beanMatch;
     }

src/main/java/io/beanmapper/core/BeanMatch.java

@@ -1,5 +1,7 @@
 package io.beanmapper.core;
 
+import io.beanmapper.core.rule.MappableFields;
+
 import java.util.Map;
 
 public class BeanMatch {
@@ -14,12 +16,19 @@ public class BeanMatch {
 
     private final Map<String, BeanField> aliases;
 
+    private final MappableFields mappableFields;
+
     public BeanMatch(Class<?> sourceClass, Class<?> targetClass, Map<String, BeanField> sourceNode, Map<String, BeanField> targetNode, Map<String, BeanField> aliases) {
+        this(sourceClass, targetClass, sourceNode, targetNode, aliases, null);
+    }
+
+    public BeanMatch(Class<?> sourceClass, Class<?> targetClass, Map<String, BeanField> sourceNode, Map<String, BeanField> targetNode, Map<String, BeanField> aliases, MappableFields mappableFields) {
         this.sourceClass = sourceClass;
         this.targetClass = targetClass;
         this.sourceNode = sourceNode;
         this.targetNode = targetNode;
         this.aliases = aliases;
+        this.mappableFields = mappableFields;
     }
 
     public Class<?> getSourceClass() {
@@ -41,4 +50,8 @@ public Map<String, BeanField> getTargetNode() {
     public Map<String, BeanField> getAliases() {
         return aliases;
     }
+
+    public MappableFields getMappableFields() {
+        return mappableFields;
+    }
 }

src/main/java/io/beanmapper/core/rule/BeanMapperRule.java

@@ -0,0 +1,47 @@
+/*
+ * (C) 2014 42 bv (www.42.nl). All rights reserved.
+ */
+package io.beanmapper.core.rule;
+
+import io.beanmapper.core.BeanField;
+import io.beanmapper.core.BeanMatch;
+
+import java.util.*;
+
+/**
+ * Maps each property when the source field is included.
+ *
+ * @author Jeroen van Schagen
+ * @since Nov 6, 2015
+ */
+public class MappableFields {
+
+    private final Set<String> fieldNames;
+
+    public MappableFields(Collection<String> fieldNames) {
+        this.fieldNames = new HashSet<String>(fieldNames);
+    }
+
+    public MappableFields(String... fieldNames) {
+        this(Arrays.asList(fieldNames));
+    }
+
+    public BeanMatch compressBeanMatch(BeanMatch beanMatch) {
+        Map<String, BeanField> sourceNode = new HashMap<String, BeanField>();
+        for(String includeField : fieldNames) {
+            sourceNode.put(includeField, beanMatch.getSourceNode().get(includeField));
+        }
+        return new BeanMatch(beanMatch.getSourceClass(), beanMatch.getTargetClass(), sourceNode, beanMatch.getTargetNode(), beanMatch.getAliases(), this);
+    }
+
+    public MappableFields splitForField(String fieldName) {
+        Set<String> mappableNestedFields = new HashSet<String>();
+        for(String includeField : fieldNames) {
+            String[] splitFields = includeField.split("\\.");
+            if(splitFields.length > 1 && splitFields[0].equals(fieldName)) {
+                mappableNestedFields.add(includeField.substring(splitFields[0].length()+1));
+            }
+        }
+        return new MappableFields(mappableNestedFields);
+    }
+}