limitations under the License.
==================================================================== */
-
package org.apache.poi.hssf.record;
import java.util.ArrayList;
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
}
private List<EscherRecord> escherRecords;
- private byte[] rawData;
-
+ private LazilyConcatenatedByteArray rawDataContainer = new LazilyConcatenatedByteArray();
public AbstractEscherHolderRecord()
{
escherRecords = new ArrayList<EscherRecord>();
if (! DESERIALISE )
{
- rawData = in.readRemainder();
+ rawDataContainer.concatenate(in.readRemainder());
}
else
{
}
protected void convertRawBytesToEscherRecords() {
+ byte[] rawData = getRawData();
convertToEscherRecords(0, rawData.length, rawData);
}
private void convertToEscherRecords( int offset, int size, byte[] data )
{
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());
}
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;
*/
public void join( AbstractEscherHolderRecord record )
{
- int length = this.rawData.length + record.getRawData().length;
- 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;
+ rawDataContainer.concatenate(record.getRawData());
}
public void processContinueRecord( byte[] record )
{
- int length = this.rawData.length + record.length;
- byte[] data = new byte[length];
- System.arraycopy( rawData, 0, data, 0, rawData.length );
- System.arraycopy( record, 0, data, rawData.length, record.length );
- rawData = data;
+ rawDataContainer.concatenate(record);
}
public byte[] getRawData()
{
- return rawData;
+ return rawDataContainer.toArray();
}
public void setRawData( byte[] rawData )
{
- this.rawData = rawData;
+ rawDataContainer.clear();
+ rawDataContainer.concatenate(rawData);
}
/**
*/
public void decode()
{
+ byte[] rawData = getRawData();
convertToEscherRecords(0, rawData.length, rawData );
}
}
--- /dev/null
+/* ====================================================================
+ 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);
+ }
+}
+
projects / poi.git / commitdiff