<person id="NKB" name="Nicola Ken Barozzi" email="barozzi@nicolaken.com"/>
<person id="POI-DEVELOPERS" name="Poi Developers" email="poi-dev@jakarta.apache.org"/>
</devs>
- <release version="1.5" date="Coming Soon">
+ <release version="1.6-dev" date="Unrelease">
+ <action dev="NKB" type="update">Removed runtime dependency on commonds logging.</action>
+ <action dev="POI-DEVELOPERS" type="update">Formula support</action>
+ </release>
+ <release version="1.5.1" date="16 June 2002">
+ <action dev="GJS" type="update">Removed depedency on commons logging. Now define poi.logging system property to enable logging to standard out.</action>
+ <action dev="GJS" type="fix">Fixed SST string handling so that spreadsheets with rich text or extended text will be read correctly.</action>
+ </release>
+ <release version="1.5" date="06 May 2002">
<action dev="NKB" type="update">New project build.</action>
<action dev="NKB" type="update">New project documentation system based on Cocoon.</action>
<action dev="POI-DEVELOPERS" type="update">Package rename</action>
<section title="How to use the HSSF prototype API">
<section title="Capabilities">
- <p>This release of the how-to outlines functionality for the 1.5 release.
+ <p>This release of the how-to outlines functionality for the CVS HEAD.
Those looking for information on previous releases should
look in the documentation distributed with that release.</p>
<p>
<ul>
<li>Type:
<code>java org.apache.poi.hssf.dev.HSSF ~/input.xls output.xls</code>
- <p>
+ <br/>
+ <br/>
This is the read/write/modify test. It reads in the spreadsheet, modifies a cell, and writes it back out.
Failing this test is not necessarily a bad thing. If HSSF tries to modify a non-existant sheet then this will
-most likely fail. No big deal. </p></li>
+most likely fail. No big deal. </li>
</ul>
</section>
- <section title="HSSF Logging facility">
-<p>HSSF now has a logging facility (using
- <link href="http://jakarta.apache.org/commons/logging.html">commons logging</link>)
-that will record massive amounts of debugging information. Its mostly
-useful to us hssf-developing geeks, but might be useful in tracking
-down problems.
-</p>
-<p>So Why use commons logging rather than log4j? Well the following discussion from
-the jakarta-general mailing list sums it up pretty well. (Thanks Morgan)
-</p>
-<p><em>Here's the problem, as I see it.</em>
-</p>
-<p><em>Suppose Commons component A decides to adopt Log4J, Commons component B
-decides to adopt LogKit, and Commons component C adopts JDK1.4 logging.
-They will all minimally function with the right jars in the classpath.
-However you (the end-user) are left with maintaining configuration for 3
-different logging APIs, which is tedious at best. When you take into
-account cool features like variable log levels, Log4J appenders and the
-like, you're pretty much guaranteed to swallow up useful configuration
-options because sophisticated configurations are too difficult to maintain
-over mutiple logging implementations.</em>
-</p>
-<p>
-<em>Contrarily, if all three Commons components use a logging facade, you can
-focus all your configuration efforts on one logging implementation. Sure,
-there is a trade-off; you don't have access to all the features, and the
-interface between the facade and the implementation must be maintained. But
-the benefits are not just political; they potentially make the end-users
-configuration much easier.</em>
-</p>
-<p><em>Even if all Commons components used the same logging implementation (Log4J
-for example), other projects in Jakarta-land may choose otherwise. If you
-add enough Jakarta projects to your environment, you eventually end up with
-the scenario described above. It's a worthwhile effort to attempt a logging
-solution that plays well with the Jakarta community at large. I think in
-many cases the Commons Logging component can fill that role.</em>
-</p>
-<p>
-Refer to the commons logging package level javadoc for more information concerning how to
-<link href="http://jakarta.apache.org/commons/logging/api/index.html">configure commons logging.</link>
-</p>
+ <section title="Logging facility">
+ <p>Poi can dynamically select it's logging implementation. Poi trys to
+ create a logger using the System property named "org.apache.poi.util.POILogger".
+ Out of the box this can be set to one of three values:
+ </p>
+ <ul>
+ <li>org.apache.poi.util.CommonsLogger</li>
+ <li>org.apache.poi.util.NullLogger</li>
+ <li>org.apache.poi.util.SystemOutLogger</li>
+ </ul>
+ <p>
+ If the property is not defined or points to an invalid classthen the NullLogger is used.
+ </p>
+ <p>
+ Refer to the commons logging package level javadoc for more information concerning how to
+ <link href="http://jakarta.apache.org/commons/logging/api/index.html">configure commons logging.</link>
+ </p>
</section>
- <section title="HSSF Developer's tools">
+ <section title="HSSF Developer's Tools">
<p>HSSF has a number of tools useful for developers to debug/develop
stuff using HSSF (and more generally XLS files). We've already
}
}
-class SSTRecordHeader
-{
- int numStrings;
- int numUniqueStrings;
-
- /**
- *
- */
- public SSTRecordHeader( int numStrings, int numUniqueStrings )
- {
- this.numStrings = numStrings;
- this.numUniqueStrings = numUniqueStrings;
- }
-
- /**
- * Writes out the SST record. This consists of the sid, the record size, the number of
- * strings and the number of unique strings.
- *
- * @param data The data buffer to write the header to.
- * @param bufferIndex The index into the data buffer where the header should be written.
- * @param recSize The number of records written.
- *
- * @return The bufer of bytes modified.
- */
- public int writeSSTHeader( byte[] data, int bufferIndex, int recSize )
- {
- int offset = bufferIndex;
-
- LittleEndian.putShort( data, offset, SSTRecord.sid );
- offset += LittleEndianConsts.SHORT_SIZE;
- LittleEndian.putShort( data, offset, (short) ( recSize ) );
- offset += LittleEndianConsts.SHORT_SIZE;
-// LittleEndian.putInt( data, offset, getNumStrings() );
- LittleEndian.putInt( data, offset, numStrings );
- offset += LittleEndianConsts.INT_SIZE;
-// LittleEndian.putInt( data, offset, getNumUniqueStrings() );
- LittleEndian.putInt( data, offset, numUniqueStrings );
- offset += LittleEndianConsts.INT_SIZE;
- return offset - bufferIndex;
- }
-
-}
\ No newline at end of file
--- /dev/null
+/* ====================================================================
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2002 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" and
+ * "Apache POI" must not be used to endorse or promote products
+ * derived from this software without prior written permission. For
+ * written permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * "Apache POI", nor may "Apache" appear in their name, without
+ * prior written permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+
+package org.apache.poi.hssf.record;
+
+import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.LittleEndianConsts;
+
+/**
+ * Write out an SST header record.
+ *
+ * @author Glen Stampoultzis (glens at apache.org)
+ */
+class SSTRecordHeader
+{
+ int numStrings;
+ int numUniqueStrings;
+
+ public SSTRecordHeader( int numStrings, int numUniqueStrings )
+ {
+ this.numStrings = numStrings;
+ this.numUniqueStrings = numUniqueStrings;
+ }
+
+ /**
+ * Writes out the SST record. This consists of the sid, the record size, the number of
+ * strings and the number of unique strings.
+ *
+ * @param data The data buffer to write the header to.
+ * @param bufferIndex The index into the data buffer where the header should be written.
+ * @param recSize The number of records written.
+ *
+ * @return The bufer of bytes modified.
+ */
+ public int writeSSTHeader( byte[] data, int bufferIndex, int recSize )
+ {
+ int offset = bufferIndex;
+
+ LittleEndian.putShort( data, offset, SSTRecord.sid );
+ offset += LittleEndianConsts.SHORT_SIZE;
+ LittleEndian.putShort( data, offset, (short) ( recSize ) );
+ offset += LittleEndianConsts.SHORT_SIZE;
+// LittleEndian.putInt( data, offset, getNumStrings() );
+ LittleEndian.putInt( data, offset, numStrings );
+ offset += LittleEndianConsts.INT_SIZE;
+// LittleEndian.putInt( data, offset, getNumUniqueStrings() );
+ LittleEndian.putInt( data, offset, numUniqueStrings );
+ offset += LittleEndianConsts.INT_SIZE;
+ return offset - bufferIndex;
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/* ====================================================================
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2002 The Apache Software Foundation. All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ * if any, must include the following acknowledgment:
+ * "This product includes software developed by the
+ * Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself,
+ * if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" and
+ * "Apache POI" must not be used to endorse or promote products
+ * derived from this software without prior written permission. For
+ * written permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ * "Apache POI", nor may "Apache" appear in their name, without
+ * prior written permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+
+package org.apache.poi.hssf.record;
+
+import org.apache.poi.util.LittleEndianConsts;
+
+import java.util.ArrayList;
+
+/**
+ * Used to calculate the record sizes for a particular record.
+ *
+ * @author Glen Stampoultzis (glens at apache.org)
+ */
+class SSTRecordSizeCalculator
+{
+ private SSTSerializer serializer;
+
+ private UnicodeString unistr = null;
+ private int stringReminant = 0;
+ private int unipos = 0;
+ /** Is there any more string to be written? */
+ private boolean isRemainingString = false;
+ private int totalBytesWritten = 0;
+ private boolean finished = false;
+ private boolean firstRecord = true;
+ private int totalWritten = 0;
+ private int recordSize = 0;
+ private int pos = 0;
+
+ public SSTRecordSizeCalculator(SSTSerializer serializer)
+ {
+ this.serializer = serializer;
+ }
+
+ /**
+ * Calculate the size in bytes of the SST record. This will include continue
+ * records.
+ *
+ * @return the size of the SST record.
+ */
+ public int getRecordSize()
+ {
+ initVars();
+
+ serializer.recordLengths = new ArrayList();
+ int retval = 0;
+ int totalStringSpaceRequired = serializer.calculateUnicodeSize();
+
+ if ( totalStringSpaceRequired > SSTRecord.MAX_DATA_SPACE )
+ {
+ retval = sizeOverContinuation( totalStringSpaceRequired );
+ }
+ else
+ {
+ // short data: write one simple SST record
+ retval = SSTRecord.SST_RECORD_OVERHEAD + totalStringSpaceRequired;
+ serializer.recordLengths.add( new Integer( totalStringSpaceRequired ) );
+ }
+ return retval;
+ }
+
+ private int sizeOverContinuation( int totalStringSpaceRequired )
+ {
+ int retval;
+
+ while ( !finished )
+ {
+ recordSize = 0;
+ pos = 0;
+
+ if ( firstRecord )
+ {
+ addMaxLengthRecordSize();
+ }
+ else
+ {
+
+ // writing continue record
+ pos = 0;
+ int toBeWritten = ( totalStringSpaceRequired - totalBytesWritten ) + ( isRemainingString ? 1 : 0 );
+ int size = Math.min( SSTRecord.MAX_RECORD_SIZE - SSTRecord.STD_RECORD_OVERHEAD, toBeWritten );
+
+ if ( size == toBeWritten )
+ {
+ finished = true;
+ }
+ recordSize = size + SSTRecord.STD_RECORD_OVERHEAD;
+ serializer.recordLengths.add( new Integer( size ) );
+ pos = 4;
+ }
+ if ( isRemainingString )
+ {
+ calcReminant();
+ }
+ calcRemainingStrings();
+ totalWritten += recordSize;
+ }
+ retval = totalWritten;
+
+ return retval;
+ }
+
+ private void addMaxLengthRecordSize()
+ {
+ // writing SST record
+ recordSize = SSTRecord.MAX_RECORD_SIZE;
+ pos = 12;
+ firstRecord = false;
+ serializer.recordLengths.add( new Integer( recordSize - SSTRecord.STD_RECORD_OVERHEAD ) );
+ }
+
+ private void calcRemainingStrings()
+ {
+ for ( ; unipos < serializer.strings.size(); unipos++ )
+ {
+ int available = SSTRecord.MAX_RECORD_SIZE - pos;
+ Integer intunipos = new Integer( unipos );
+
+ unistr = ( (UnicodeString) serializer.strings.get( intunipos ) );
+ if ( unistr.getRecordSize() <= available )
+ {
+ totalBytesWritten += unistr.getRecordSize();
+ pos += unistr.getRecordSize();
+ }
+ else
+ {
+ if ( available >= SSTRecord.STRING_MINIMAL_OVERHEAD )
+ {
+ int toBeWritten =
+ unistr.maxBrokenLength( available );
+
+ totalBytesWritten += toBeWritten;
+ stringReminant =
+ ( unistr.getRecordSize() - toBeWritten )
+ + LittleEndianConsts.BYTE_SIZE;
+ if ( available != toBeWritten )
+ {
+ int shortrecord = recordSize
+ - ( available - toBeWritten );
+
+ serializer.recordLengths.set(
+ serializer.recordLengths.size() - 1,
+ new Integer(
+ shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
+ recordSize = shortrecord;
+ }
+ isRemainingString = true;
+ unipos++;
+ }
+ else
+ {
+ int shortrecord = recordSize - available;
+
+ serializer.recordLengths.set( serializer.recordLengths.size() - 1,
+ new Integer( shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
+ recordSize = shortrecord;
+ }
+ break;
+ }
+ }
+ }
+
+ private void calcReminant()
+ {
+ int available = SSTRecord.MAX_RECORD_SIZE - pos;
+
+ if ( stringReminant <= available )
+ {
+
+ // write reminant
+ totalBytesWritten += stringReminant - 1;
+ pos += stringReminant;
+ isRemainingString = false;
+ }
+ else
+ {
+
+ // write as much of the remnant as possible
+ int toBeWritten = unistr.maxBrokenLength( available );
+
+ if ( available != toBeWritten )
+ {
+ int shortrecord = recordSize - ( available - toBeWritten );
+ serializer.recordLengths.set( serializer.recordLengths.size() - 1,
+ new Integer( shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
+ recordSize = shortrecord;
+ }
+ totalBytesWritten += toBeWritten - 1;
+ pos += toBeWritten;
+ stringReminant -= toBeWritten - 1;
+ isRemainingString = true;
+ }
+ }
+
+ private void initVars()
+ {
+ unistr = null;
+ stringReminant = 0;
+ unipos = 0;
+ isRemainingString = false;
+ totalBytesWritten = 0;
+ finished = false;
+ firstRecord = true;
+ totalWritten = 0;
+ }
+
+}
package org.apache.poi.hssf.record;
import org.apache.poi.util.BinaryTree;
-import org.apache.poi.util.LittleEndianConsts;
import java.util.List;
-import java.util.ArrayList;
/**
* This class handles serialization of SST records. It utilizes the record processor
class SSTSerializer
{
- private List recordLengths;
- private BinaryTree strings;
+ // todo: make private again
+ List recordLengths;
+ BinaryTree strings;
+
private int numStrings;
private int numUniqueStrings;
private SSTRecordHeader sstRecordHeader;
this.strings = strings;
this.numStrings = numStrings;
this.numUniqueStrings = numUniqueStrings;
- this.sstRecordHeader = new SSTRecordHeader(numStrings, numUniqueStrings);
+ this.sstRecordHeader = new SSTRecordHeader( numStrings, numUniqueStrings );
}
/**
return record_size;
}
- private int calculateUnicodeSize()
- {
- int retval = 0;
- for ( int k = 0; k < strings.size(); k++ )
- {
- retval += getUnicodeString(k).getRecordSize();
- }
- return retval;
- }
- // we can probably simplify this later...this calculates the size
- // w/o serializing but still is a bit slow
- public int getRecordSize()
+ // todo: make private again
+ /**
+ * Calculates the total unicode size for all the strings.
+ *
+ * @return the total size.
+ */
+ int calculateUnicodeSize()
{
- recordLengths = new ArrayList();
int retval = 0;
- int unicodesize = calculateUnicodeSize();
- if ( unicodesize > SSTRecord.MAX_DATA_SPACE )
- {
- retval = calcRecordSizesForLongStrings( unicodesize );
- }
- else
+ for ( int k = 0; k < strings.size(); k++ )
{
- // short data: write one simple SST record
- retval = SSTRecord.SST_RECORD_OVERHEAD + unicodesize;
- recordLengths.add( new Integer( unicodesize ) );
+ retval += getUnicodeString( k ).getRecordSize();
}
return retval;
}
- private int calcRecordSizesForLongStrings( int unicodesize )
- {
- int retval;
- UnicodeString unistr = null;
- int stringreminant = 0;
- int unipos = 0;
- boolean lastneedcontinue = false;
- int stringbyteswritten = 0;
- boolean finished = false;
- boolean first_record = true;
- int totalWritten = 0;
-
- while ( !finished )
- {
- int record = 0;
- int pos = 0;
-
- if ( first_record )
- {
-
- // writing SST record
- record = SSTRecord.MAX_RECORD_SIZE;
- pos = 12;
- first_record = false;
- recordLengths.add( new Integer( record - SSTRecord.STD_RECORD_OVERHEAD ) );
- }
- else
- {
-
- // writing continue record
- pos = 0;
- int to_be_written = ( unicodesize - stringbyteswritten ) + ( lastneedcontinue ? 1 : 0 );
- int size = Math.min( SSTRecord.MAX_RECORD_SIZE - SSTRecord.STD_RECORD_OVERHEAD, to_be_written );
-
- if ( size == to_be_written )
- {
- finished = true;
- }
- record = size + SSTRecord.STD_RECORD_OVERHEAD;
- recordLengths.add( new Integer( size ) );
- pos = 4;
- }
- if ( lastneedcontinue )
- {
- int available = SSTRecord.MAX_RECORD_SIZE - pos;
-
- if ( stringreminant <= available )
- {
-
- // write reminant
- stringbyteswritten += stringreminant - 1;
- pos += stringreminant;
- lastneedcontinue = false;
- }
- else
- {
-
- // write as much of the remnant as possible
- int toBeWritten = unistr.maxBrokenLength( available );
-
- if ( available != toBeWritten )
- {
- int shortrecord = record - ( available - toBeWritten );
- recordLengths.set( recordLengths.size() - 1,
- new Integer( shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
- record = shortrecord;
- }
- stringbyteswritten += toBeWritten - 1;
- pos += toBeWritten;
- stringreminant -= toBeWritten - 1;
- lastneedcontinue = true;
- }
- }
- for ( ; unipos < strings.size(); unipos++ )
- {
- int available = SSTRecord.MAX_RECORD_SIZE - pos;
- Integer intunipos = new Integer( unipos );
-
- unistr = ( (UnicodeString) strings.get( intunipos ) );
- if ( unistr.getRecordSize() <= available )
- {
- stringbyteswritten += unistr.getRecordSize();
- pos += unistr.getRecordSize();
- }
- else
- {
- if ( available >= SSTRecord.STRING_MINIMAL_OVERHEAD )
- {
- int toBeWritten =
- unistr.maxBrokenLength( available );
-
- stringbyteswritten += toBeWritten;
- stringreminant =
- ( unistr.getRecordSize() - toBeWritten )
- + LittleEndianConsts.BYTE_SIZE;
- if ( available != toBeWritten )
- {
- int shortrecord = record
- - ( available - toBeWritten );
-
- recordLengths.set(
- recordLengths.size() - 1,
- new Integer(
- shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
- record = shortrecord;
- }
- lastneedcontinue = true;
- unipos++;
- }
- else
- {
- int shortrecord = record - available;
-
- recordLengths.set( recordLengths.size() - 1,
- new Integer( shortrecord - SSTRecord.STD_RECORD_OVERHEAD ) );
- record = shortrecord;
- }
- break;
- }
- }
- totalWritten += record;
- }
- retval = totalWritten;
-
- return retval;
- }
-
-
private void serializeSingleSSTRecord( byte[] data, int offset, int record_length_index )
{
// short data: write one simple SST record
for ( int k = 0; k < strings.size(); k++ )
{
// UnicodeString unistr = ( (UnicodeString) strings.get( new Integer( k ) ) );
- System.arraycopy( getUnicodeString(k).serialize(), 0, data, pos + offset, getUnicodeString(k).getRecordSize() );
- pos += getUnicodeString(k).getRecordSize();
+ System.arraycopy( getUnicodeString( k ).serialize(), 0, data, pos + offset, getUnicodeString( k ).getRecordSize() );
+ pos += getUnicodeString( k ).getRecordSize();
}
}
return ( (UnicodeString) strings.get( intunipos ) );
}
+ public int getRecordSize()
+ {
+ return new SSTRecordSizeCalculator(this).getRecordSize();
+ }
+
}
-
/* ====================================================================
* The Apache Software License, Version 1.1
*
package org.apache.poi.util;
-import org.apache.log4j.Category;
-
-import junit.framework.*;
+import junit.framework.TestCase;
-import java.io.*;
+import java.io.IOException;
/**
* @author Marc Johnson (mjohnson at apache dot org)
*/
public class TestPOILogFactory
- extends TestCase
+ extends TestCase
{
/**
* Creates new TestPOILogFactory
* @param name
*/
- public TestPOILogFactory(String name)
+ public TestPOILogFactory( String name )
{
- super(name);
+ super( name );
}
/**
*/
public void testLog()
- throws IOException
+ throws IOException
{
//NKB Testing only that logging classes use gives no exception
// Since logging can be disabled, no checking of logging
// output is done.
-
- POILogger l1 = POILogFactory.getLogger("org.apache.poi.hssf.test");
- POILogger l2 = POILogFactory.getLogger("org.apache.poi.hdf.test");
- l1.log(POILogger.FATAL, "testing cat org.apache.poi.hssf.*:FATAL");
- l1.log(POILogger.ERROR, "testing cat org.apache.poi.hssf.*:ERROR");
- l1.log(POILogger.WARN, "testing cat org.apache.poi.hssf.*:WARN");
- l1.log(POILogger.INFO, "testing cat org.apache.poi.hssf.*:INFO");
- l1.log(POILogger.DEBUG, "testing cat org.apache.poi.hssf.*:DEBUG");
+ POILogger l1 = POILogFactory.getLogger( "org.apache.poi.hssf.test" );
+ POILogger l2 = POILogFactory.getLogger( "org.apache.poi.hdf.test" );
+
+ l1.log( POILogger.FATAL, "testing cat org.apache.poi.hssf.*:FATAL" );
+ l1.log( POILogger.ERROR, "testing cat org.apache.poi.hssf.*:ERROR" );
+ l1.log( POILogger.WARN, "testing cat org.apache.poi.hssf.*:WARN" );
+ l1.log( POILogger.INFO, "testing cat org.apache.poi.hssf.*:INFO" );
+ l1.log( POILogger.DEBUG, "testing cat org.apache.poi.hssf.*:DEBUG" );
- l2.log(POILogger.FATAL, "testing cat org.apache.poi.hdf.*:FATAL");
- l2.log(POILogger.ERROR, "testing cat org.apache.poi.hdf.*:ERROR");
- l2.log(POILogger.WARN, "testing cat org.apache.poi.hdf.*:WARN");
- l2.log(POILogger.INFO, "testing cat org.apache.poi.hdf.*:INFO");
- l2.log(POILogger.DEBUG, "testing cat org.apache.poi.hdf.*:DEBUG");
+ l2.log( POILogger.FATAL, "testing cat org.apache.poi.hdf.*:FATAL" );
+ l2.log( POILogger.ERROR, "testing cat org.apache.poi.hdf.*:ERROR" );
+ l2.log( POILogger.WARN, "testing cat org.apache.poi.hdf.*:WARN" );
+ l2.log( POILogger.INFO, "testing cat org.apache.poi.hdf.*:INFO" );
+ l2.log( POILogger.DEBUG, "testing cat org.apache.poi.hdf.*:DEBUG" );
}
* @param ignored_args
*/
- public static void main(String [] ignored_args)
+ public static void main( String[] ignored_args )
{
- System.out.println("Testing basic util.POILogFactory functionality");
- junit.textui.TestRunner.run(TestPOILogFactory.class);
+ System.out.println( "Testing basic util.POILogFactory functionality" );
+ junit.textui.TestRunner.run( TestPOILogFactory.class );
}
}
-
/* ====================================================================
* The Apache Software License, Version 1.1
*
import junit.framework.TestCase;
-import java.io.File;
-import java.io.FileInputStream;
-
/**
* Tests the log class.
*
* @author Glen Stampoultzis (glens at apache.org)
* @author Marc Johnson (mjohnson at apache dot org)
- * @author Nicola Ken Barozzi (nicolaken at apache.org)
+ * @author Nicola Ken Barozzi (nicolaken at apache.org)
*/
public class TestPOILogger
- extends TestCase
+ extends TestCase
{
/**
* Constructor TestPOILogger
*
*/
- public TestPOILogger(String s)
- {
- super(s);
- }
-
- /**
- * Method setUp
- *
- *
- * @exception Exception
- *
- */
-
- protected void setUp()
- throws Exception
+ public TestPOILogger( String s )
{
- super.setUp();
+ super( s );
}
/**
*
* @exception Exception
*/
-
public void testVariousLogTypes()
- throws Exception
+ throws Exception
{
//NKB Testing only that logging classes use gives no exception
// Since logging can be disabled, no checking of logging
// output is done.
-
- POILogger log = POILogFactory.getLogger("foo");
- log.log(POILogger.WARN, "Test = ", new Integer(1));
- log.logFormatted(POILogger.ERROR, "Test param 1 = %, param 2 = %",
- "2", new Integer(3));
- log.logFormatted(POILogger.ERROR, "Test param 1 = %, param 2 = %",
- new int[]
- {
- 4, 5
- });
- log.logFormatted(POILogger.ERROR,
- "Test param 1 = %1.1, param 2 = %0.1", new double[]
- {
- 4, 5.23
- });
+ POILogger log = POILogFactory.getLogger( "foo" );
+
+ log.log( POILogger.WARN, "Test = ", new Integer( 1 ) );
+ log.logFormatted( POILogger.ERROR, "Test param 1 = %, param 2 = %", "2", new Integer( 3 ) );
+ log.logFormatted( POILogger.ERROR, "Test param 1 = %, param 2 = %", new int[]{4, 5} );
+ log.logFormatted( POILogger.ERROR,
+ "Test param 1 = %1.1, param 2 = %0.1", new double[]{4, 5.23} );
}
}
projects / poi.git / commitdiff