Apply patch from Trejkaz from bug #49050 - Improve performance of AbstractEscherHolderRecord when there are lots of Continue Records

git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@941379 13f79535-47bb-0310-9956-ffa450edef68

src/documentation/content/xdocs/status.xml

@@ -34,6 +34,7 @@
 
     <changes>
         <release version="3.7-SNAPSHOT" date="2010-??-??">
+           <action dev="POI-DEVELOPERS" type="fix">49050 - Improve performance of AbstractEscherHolderRecord when there are lots of Continue Records</action>
            <action dev="POI-DEVELOPERS" type="fix">49194 - Correct text size limit for OOXML .xlsx files</action>
            <action dev="POI-DEVELOPERS" type="fix">49254 - Fix CellUtils.setFont to use the correct type internally</action>
            <action dev="POI-DEVELOPERS" type="fix">49139 - Properly support 4k big block size in POIFS</action>

src/java/org/apache/poi/hssf/record/AbstractEscherHolderRecord.java

@@ -15,7 +15,6 @@
    limitations under the License.
 ==================================================================== */
 
-
 package org.apache.poi.hssf.record;
 
 import java.util.ArrayList;
@@ -28,6 +27,7 @@ import org.apache.poi.ddf.EscherRecord;
 import org.apache.poi.ddf.EscherRecordFactory;
 import org.apache.poi.ddf.NullEscherSerializationListener;
 import org.apache.poi.util.LittleEndian;
+import org.apache.poi.hssf.util.LazilyConcatenatedByteArray;
 
 /**
  * The escher container record is used to hold escher records.  It is abstract and
@@ -47,8 +47,7 @@ public abstract class AbstractEscherHolderRecord extends Record {
     }
 
     private List<EscherRecord> escherRecords;
-    private byte[] rawData;
+    private LazilyConcatenatedByteArray rawDataContainer = new LazilyConcatenatedByteArray();
-
 
     public AbstractEscherHolderRecord()
     {
@@ -60,7 +59,7 @@ public abstract class AbstractEscherHolderRecord extends Record {
         escherRecords = new ArrayList<EscherRecord>();
         if (! DESERIALISE )
         {
-            rawData = in.readRemainder();
+            rawDataContainer.concatenate(in.readRemainder());
         }
         else
         {
@@ -70,6 +69,7 @@ public abstract class AbstractEscherHolderRecord extends Record {
     }
 
     protected void convertRawBytesToEscherRecords() {
+        byte[] rawData = getRawData();
     	convertToEscherRecords(0, rawData.length, rawData);
     }
     private void convertToEscherRecords( int offset, int size, byte[] data )
@@ -109,6 +109,7 @@ public abstract class AbstractEscherHolderRecord extends Record {
     {
         LittleEndian.putShort( data, 0 + offset, getSid() );
         LittleEndian.putShort( data, 2 + offset, (short) ( getRecordSize() - 4 ) );
+        byte[] rawData = getRawData();
         if ( escherRecords.size() == 0 && rawData != null )
         {
             LittleEndian.putShort(data, 0 + offset, getSid());
@@ -129,7 +130,9 @@ public abstract class AbstractEscherHolderRecord extends Record {
     }
 
     public int getRecordSize() {
+        byte[] rawData = getRawData();
         if (escherRecords.size() == 0 && rawData != null) {
+            // XXX: It should be possible to derive this without concatenating the array, too.
             return rawData.length;
         }
         int size = 0;
@@ -229,30 +232,23 @@ public abstract class AbstractEscherHolderRecord extends Record {
      */
     public void join( AbstractEscherHolderRecord record )
     {
-        int length = this.rawData.length + record.getRawData().length;
+        rawDataContainer.concatenate(record.getRawData());
-        byte[] data = new byte[length];
-        System.arraycopy( rawData, 0, data, 0, rawData.length );
-        System.arraycopy( record.getRawData(), 0, data, rawData.length, record.getRawData().length );
-        rawData = data;
     }
 
     public void processContinueRecord( byte[] record )
     {
-        int length = this.rawData.length + record.length;
+        rawDataContainer.concatenate(record);
-        byte[] data = new byte[length];
-        System.arraycopy( rawData, 0, data, 0, rawData.length );
-        System.arraycopy( record, 0, data, rawData.length, record.length );
-        rawData = data;
     }
 
     public byte[] getRawData()
     {
-        return rawData;
+        return rawDataContainer.toArray();
     }
 
     public void setRawData( byte[] rawData )
     {
-        this.rawData = rawData;
+        rawDataContainer.clear();
+        rawDataContainer.concatenate(rawData);
     }
 
     /**
@@ -260,6 +256,7 @@ public abstract class AbstractEscherHolderRecord extends Record {
      */
     public void decode()
     {
+        byte[] rawData = getRawData();
         convertToEscherRecords(0, rawData.length, rawData );
     }
 }

src/java/org/apache/poi/hssf/util/LazilyConcatenatedByteArray.java

@@ -0,0 +1,83 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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.apache.poi.hssf.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility for delaying the concatenation of multiple byte arrays.  Doing this up-front
+ * causes significantly more copying, which for a large number of byte arrays can cost
+ * a large amount of time.
+ */
+public class LazilyConcatenatedByteArray {
+    private final List<byte[]> arrays = new ArrayList<byte[]>(1);
+
+    /**
+     * Clears the array (sets the concatenated length back to zero.
+     */
+    public void clear() {
+        arrays.clear();
+    }
+
+    /**
+     * Concatenates an array onto the end of our array.
+     * This is a relatively fast operation.
+     *
+     * @param array the array to concatenate.
+     * @throws IllegalArgumentException if {@code array} is {@code null}.
+     */
+    public void concatenate(byte[] array) {
+        if (array == null) {
+            throw new IllegalArgumentException("array cannot be null");
+        }
+        arrays.add(array);
+    }
+
+    /**
+     * Gets the concatenated contents as a single byte array.
+     *
+     * This is a slower operation, but the concatenated array is stored off as a single
+     * array again so that subsequent calls will not perform additional copying.
+     *
+     * @return the byte array.  Returns {@code null} if no data has been placed into it.
+     */
+    public byte[] toArray() {
+        if (arrays.isEmpty()) {
+            return null;
+        } else if (arrays.size() > 1) {
+            int totalLength = 0;
+            for (byte[] array : arrays) {
+                totalLength += array.length;
+            }
+
+            byte[] concatenated = new byte[totalLength];
+            int destPos = 0;
+            for (byte[] array : arrays) {
+                System.arraycopy(array, 0, concatenated, destPos, array.length);
+                destPos += array.length;
+            }
+
+            arrays.clear();
+            arrays.add(concatenated);
+        }
+
+        return arrays.get(0);
+    }
+}
+