Merge branch 'master' into sebastiencaille-master

Author: buzdin

core/src/main/java/org/dozer/MappingProcessor.java

@@ -39,6 +39,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.lang.reflect.Array;
+import java.lang.reflect.Modifier;
 import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 import java.util.Map.Entry;
@@ -613,8 +614,18 @@ private Object mapMap(Object srcObj, Map srcMapValue, FieldMap fieldMap, Object
 
   private Object mapArrayToArray(Object srcObj, Object srcCollectionValue, FieldMap fieldMap, Object destObj) {
     Class destEntryType = fieldMap.getDestFieldType(destObj.getClass()).getComponentType();
+    Class srcEntryType = srcCollectionValue.getClass().getComponentType();
     int size = Array.getLength(srcCollectionValue);
-    if (CollectionUtils.isPrimitiveArray(srcCollectionValue.getClass())) {
+    
+    CopyByReferenceContainer copyByReferences = globalConfiguration.getCopyByReferences();
+    boolean isPrimitiveArray = CollectionUtils.isPrimitiveArray(srcCollectionValue.getClass());
+    boolean isFinal = Modifier.isFinal(srcEntryType.getModifiers());
+    boolean isCopyByReference = copyByReferences.contains(srcEntryType);
+    
+    // TODO: what about custom converters?
+    if (destEntryType.isAssignableFrom(srcEntryType) && isFinal && (isPrimitiveArray || isCopyByReference)) {
+      return addArrayContentCopy(fieldMap, size, srcCollectionValue, destObj, destEntryType);
+    } else if (isPrimitiveArray) {
       return addToPrimitiveArray(srcObj, fieldMap, size, srcCollectionValue, destObj, destEntryType);
     } else {
       List<?> list = Arrays.asList((Object[]) srcCollectionValue);
@@ -659,6 +670,22 @@ private void mapFromIterateMethodFieldMap(Object srcObj, Object destObj, Object
           fieldMapping.getDestFieldName(), srcFieldValue, null, fieldMapping.getClassMap().getMapId()));
     }
   }
+  
+  private Object addArrayContentCopy(FieldMap fieldMap, int size, Object srcCollectionValue, Object destObj,
+          Class destEntryType) {
+      Object result;
+      Object field = fieldMap.getDestValue(destObj);
+      int arraySize = 0;
+      if (field == null) {
+          result = Array.newInstance(destEntryType, size);
+      } else {
+          result = Array.newInstance(destEntryType, size + Array.getLength(field));
+          arraySize = Array.getLength(field);
+          System.arraycopy(field, 0, result, 0, arraySize);
+      }
+      System.arraycopy(srcCollectionValue, 0, result, arraySize, size);
+      return result;
+  }
 
   private Object addToPrimitiveArray(Object srcObj, FieldMap fieldMap, int size, Object srcCollectionValue, Object destObj,
                                      Class<?> destEntryType) {

core/src/test/java/org/dozer/MappingProcessorArrayTest.java

@@ -0,0 +1,88 @@
+package org.dozer;
+
+import java.util.Arrays;
+import java.util.Date;
+
+public class MappingProcessorArrayTest extends AbstractDozerTest {
+
+  public static class PrimitiveArray {
+    private int[] data;
+
+    public int[] getData() {
+      return data;
+    }
+
+    public void setData(int[] data) {
+      this.data = data;
+    }
+  }
+
+  public static final class MyDate extends Date {
+    public MyDate(long ms) {
+      super(ms);
+    }
+  }
+  
+  public static class FinalCopyByReferenceArray {
+    private MyDate[] data;
+
+    public MyDate[] getData() {
+      return data;
+    }
+
+    public void setData(MyDate[] data) {
+      this.data = data;
+    }
+  }
+  
+  public static class FinalCopyByReferenceDest {
+    private Date[] data;
+
+    public Date[] getData() {
+      return data;
+    }
+
+    public void setData(Date[] data) {
+      this.data = data;
+    }
+  }
+
+  public void testPrimitiveArrayCopy() {
+
+    PrimitiveArray test = new PrimitiveArray();
+    int[] data = new int[1024 * 1024];
+    for (int i = 0; i < data.length; i++) {
+      data[i] = i;
+    }
+    test.setData(data);
+    DozerBeanMapper dozer = new DozerBeanMapper();
+    PrimitiveArray result = dozer.map(test, PrimitiveArray.class);
+
+    // long start = System.currentTimeMillis();
+    //   result = dozer.map(test, PrimitiveArray.class);
+    //  System.out.println(System.currentTimeMillis() - start);
+
+    assertNotSame(test.getData(), result.getData());
+    assertTrue(Arrays.equals(test.getData(), result.getData()));
+  }
+
+  public void testReferenceCopy() {
+
+    FinalCopyByReferenceArray test = new FinalCopyByReferenceArray();
+    MyDate[] data = new MyDate[1024 * 1024];
+    for (int i = 0; i < data.length; i++) {
+      data[i] = new MyDate(i);
+    }
+    test.setData(data);
+    DozerBeanMapper dozer = new DozerBeanMapper(Arrays.asList("mappingProcessorArrayTest.xml"));
+    FinalCopyByReferenceDest result = dozer.map(test, FinalCopyByReferenceDest.class);
+
+    // long start = System.currentTimeMillis();
+    // result = dozer.map(test, FinalCopyByReferenceDest.class);
+    // System.out.println(System.currentTimeMillis() - start);
+
+    assertNotSame(test.getData(), result.getData());
+    assertTrue(Arrays.equals(test.getData(), result.getData()));
+  }
+
+}

core/src/test/java/org/dozer/MappingProcessorTest.java

@@ -23,6 +23,11 @@
 import java.util.ArrayList;
 import java.util.List;
 
+
+import org.dozer.MappingProcessor;
+import org.junit.Before;
+import org.junit.Test;
+
 /**
  * @author Dmitry Spikhalskiy
  * @since 03.01.13
@@ -150,4 +155,5 @@ public int hashCode() {
       return id;
     }
   }
+
 }

core/src/test/resources/mappingProcessorArrayTest.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mappings xmlns="http://dozer.sourceforge.net"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://dozer.sourceforge.net
+          http://dozer.sourceforge.net/schema/beanmapping.xsd">
+
+  <configuration>
+        <copy-by-references>
+            <copy-by-reference>*MyDate</copy-by-reference>
+        </copy-by-references>
+  </configuration>
+
+</mappings>