Attachment #23909 for bug #47448

View | Details | Raw Unified | Return to bug 47448
Collapse All | Expand All

Lines 134-140 Link Here

(-)src/java/org/apache/poi/hssf/eventusermodel/HSSFEventFactory.java (-1 / +1 lines)
134	Record r = null;	134	Record r = null;
135		135
136	// Create a new RecordStream and use that	136	// Create a new RecordStream and use that
137	HSSFRecordStream recordStream = new HSSFRecordStream(in);	137	RecordFactoryInputStream recordStream = new RecordFactoryInputStream(in);
138		138
139	// Process each record as they come in	139	// Process each record as they come in
140	while(going) {	140	while(going) {




/* ====================================================================
   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.eventusermodel;

import java.util.Vector;

import org.apache.poi.hssf.record.ContinueRecord;
import org.apache.poi.hssf.record.DrawingGroupRecord;
import org.apache.poi.hssf.record.DrawingRecord;
import org.apache.poi.hssf.record.ObjRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.record.RecordFactory;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.record.TextObjectRecord;
import org.apache.poi.hssf.record.UnknownRecord;

/**
 * A stream based way to get at complete records, with
 *  as low a memory footprint as possible.
 * This handles reading from a RecordInputStream, turning
 *  the data into full records, processing continue records
 *  etc.
 * Most users should use {@link HSSFEventFactory} /
 *  {@link HSSFListener} and have new records pushed to
 *  them, but this does allow for a "pull" style of coding.  
 */
public class HSSFRecordStream {
	private RecordInputStream in;

	/** Have we run out of records on the stream? */
	private boolean hitEOS = false;
	/** Have we returned all the records there are? */
	private boolean complete = false;
	
	/**
	 * Sometimes we end up with a bunch of
	 *  records. When we do, these should
	 *  be returned before the next normal
	 *  record processing occurs (i.e. before
	 *  we check for continue records and
	 *  return rec)
	 */
	private Vector bonusRecords = null;
	
	/** 
	 * The next record to return, which may need to have its
	 *  continue records passed to it before we do
	 */
	private Record rec = null;
	/**
	 * The most recent record that we gave to the user
	 */
	private Record lastRec = null;
	/**
	 * The most recent DrawingRecord seen
	 */
	private DrawingRecord lastDrawingRecord = new DrawingRecord();
	
	public HSSFRecordStream(RecordInputStream inp) {
		this.in = inp;
	}

	/**
	 * Returns the next (complete) record from the 
	 *  stream, or null if there are no more.
	 */
	public Record nextRecord() {
		Record r = null;
		
		// Loop until we get something
		while(r == null && !complete) {
			// Are there any bonus records that we need to
			//  return?
			r = getBonusRecord();
			
			// If not, ask for the next real record
			if(r == null) {
				r = getNextRecord();
			}
		}
		
		// All done
		return r;
	}
	
	/**
	 * If there are any "bonus" records, that should
	 *  be returned before processing new ones, 
	 *  grabs the next and returns it.
	 * If not, returns null;
	 */
	private Record getBonusRecord() {
		if(bonusRecords != null) {
			Record r = (Record)bonusRecords.remove(0);
			if(bonusRecords.size() == 0) {
				bonusRecords = null;
			}
			return r;
		}
		return null;
	}
	
	/**
	 * Returns the next available record, or null if
	 *  this pass didn't return a record that's
	 *  suitable for returning (eg was a continue record).
	 */
	private Record getNextRecord() {
		Record toReturn = null;
		
		if(in.hasNextRecord()) {
			// Grab our next record
			in.nextRecord();
			short sid = in.getSid();
			
            //
            // for some reasons we have to make the workbook to be at least 4096 bytes
            // but if we have such workbook we fill the end of it with zeros (many zeros)
            //
            // it is not good:
            // if the length( all zero records ) % 4 = 1
            // e.g.: any zero record would be readed as  4 bytes at once ( 2 - id and 2 - size ).
            // And the last 1 byte will be readed WRONG ( the id must be 2 bytes )
            //
            // So we should better to check if the sid is zero and not to read more data
            // The zero sid shows us that rest of the stream data is a fake to make workbook 
            // certain size
            //
            if ( sid == 0 )
                return null;


            // If we had a last record, and this one
            //  isn't a continue record, then pass
            //  it on to the listener
			if ((rec != null) && (sid != ContinueRecord.sid))
			{
				// This last record ought to be returned
				toReturn = rec;
			}
			
			// If this record isn't a continue record,
			//  then build it up
			if (sid != ContinueRecord.sid)
			{
				//System.out.println("creating "+sid);
				Record[] recs = RecordFactory.createRecord(in);

				// We know that the multiple record situations
				//  don't contain continue records, so just
				//  pass those on to the listener now
				if (recs.length > 1) {
					bonusRecords = new Vector(recs.length-1);
					for (int k = 0; k < (recs.length - 1); k++)	{
						bonusRecords.add(recs[k]);
					}
				}
				
				// Regardless of the number we created, always hold
				//  onto the last record to be processed on the next
				//  loop, in case it has any continue records
				rec = recs[ recs.length - 1 ];
				// Don't return it just yet though, as we probably have
				//  a record from the last round to return
			}
			else {
				// Normally, ContinueRecords are handled internally
				// However, in a few cases, there is a gap between a record at
				//  its Continue, so we have to handle them specially
				// This logic is much like in RecordFactory.createRecords()
				Record[] recs = RecordFactory.createRecord(in);
				ContinueRecord crec = (ContinueRecord)recs[0];
				if((lastRec instanceof ObjRecord) || (lastRec instanceof TextObjectRecord)) {
					// You can have Obj records between a DrawingRecord
					//  and its continue!
					lastDrawingRecord.processContinueRecord( crec.getData() );
					// Trigger them on the drawing record, now it's complete
					rec = lastDrawingRecord;
				}
				else if((lastRec instanceof DrawingGroupRecord)) {
					((DrawingGroupRecord)lastRec).processContinueRecord(crec.getData());
					// Trigger them on the drawing record, now it's complete
					rec = lastRec;
				}
				else {
                    if (rec instanceof UnknownRecord) {
                        ;//silently skip records we don't know about
                    } else {
					    throw new RecordFormatException("Records should handle ContinueRecord internally. Should not see this exception");
                    }
				}
			}

			// Update our tracking of the last record
			lastRec = rec;
			if(rec instanceof DrawingRecord) {
				lastDrawingRecord = (DrawingRecord)rec;
			}
		} else {
			// No more records
			hitEOS = true;
		}
		
		// If we've hit the end-of-stream, then
		//  finish off the last record and be done
		if(hitEOS) {
			complete = true;
			
			// Return the last record if there was
			//  one, otherwise null
			if(rec != null) {
				toReturn = rec;
				rec = null;
			}
		}
			
		return toReturn;
	}
}




   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record;

import org.apache.poi.hssf.eventusermodel.HSSFEventFactory;
import org.apache.poi.hssf.eventusermodel.HSSFListener;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import org.apache.poi.hssf.record.ObjRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.record.RecordFactory;
import org.apache.poi.hssf.record.RecordFormatException;
import org.apache.poi.hssf.record.RecordInputStream;
import org.apache.poi.hssf.record.TextObjectRecord;
import org.apache.poi.hssf.record.UnknownRecord;

/**
 * A stream based way to get at complete records, with

 *  {@link HSSFListener} and have new records pushed to
 *  them, but this does allow for a "pull" style of coding.  
 */
public class RecordFactoryInputStream {
	private final RecordInputStream recStream;

	/** Have we run out of records on the stream? */
	private boolean hitEOS = false;
	/** Have we returned all the records there are? */
	private boolean complete = false;
	

	 *  we check for continue records and
	 *  return rec)
	 */
	private final LinkedList bonusRecords = new LinkedList();

        /**
	 * The next record to return, which may need to have its
	 *  continue records passed to it before we do
	 */
	private Record rec = null;
	/**
	 * The most recent record that we gave to the user
	 */
	private Record lastRecord = null;
	/**
	 * The most recent DrawingRecord seen
	 */
	private DrawingRecord lastDrawingRecord = new DrawingRecord();

        private int bofDepth=0;

        private boolean lastRecordWasEOFLevelZero = false;

        private boolean includeContinueRecords = false;

        public RecordFactoryInputStream(RecordInputStream inp) {
                recStream = inp;
	}

        /**
	 * Returns the next (complete) record from the 
	 *  stream, or null if there are no more.
	 */

	 * If not, returns null;
	 */
	private Record getBonusRecord() {
		if(!bonusRecords.isEmpty()) {
                        return (Record) bonusRecords.removeFirst();
			if(bonusRecords.size() == 0) {
				bonusRecords = null;
			}
			return r;
		}
		return null;
	}

	 *  this pass didn't return a record that's
	 *  suitable for returning (eg was a continue record).
	 */
        private Record getNextRecord() {
                /*
                 * How to recognise end of stream?
                 * In the best case, the underlying input stream (in) ends just after the last EOF record
                 * Usually however, the stream is padded with an arbitrary byte count.  Excel and most apps
                 * reliably use zeros for padding and if this were always the case, this code could just
                 * skip all the (zero sized) records with sid==0.  However, bug 46987 shows a file with
                 * non-zero padding that is read OK by Excel (Excel also fixes the padding).
                 *
                 * So to properly detect the workbook end of stream, this code has to identify the last
                 * EOF record.  This is not so easy because the worbook bof+eof pair do not bracket the
                 * whole stream.  The worksheets follow the workbook, but it is not easy to tell how many
                 * sheet sub-streams should be present.  Hence we are looking for an EOF record that is not
                 * immediately followed by a BOF record.  One extra complication is that bof+eof sub-
                 * streams can be nested within worksheet streams and it's not clear in these cases what
                 * record might follow any EOF record.  So we also need to keep track of the bof/eof
                 * nesting level.
                 */
                
                if (recStream.hasNextRecord()) {
                        // Grab our next record
                        recStream.nextRecord();
                return null;

                        if (lastRecordWasEOFLevelZero && recStream.getSid() != BOFRecord.sid) {
                                // Normally InputStream (in) contains only zero padding after this point
                                complete = true;
                                return null;
                        }

                        Record record = RecordFactory.createSingleRecord(recStream);
                        lastRecordWasEOFLevelZero = false;
            //  it on to the listener
			if ((rec != null) && (sid != ContinueRecord.sid))
			{
				// This last record ought to be returned
				toReturn = rec;
			}
			
			// If this record isn't a continue record,
			//  then build it up
			if (sid != ContinueRecord.sid)
			{
				//System.out.println("creating "+sid);
				Record[] recs = RecordFactory.createRecord(in);

                        if (record instanceof BOFRecord) {
                                bofDepth++;
                                return record;
                        }
					bonusRecords = new Vector(recs.length-1);
					for (int k = 0; k < (recs.length - 1); k++)	{
						bonusRecords.add(recs[k]);
					}
				}
				
				// Regardless of the number we created, always hold
				//  onto the last record to be processed on the next
				//  loop, in case it has any continue records
				rec = recs[ recs.length - 1 ];
				// Don't return it just yet though, as we probably have
				//  a record from the last round to return
			}
			else {
				// Normally, ContinueRecords are handled internally
				// However, in a few cases, there is a gap between a record at
				//  its Continue, so we have to handle them specially
				// This logic is much like in RecordFactory.createRecords()
				Record[] recs = RecordFactory.createRecord(in);
				ContinueRecord crec = (ContinueRecord)recs[0];
				if((lastRec instanceof ObjRecord) || (lastRec instanceof TextObjectRecord)) {
					// You can have Obj records between a DrawingRecord
					//  and its continue!
					lastDrawingRecord.processContinueRecord( crec.getData() );
					// Trigger them on the drawing record, now it's complete
					rec = lastDrawingRecord;
				}
				else if((lastRec instanceof DrawingGroupRecord)) {
					((DrawingGroupRecord)lastRec).processContinueRecord(crec.getData());
					// Trigger them on the drawing record, now it's complete
					rec = lastRec;
				}
				else {
                    if (rec instanceof UnknownRecord) {
                        ;//silently skip records we don't know about
                    } else {
					    throw new RecordFormatException("Records should handle ContinueRecord internally. Should not see this exception");
                    }
				}
			}

                        if (record instanceof EOFRecord) {
                                bofDepth--;
                                if (bofDepth<1) {
                                        lastRecordWasEOFLevelZero = true;
                                }

                                return record;
                        }

                        if (record instanceof DBCellRecord) {
                                // Not needed by POI.  Regenerated from scratch by POI when spreadsheet is written
                                return null;
                        }

                        if (record instanceof RKRecord) {
                                return RecordFactory.convertToNumberRecord((RKRecord) record);
                        }

                        if (record instanceof MulRKRecord) {
                                NumberRecord[] records = RecordFactory.convertRKRecords((MulRKRecord) record);

                                List<NumberRecord> list = Arrays.asList(records);
                                bonusRecords.addAll(list.subList(1, list.size()));

                                return records[0];
                        }

                        if (record.getSid() == DrawingGroupRecord.sid
                                   && lastRecord instanceof DrawingGroupRecord) {
                                DrawingGroupRecord lastDGRecord = (DrawingGroupRecord) lastRecord;
                                lastDGRecord.join((AbstractEscherHolderRecord) record);
                                return null;
                        } else if (record.getSid() == ContinueRecord.sid) {
                                ContinueRecord contRec = (ContinueRecord) record;

                                if (lastRecord instanceof ObjRecord || lastRecord instanceof TextObjectRecord) {
                                        // Drawing records have a very strange continue behaviour.
                                        //There can actually be OBJ records mixed between the continues.
                                        lastDrawingRecord.processContinueRecord(contRec.getData() );
                                        //we must remember the position of the continue record.
                                        //in the serialization procedure the original structure of records must be preserved
                                        if (includeContinueRecords) {
                                                return record;
                                        } else {
                                                return null;
                                        }
                                } else if (lastRecord instanceof DrawingGroupRecord) {
                                        ((DrawingGroupRecord)lastRecord).processContinueRecord(contRec.getData());
                                        return null;
                                } else if (lastRecord instanceof UnknownRecord) {
                                        //Gracefully handle records that we don't know about,
                                        //that happen to be continued
                                        return record;
                                } else if (lastRecord instanceof EOFRecord) {
                                        // This is really odd, but excel still sometimes
                                        //  outputs a file like this all the same
                                        return record;
                                } else {
                                        throw new RecordFormatException("Unhandled Continue Record");
                                }
                        } else {
                                lastRecord = record;
                                if (record instanceof DrawingRecord) {
                                        lastDrawingRecord = (DrawingRecord) record;
                                }

                                return record;
                        }

                } else {
                        // No more records
                        complete = true;
                        return null;
                }
        }

        /**
         *  Return or not ContinueRecord in nextRecord
         */
        public void setIncludeContinueRecords(boolean includeContinueRecords) {
                this.includeContinueRecords = includeContinueRecords;
        }
}
  + native





