git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@941379 13f79535-47bb-0310-9956-ffa450edef68tags/REL_3_7_BETA1
@@ -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> |
@@ -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; | |||
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); | |||
} | |||
/** | |||
@@ -260,6 +256,7 @@ public abstract class AbstractEscherHolderRecord extends Record { | |||
*/ | |||
public void decode() | |||
{ | |||
byte[] rawData = getRawData(); | |||
convertToEscherRecords(0, rawData.length, rawData ); | |||
} | |||
} |
@@ -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); | |||
} | |||
} | |||