package org.apache.poi.hssf.record;

import org.apache.poi.hssf.record.chart.*;
import org.apache.poi.hssf.record.pivottable.*;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.poi.hssf.record.chart.*;
import org.apache.poi.hssf.record.pivottable.*;

/**
 * Title:  Record Factory<P>
 * Description:  Takes a stream and outputs an array of Record objects.<P>

		return new Record[] { record, };
	}

	public static Record createSingleRecord(RecordInputStream in) {
		I_RecordCreator constructor = _recordCreatorsById.get(new Integer(in.getSid()));

		if (constructor == null) {

	 * RK record is a slightly smaller alternative to NumberRecord
	 * POI likes NumberRecord better
	 */
	public static NumberRecord convertToNumberRecord(RKRecord rk) {
		NumberRecord num = new NumberRecord();

		num.setColumn(rk.getColumn());

	/**
	 * Converts a {@link MulRKRecord} into an equivalent array of {@link NumberRecord}s
	 */
	public static NumberRecord[] convertRKRecords(MulRKRecord mrk) {

		NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];
		for (int k = 0; k < mrk.getNumColumns(); k++) {

	 * @exception RecordFormatException on error processing the InputStream
	 */
	public static List<Record> createRecords(InputStream in) throws RecordFormatException {

		List<Record> records = new ArrayList<Record>(NUM_RECORDS);

		RecordFactoryInputStream recStream = new RecordFactoryInputStream(new RecordInputStream(in));
                recStream.setIncludeContinueRecords(true);
		Record lastRecord = null;
		/*
		 * How to recognise end of stream?
		 * In the best case, the underlying input stream (in) ends just after the last EOF record
		 * Usually however, the stream is padded with an arbitrary byte count.  Excel and most apps
		 * reliably use zeros for padding and if this were always the case, this code could just
		 * skip all the (zero sized) records with sid==0.  However, bug 46987 shows a file with
		 * non-zero padding that is read OK by Excel (Excel also fixes the padding).
		 *
		 * So to properly detect the workbook end of stream, this code has to identify the last
		 * EOF record.  This is not so easy because the worbook bof+eof pair do not bracket the
		 * whole stream.  The worksheets follow the workbook, but it is not easy to tell how many
		 * sheet sub-streams should be present.  Hence we are looking for an EOF record that is not
		 * immediately followed by a BOF record.  One extra complication is that bof+eof sub-
		 * streams can be nested within worksheet streams and it's not clear in these cases what
		 * record might follow any EOF record.  So we also need to keep track of the bof/eof
		 * nesting level.
		 */

                Record record;
		boolean lastRecordWasEOFLevelZero = false;
		while (recStream.hasNextRecord()) {
			recStream.nextRecord();
			if (lastRecordWasEOFLevelZero && recStream.getSid() != BOFRecord.sid) {
				// Normally InputStream (in) contains only zero padding after this point
				break;
			}
			Record record = createSingleRecord(recStream);
			lastRecordWasEOFLevelZero = false;
			if (record instanceof BOFRecord) {
				bofDepth++;
				records.add(record);
				continue;
			}
			if (record instanceof EOFRecord) {
				bofDepth--;
				records.add(record);
				if (bofDepth<1) {
					lastRecordWasEOFLevelZero = true;
				}
				continue;
			}

		while ((record = recStream.nextRecord())!=null) {
                        records.add(record);
				continue;
			}

			if (record instanceof RKRecord) {
				records.add(convertToNumberRecord((RKRecord) record));
				continue;
			}
			if (record instanceof MulRKRecord) {
				addAll(records, convertRKRecords((MulRKRecord)record));
				continue;
			}

			if (record.getSid() == DrawingGroupRecord.sid
				   && lastRecord instanceof DrawingGroupRecord) {
				DrawingGroupRecord lastDGRecord = (DrawingGroupRecord) lastRecord;
				lastDGRecord.join((AbstractEscherHolderRecord) record);
			} else if (record.getSid() == ContinueRecord.sid) {
				ContinueRecord contRec = (ContinueRecord)record;

				if (lastRecord instanceof ObjRecord || lastRecord instanceof TextObjectRecord) {
					// Drawing records have a very strange continue behaviour.
					//There can actually be OBJ records mixed between the continues.
					lastDrawingRecord.processContinueRecord(contRec.getData() );
					//we must remember the position of the continue record.
					//in the serialization procedure the original structure of records must be preserved
					records.add(record);
				} else if (lastRecord instanceof DrawingGroupRecord) {
					((DrawingGroupRecord)lastRecord).processContinueRecord(contRec.getData());
				} else if (lastRecord instanceof UnknownRecord) {
					//Gracefully handle records that we don't know about,
					//that happen to be continued
					records.add(record);
				} else if (lastRecord instanceof EOFRecord) {
					// This is really odd, but excel still sometimes
					//  outputs a file like this all the same
					records.add(record);
				} else {
					throw new RecordFormatException("Unhandled Continue Record");
				}
			} else {
				lastRecord = record;
				if (record instanceof DrawingRecord) {
					lastDrawingRecord = (DrawingRecord) record;
				}
				records.add(record);
			}
		}

		return records;
	}

	private static void addAll(List<Record> destList, Record[] srcRecs) {
		for (int i = 0; i < srcRecs.length; i++) {
			destList.add(srcRecs[i]);
		}
	}
}

Return to bug 47448

Lines 17-38 Link Here

(-)src/java/org/apache/poi/hssf/record/RecordFactory.java (-112 / +13 lines)
17		17
18	package org.apache.poi.hssf.record;	18	package org.apache.poi.hssf.record;
19		19
		20	import org.apache.poi.hssf.record.chart.*;
		21	import org.apache.poi.hssf.record.pivottable.*;
		22
20	import java.io.InputStream;	23	import java.io.InputStream;
21	import java.lang.reflect.Constructor;	24	import java.lang.reflect.Constructor;
22	import java.lang.reflect.InvocationTargetException;	25	import java.lang.reflect.InvocationTargetException;
23	import java.lang.reflect.Modifier;	26	import java.lang.reflect.Modifier;
24	import java.util.ArrayList;	27	import java.util.*;
25	import java.util.Arrays;
26	import java.util.HashMap;
27	import java.util.HashSet;
28	import java.util.Iterator;
29	import java.util.List;
30	import java.util.Map;
31	import java.util.Set;
32		28
33	import org.apache.poi.hssf.record.chart.*;
34	import org.apache.poi.hssf.record.pivottable.*;
35
36	/**	29	/**
37	* Title: Record Factory<P>	30	* Title: Record Factory<P>
38	* Description: Takes a stream and outputs an array of Record objects.<P>	31	* Description: Takes a stream and outputs an array of Record objects.<P>
Lines 259-265 Link Here
259	return new Record[] { record, };	252	return new Record[] { record, };
260	}	253	}
261		254
262	static Record createSingleRecord(RecordInputStream in) {	255	public static Record createSingleRecord(RecordInputStream in) {
263	I_RecordCreator constructor = _recordCreatorsById.get(new Integer(in.getSid()));	256	I_RecordCreator constructor = _recordCreatorsById.get(new Integer(in.getSid()));
264		257
265	if (constructor == null) {	258	if (constructor == null) {
Lines 273-279 Link Here
273	* RK record is a slightly smaller alternative to NumberRecord	266	* RK record is a slightly smaller alternative to NumberRecord
274	* POI likes NumberRecord better	267	* POI likes NumberRecord better
275	*/	268	*/
276	private static NumberRecord convertToNumberRecord(RKRecord rk) {	269	public static NumberRecord convertToNumberRecord(RKRecord rk) {
277	NumberRecord num = new NumberRecord();	270	NumberRecord num = new NumberRecord();
278		271
279	num.setColumn(rk.getColumn());	272	num.setColumn(rk.getColumn());
Lines 286-292 Link Here
286	/**	279	/**
287	* Converts a {@link MulRKRecord} into an equivalent array of {@link NumberRecord}s	280	* Converts a {@link MulRKRecord} into an equivalent array of {@link NumberRecord}s
288	*/	281	*/
289	private static NumberRecord[] convertRKRecords(MulRKRecord mrk) {	282	public static NumberRecord[] convertRKRecords(MulRKRecord mrk) {
290		283
291	NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];	284	NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];
292	for (int k = 0; k < mrk.getNumColumns(); k++) {	285	for (int k = 0; k < mrk.getNumColumns(); k++) {
Lines 374-482 Link Here
374	* @exception RecordFormatException on error processing the InputStream	367	* @exception RecordFormatException on error processing the InputStream
375	*/	368	*/
376	public static List<Record> createRecords(InputStream in) throws RecordFormatException {	369	public static List<Record> createRecords(InputStream in) throws RecordFormatException {
377
378	List<Record> records = new ArrayList<Record>(NUM_RECORDS);	370	List<Record> records = new ArrayList<Record>(NUM_RECORDS);
379		371
380	RecordInputStream recStream = new RecordInputStream(in);	372	RecordFactoryInputStream recStream = new RecordFactoryInputStream(new RecordInputStream(in));
381	DrawingRecord lastDrawingRecord = new DrawingRecord( );	373	recStream.setIncludeContinueRecords(true);
382	Record lastRecord = null;
383	/*
384	* How to recognise end of stream?
385	* In the best case, the underlying input stream (in) ends just after the last EOF record
386	* Usually however, the stream is padded with an arbitrary byte count. Excel and most apps
387	* reliably use zeros for padding and if this were always the case, this code could just
388	* skip all the (zero sized) records with sid==0. However, bug 46987 shows a file with
389	* non-zero padding that is read OK by Excel (Excel also fixes the padding).
390	*
391	* So to properly detect the workbook end of stream, this code has to identify the last
392	* EOF record. This is not so easy because the worbook bof+eof pair do not bracket the
393	* whole stream. The worksheets follow the workbook, but it is not easy to tell how many
394	* sheet sub-streams should be present. Hence we are looking for an EOF record that is not
395	* immediately followed by a BOF record. One extra complication is that bof+eof sub-
396	* streams can be nested within worksheet streams and it's not clear in these cases what
397	* record might follow any EOF record. So we also need to keep track of the bof/eof
398	* nesting level.
399	*/
400		374
401	int bofDepth=0;	375	Record record;
402	boolean lastRecordWasEOFLevelZero = false;
403	while (recStream.hasNextRecord()) {
404	recStream.nextRecord();
405	if (lastRecordWasEOFLevelZero && recStream.getSid() != BOFRecord.sid) {
406	// Normally InputStream (in) contains only zero padding after this point
407	break;
408	}
409	Record record = createSingleRecord(recStream);
410	lastRecordWasEOFLevelZero = false;
411	if (record instanceof BOFRecord) {
412	bofDepth++;
413	records.add(record);
414	continue;
415	}
416	if (record instanceof EOFRecord) {
417	bofDepth--;
418	records.add(record);
419	if (bofDepth<1) {
420	lastRecordWasEOFLevelZero = true;
421	}
422	continue;
423	}
424		376
425	if (record instanceof DBCellRecord) {	377	while ((record = recStream.nextRecord())!=null) {
426	// Not needed by POI. Regenerated from scratch by POI when spreadsheet is written	378	records.add(record);
427	continue;
428	}
429
430	if (record instanceof RKRecord) {
431	records.add(convertToNumberRecord((RKRecord) record));
432	continue;
433	}
434	if (record instanceof MulRKRecord) {
435	addAll(records, convertRKRecords((MulRKRecord)record));
436	continue;
437	}
438
439	if (record.getSid() == DrawingGroupRecord.sid
440	&& lastRecord instanceof DrawingGroupRecord) {
441	DrawingGroupRecord lastDGRecord = (DrawingGroupRecord) lastRecord;
442	lastDGRecord.join((AbstractEscherHolderRecord) record);
443	} else if (record.getSid() == ContinueRecord.sid) {
444	ContinueRecord contRec = (ContinueRecord)record;
445
446	if (lastRecord instanceof ObjRecord \|\| lastRecord instanceof TextObjectRecord) {
447	// Drawing records have a very strange continue behaviour.
448	//There can actually be OBJ records mixed between the continues.
449	lastDrawingRecord.processContinueRecord(contRec.getData() );
450	//we must remember the position of the continue record.
451	//in the serialization procedure the original structure of records must be preserved
452	records.add(record);
453	} else if (lastRecord instanceof DrawingGroupRecord) {
454	((DrawingGroupRecord)lastRecord).processContinueRecord(contRec.getData());
455	} else if (lastRecord instanceof UnknownRecord) {
456	//Gracefully handle records that we don't know about,
457	//that happen to be continued
458	records.add(record);
459	} else if (lastRecord instanceof EOFRecord) {
460	// This is really odd, but excel still sometimes
461	// outputs a file like this all the same
462	records.add(record);
463	} else {
464	throw new RecordFormatException("Unhandled Continue Record");
465	}
466	} else {
467	lastRecord = record;
468	if (record instanceof DrawingRecord) {
469	lastDrawingRecord = (DrawingRecord) record;
470	}
471	records.add(record);
472	}
473	}	379	}
		380
474	return records;	381	return records;
475	}	382	}
476
477	private static void addAll(List<Record> destList, Record[] srcRecs) {
478	for (int i = 0; i < srcRecs.length; i++) {
479	destList.add(srcRecs[i]);
480	}
481	}
482	}	383	}

Lines 1-234 Link Here

(-)src/java/org/apache/poi/hssf/eventusermodel/HSSFRecordStream.java (-234 lines)
1	/* ====================================================================
2	Licensed to the Apache Software Foundation (ASF) under one or more
3	contributor license agreements. See the NOTICE file distributed with
4	this work for additional information regarding copyright ownership.
5	The ASF licenses this file to You under the Apache License, Version 2.0
6	(the "License"); you may not use this file except in compliance with
7	the License. You may obtain a copy of the License at
8
9	http://www.apache.org/licenses/LICENSE-2.0
10
11	Unless required by applicable law or agreed to in writing, software
12	distributed under the License is distributed on an "AS IS" BASIS,
13	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	See the License for the specific language governing permissions and
15	limitations under the License.
16	==================================================================== */
17	package org.apache.poi.hssf.eventusermodel;
18
19	import java.util.Vector;
20
21	import org.apache.poi.hssf.record.ContinueRecord;
22	import org.apache.poi.hssf.record.DrawingGroupRecord;
23	import org.apache.poi.hssf.record.DrawingRecord;
24	import org.apache.poi.hssf.record.ObjRecord;
25	import org.apache.poi.hssf.record.Record;
26	import org.apache.poi.hssf.record.RecordFactory;
27	import org.apache.poi.hssf.record.RecordFormatException;
28	import org.apache.poi.hssf.record.RecordInputStream;
29	import org.apache.poi.hssf.record.TextObjectRecord;
30	import org.apache.poi.hssf.record.UnknownRecord;
31
32	/**
33	* A stream based way to get at complete records, with
34	* as low a memory footprint as possible.
35	* This handles reading from a RecordInputStream, turning
36	* the data into full records, processing continue records
37	* etc.
38	* Most users should use {@link HSSFEventFactory} /
39	* {@link HSSFListener} and have new records pushed to
40	* them, but this does allow for a "pull" style of coding.
41	*/
42	public class HSSFRecordStream {
43	private RecordInputStream in;
44
45	/** Have we run out of records on the stream? */
46	private boolean hitEOS = false;
47	/** Have we returned all the records there are? */
48	private boolean complete = false;
49
50	/**
51	* Sometimes we end up with a bunch of
52	* records. When we do, these should
53	* be returned before the next normal
54	* record processing occurs (i.e. before
55	* we check for continue records and
56	* return rec)
57	*/
58	private Vector bonusRecords = null;
59
60	/**
61	* The next record to return, which may need to have its
62	* continue records passed to it before we do
63	*/
64	private Record rec = null;
65	/**
66	* The most recent record that we gave to the user
67	*/
68	private Record lastRec = null;
69	/**
70	* The most recent DrawingRecord seen
71	*/
72	private DrawingRecord lastDrawingRecord = new DrawingRecord();
73
74	public HSSFRecordStream(RecordInputStream inp) {
75	this.in = inp;
76	}
77
78	/**
79	* Returns the next (complete) record from the
80	* stream, or null if there are no more.
81	*/
82	public Record nextRecord() {
83	Record r = null;
84
85	// Loop until we get something
86	while(r == null && !complete) {
87	// Are there any bonus records that we need to
88	// return?
89	r = getBonusRecord();
90
91	// If not, ask for the next real record
92	if(r == null) {
93	r = getNextRecord();
94	}
95	}
96
97	// All done
98	return r;
99	}
100
101	/**
102	* If there are any "bonus" records, that should
103	* be returned before processing new ones,
104	* grabs the next and returns it.
105	* If not, returns null;
106	*/
107	private Record getBonusRecord() {
108	if(bonusRecords != null) {
109	Record r = (Record)bonusRecords.remove(0);
110	if(bonusRecords.size() == 0) {
111	bonusRecords = null;
112	}
113	return r;
114	}
115	return null;
116	}
117
118	/**
119	* Returns the next available record, or null if
120	* this pass didn't return a record that's
121	* suitable for returning (eg was a continue record).
122	*/
123	private Record getNextRecord() {
124	Record toReturn = null;
125
126	if(in.hasNextRecord()) {
127	// Grab our next record
128	in.nextRecord();
129	short sid = in.getSid();
130
131	//
132	// for some reasons we have to make the workbook to be at least 4096 bytes
133	// but if we have such workbook we fill the end of it with zeros (many zeros)
134	//
135	// it is not good:
136	// if the length( all zero records ) % 4 = 1
137	// e.g.: any zero record would be readed as 4 bytes at once ( 2 - id and 2 - size ).
138	// And the last 1 byte will be readed WRONG ( the id must be 2 bytes )
139	//
140	// So we should better to check if the sid is zero and not to read more data
141	// The zero sid shows us that rest of the stream data is a fake to make workbook
142	// certain size
143	//
144	if ( sid == 0 )
145	return null;
146
147
148	// If we had a last record, and this one
149	// isn't a continue record, then pass
150	// it on to the listener
151	if ((rec != null) && (sid != ContinueRecord.sid))
152	{
153	// This last record ought to be returned
154	toReturn = rec;
155	}
156
157	// If this record isn't a continue record,
158	// then build it up
159	if (sid != ContinueRecord.sid)
160	{
161	//System.out.println("creating "+sid);
162	Record[] recs = RecordFactory.createRecord(in);
163
164	// We know that the multiple record situations
165	// don't contain continue records, so just
166	// pass those on to the listener now
167	if (recs.length > 1) {
168	bonusRecords = new Vector(recs.length-1);
169	for (int k = 0; k < (recs.length - 1); k++) {
170	bonusRecords.add(recs[k]);
171	}
172	}
173
174	// Regardless of the number we created, always hold
175	// onto the last record to be processed on the next
176	// loop, in case it has any continue records
177	rec = recs[ recs.length - 1 ];
178	// Don't return it just yet though, as we probably have
179	// a record from the last round to return
180	}
181	else {
182	// Normally, ContinueRecords are handled internally
183	// However, in a few cases, there is a gap between a record at
184	// its Continue, so we have to handle them specially
185	// This logic is much like in RecordFactory.createRecords()
186	Record[] recs = RecordFactory.createRecord(in);
187	ContinueRecord crec = (ContinueRecord)recs[0];
188	if((lastRec instanceof ObjRecord) \|\| (lastRec instanceof TextObjectRecord)) {
189	// You can have Obj records between a DrawingRecord
190	// and its continue!
191	lastDrawingRecord.processContinueRecord( crec.getData() );
192	// Trigger them on the drawing record, now it's complete
193	rec = lastDrawingRecord;
194	}
195	else if((lastRec instanceof DrawingGroupRecord)) {
196	((DrawingGroupRecord)lastRec).processContinueRecord(crec.getData());
197	// Trigger them on the drawing record, now it's complete
198	rec = lastRec;
199	}
200	else {
201	if (rec instanceof UnknownRecord) {
202	;//silently skip records we don't know about
203	} else {
204	throw new RecordFormatException("Records should handle ContinueRecord internally. Should not see this exception");
205	}
206	}
207	}
208
209	// Update our tracking of the last record
210	lastRec = rec;
211	if(rec instanceof DrawingRecord) {
212	lastDrawingRecord = (DrawingRecord)rec;
213	}
214	} else {
215	// No more records
216	hitEOS = true;
217	}
218
219	// If we've hit the end-of-stream, then
220	// finish off the last record and be done
221	if(hitEOS) {
222	complete = true;
223
224	// Return the last record if there was
225	// one, otherwise null
226	if(rec != null) {
227	toReturn = rec;
228	rec = null;
229	}
230	}
231
232	return toReturn;
233	}
234	}