From b6fedbefd91ccf1bacdd6a9acfa233cc4df12331 Mon Sep 17 00:00:00 2001 From: Nick Burch Date: Fri, 18 May 2007 13:27:04 +0000 Subject: [PATCH] Initial version of a Missing Record Aware shim on HSSFListener. Includes limited tests, but not yet any documentation git-svn-id: https://svn.apache.org/repos/asf/jakarta/poi/trunk@539462 13f79535-47bb-0310-9956-ffa450edef68 --- .../MissingRecordAwareHSSFListener.java | 199 +++++++++ .../dummyrecord/LastCellOfRowDummyRecord.java | 61 +++ .../dummyrecord/MissingCellDummyRecord.java | 49 +++ .../dummyrecord/MissingRowDummyRecord.java | 48 +++ .../org/apache/poi/hssf/data/MissingBits.xls | Bin 0 -> 5632 bytes .../TestMissingRecordAwareHSSFListener.java | 376 ++++++++++++++++++ 6 files changed, 733 insertions(+) create mode 100644 src/scratchpad/src/org/apache/poi/hssf/eventusermodel/MissingRecordAwareHSSFListener.java create mode 100644 src/scratchpad/src/org/apache/poi/hssf/eventusermodel/dummyrecord/LastCellOfRowDummyRecord.java create mode 100644 src/scratchpad/src/org/apache/poi/hssf/eventusermodel/dummyrecord/MissingCellDummyRecord.java create mode 100644 src/scratchpad/src/org/apache/poi/hssf/eventusermodel/dummyrecord/MissingRowDummyRecord.java create mode 100644 src/scratchpad/testcases/org/apache/poi/hssf/data/MissingBits.xls create mode 100644 src/scratchpad/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java diff --git a/src/scratchpad/src/org/apache/poi/hssf/eventusermodel/MissingRecordAwareHSSFListener.java b/src/scratchpad/src/org/apache/poi/hssf/eventusermodel/MissingRecordAwareHSSFListener.java new file mode 100644 index 000000000..4acc392cc --- /dev/null +++ b/src/scratchpad/src/org/apache/poi/hssf/eventusermodel/MissingRecordAwareHSSFListener.java @@ -0,0 +1,199 @@ +/* ==================================================================== + 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 org.apache.poi.hssf.eventusermodel.HSSFListener; +import org.apache.poi.hssf.eventusermodel.dummyrecord.LastCellOfRowDummyRecord; +import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingCellDummyRecord; +import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingRowDummyRecord; +import org.apache.poi.hssf.record.BOFRecord; +import org.apache.poi.hssf.record.BlankRecord; +import org.apache.poi.hssf.record.BoolErrRecord; +import org.apache.poi.hssf.record.BoundSheetRecord; +import org.apache.poi.hssf.record.FormulaRecord; +import org.apache.poi.hssf.record.LabelRecord; +import org.apache.poi.hssf.record.LabelSSTRecord; +import org.apache.poi.hssf.record.NoteRecord; +import org.apache.poi.hssf.record.NumberRecord; +import org.apache.poi.hssf.record.RKRecord; +import org.apache.poi.hssf.record.Record; +import org.apache.poi.hssf.record.RowRecord; + +/** + *

A HSSFListener which tracks rows and columns, and will + * trigger your HSSFListener for all rows and cells, + * even the ones that aren't actually stored in the file.

+ *

This allows your code to have a more "Excel" like + * view of the data in the file, and not have to worry + * (as much) about if a particular row/cell is in the + * file, or was skipped from being written as it was + * blank. + */ +public class MissingRecordAwareHSSFListener implements HSSFListener { + private HSSFListener childListener; + private int lastSeenRow = -1; + private int lastSeenColumn = -1; + + /** + * Constructs a new MissingRecordAwareHSSFListener, which + * will fire processRecord on the supplied child + * HSSFListener for all Records, and missing records. + * @param listener The HSSFListener to pass records on to + */ + public MissingRecordAwareHSSFListener(HSSFListener listener) { + childListener = listener; + } + + public void processRecord(Record record) { + int thisRow = -1; + int thisColumn = -1; + + switch (record.getSid()) + { + // the BOFRecord can represent either the beginning of a sheet or the workbook + case BOFRecord.sid: + BOFRecord bof = (BOFRecord) record; + if (bof.getType() == bof.TYPE_WORKBOOK) + { + // Reset the row and column counts - new workbook + lastSeenRow = -1; + lastSeenColumn = -1; + //System.out.println("Encountered workbook"); + } else if (bof.getType() == bof.TYPE_WORKSHEET) + { + // Reset the row and column counts - new sheet + lastSeenRow = -1; + lastSeenColumn = -1; + //System.out.println("Encountered sheet reference"); + } + break; + case BoundSheetRecord.sid: + BoundSheetRecord bsr = (BoundSheetRecord) record; + System.out.println("New sheet named: " + bsr.getSheetname()); + break; + case RowRecord.sid: + RowRecord rowrec = (RowRecord) record; + //System.out.println("Row " + rowrec.getRowNumber() + " found, first column at " + // + rowrec.getFirstCol() + " last column at " + rowrec.getLastCol()); + + // If there's a jump in rows, fire off missing row records + if(lastSeenRow+1 < rowrec.getRowNumber()) { + for(int i=(lastSeenRow+1); ixh7iifoi6%`8#WeDuhJZ#CE2U-EHZ-k4c<6&> zteW_siO~czi7$P$CR$%=V){UzP_urd4{g%;(E1-}G%<#D{GBs9%di36nlw?u8P2)) zoO{p5oO|!NJN)=VdHIuvYW72KduF*9qZC3iZ&b_Mi5Spk53=g3FG3^-`HwSgzdrCW$ZX-4DrRv;L zNd_(Wni^5OFI$^nVQlK`s}EY{>k@w%||Nk2D`lCcDz{AOdBQ%B2n})6v_($R?A6leF7| z6!wZrSR)-@QAo#E&3_a#~Sh?p_CjA46L~7M>qC|Tm_nex1yptT+zGDwG{Z> zi)-tX#kk02aaI0XF!c9w*@tV*Ur#Pp*P6eP^7K0L z+BN0kP2*V({Jvv-Xj*7+syt~Mortzgj-_q0Q==^$Xxrjcd&gN941B;E=+_XIb?8M` zBy#JigdIoR6p6#u5r&<`#YHv_T-Sq}&GUXNpuqWgJ|5-BlP`!tI+jPeYELbw4e>%H z)hkfn^IW*(J(s$)>lIvN^B%H=0_B`7=o0fZpLemaumDa#)}$vbW%uAS$Ay(pHZqs?ZBnYxXQIpp?p-#4rfKjh9 zDSPEI38P#lnJ$+}Eafus7?$1D)dLeH@VdE$n?tyLC9aCxOGQpR+qhEVs>!`jH8Pu9)|MNo$cgtLGMk&%#-*a3 zyrr#gA~su9k2_aAw9>k*EANlRirh_FzQC8C=Dc6M8{StHJagV*vk6!97!FcTawqUG z_hMC>F08?=&t9yOLlUU}#K{}=knnd+@sI?Ez)zXbo4W9TCRN3Qq(N3RsVXgr?kA}k z7KhEGO8y3k|BzIfwh8~m49LPs8J2P;Wm1Zx)F1h_m#a~J0LZbBOGPf{twgzO>WOm2 z@QX#iwVK)bB^&asq8Ic-Y_}745O)&!5yDaiv=bj8#)-R$9mGyz7jX|ULF9)8lEf4- zP3$K25POMoneb}>eZ&k={{OHE|1JZgILBv>YjG53+0NoTGg>+DtJMfR%U-G!9NA2S z=jeSFGdQ7f%=p6lp!^R&$-l%=scOFHztZ^|b)Kx*TIXNRRDgGb1>S5oTn7FEbfpE7 literal 0 HcmV?d00001 diff --git a/src/scratchpad/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java b/src/scratchpad/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java new file mode 100644 index 000000000..9c2cb2b87 --- /dev/null +++ b/src/scratchpad/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java @@ -0,0 +1,376 @@ +/* ==================================================================== + 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 org.apache.poi.hssf.eventusermodel.HSSFEventFactory; +import org.apache.poi.hssf.eventusermodel.HSSFListener; + +import java.io.File; +import java.io.FileInputStream; +import java.util.ArrayList; + +import org.apache.poi.hssf.eventusermodel.HSSFRequest; +import org.apache.poi.hssf.eventusermodel.dummyrecord.LastCellOfRowDummyRecord; +import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingCellDummyRecord; +import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingRowDummyRecord; +import org.apache.poi.hssf.record.LabelSSTRecord; +import org.apache.poi.hssf.record.Record; +import org.apache.poi.hssf.record.RowRecord; +import org.apache.poi.poifs.filesystem.POIFSFileSystem; + +import junit.framework.TestCase; + +public class TestMissingRecordAwareHSSFListener extends TestCase { + private String dirname; + + public TestMissingRecordAwareHSSFListener() { + dirname = System.getProperty("HSSF.testdata.path"); + } + + public void testMissingRowRecords() throws Exception { + File f = new File(dirname + "/MissingBits.xls"); + + HSSFRequest req = new HSSFRequest(); + MockHSSFListener mockListen = new MockHSSFListener(); + MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen); + req.addListenerForAllRecords(listener); + + POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(f)); + HSSFEventFactory factory = new HSSFEventFactory(); + factory.processWorkbookEvents(req, fs); + + // Check we got the dummy records + Record[] r = (Record[]) + mockListen.records.toArray(new Record[mockListen.records.size()]); + + // We have rows 0, 1, 2, 20 and 21 + int row0 = -1; + for(int i=0; i -1); + + // Following row 0, we should have 1, 2, then dummy, then 20+21+22 + assertTrue(r[row0] instanceof RowRecord); + assertTrue(r[row0+1] instanceof RowRecord); + assertTrue(r[row0+2] instanceof RowRecord); + assertTrue(r[row0+3] instanceof MissingRowDummyRecord); + assertTrue(r[row0+4] instanceof MissingRowDummyRecord); + assertTrue(r[row0+5] instanceof MissingRowDummyRecord); + assertTrue(r[row0+6] instanceof MissingRowDummyRecord); + // ... + assertTrue(r[row0+18] instanceof MissingRowDummyRecord); + assertTrue(r[row0+19] instanceof MissingRowDummyRecord); + assertTrue(r[row0+20] instanceof RowRecord); + assertTrue(r[row0+21] instanceof RowRecord); + assertTrue(r[row0+22] instanceof RowRecord); + + // Check things had the right row numbers + RowRecord rr; + rr = (RowRecord)r[row0+2]; + assertEquals(2, rr.getRowNumber()); + rr = (RowRecord)r[row0+20]; + assertEquals(20, rr.getRowNumber()); + rr = (RowRecord)r[row0+21]; + assertEquals(21, rr.getRowNumber()); + + MissingRowDummyRecord mr; + mr = (MissingRowDummyRecord)r[row0+3]; + assertEquals(3, mr.getRowNumber()); + mr = (MissingRowDummyRecord)r[row0+4]; + assertEquals(4, mr.getRowNumber()); + mr = (MissingRowDummyRecord)r[row0+5]; + assertEquals(5, mr.getRowNumber()); + mr = (MissingRowDummyRecord)r[row0+18]; + assertEquals(18, mr.getRowNumber()); + mr = (MissingRowDummyRecord)r[row0+19]; + assertEquals(19, mr.getRowNumber()); + } + + public void testEndOfRowRecords() throws Exception { + File f = new File(dirname + "/MissingBits.xls"); + + HSSFRequest req = new HSSFRequest(); + MockHSSFListener mockListen = new MockHSSFListener(); + MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen); + req.addListenerForAllRecords(listener); + + POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(f)); + HSSFEventFactory factory = new HSSFEventFactory(); + factory.processWorkbookEvents(req, fs); + + // Check we got the dummy records + Record[] r = (Record[]) + mockListen.records.toArray(new Record[mockListen.records.size()]); + + // Find the cell at 0,0 + int cell00 = -1; + for(int i=0; i -1); + + // We have rows 0, 1, 2, 20 and 21 + // Row 0 has 1 entry + // Row 1 has 4 entries + // Row 2 has 6 entries + // Row 20 has 5 entries + // Row 21 has 7 entries + // Row 22 has 12 entries + + // Row 0 + assertFalse(r[cell00+0] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+1] instanceof LastCellOfRowDummyRecord); + // Row 1 + assertFalse(r[cell00+2] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+3] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+4] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+5] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+6] instanceof LastCellOfRowDummyRecord); + // Row 2 + assertFalse(r[cell00+7] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+8] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+9] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+10] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+11] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+12] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+13] instanceof LastCellOfRowDummyRecord); + // Row 3 -> 19 + assertTrue(r[cell00+14] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+15] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+16] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+17] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+18] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+19] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+20] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+21] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+22] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+23] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+24] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+25] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+26] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+27] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+28] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+29] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+30] instanceof LastCellOfRowDummyRecord); + // Row 20 + assertFalse(r[cell00+31] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+32] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+33] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+34] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+35] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+36] instanceof LastCellOfRowDummyRecord); + // Row 21 + assertFalse(r[cell00+37] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+38] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+39] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+40] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+41] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+42] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+43] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+44] instanceof LastCellOfRowDummyRecord); + // Row 22 + assertFalse(r[cell00+45] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+46] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+47] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+48] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+49] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+50] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+51] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+52] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+53] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+54] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+55] instanceof LastCellOfRowDummyRecord); + assertFalse(r[cell00+56] instanceof LastCellOfRowDummyRecord); + assertTrue(r[cell00+57] instanceof LastCellOfRowDummyRecord); + + // Check the numbers of the last seen columns + LastCellOfRowDummyRecord[] lrs = new LastCellOfRowDummyRecord[23]; + int lrscount = 0; + for(int i=0; i -1); + + // We have rows 0, 1, 2, 20 and 21 + // Row 0 has 1 entry, 0 + // Row 1 has 4 entries, 0+3 + // Row 2 has 6 entries, 0+5 + // Row 20 has 5 entries, 0-5 + // Row 21 has 7 entries, 0+1+3+5+6 + // Row 22 has 12 entries, 0+3+4+11 + + // Row 0 + assertFalse(r[cell00+0] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+1] instanceof MissingCellDummyRecord); + + // Row 1 + assertFalse(r[cell00+2] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+3] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+4] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+5] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+6] instanceof MissingCellDummyRecord); + + // Row 2 + assertFalse(r[cell00+7] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+8] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+9] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+10] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+11] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+12] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+13] instanceof MissingCellDummyRecord); + + // Row 3-19 + assertFalse(r[cell00+14] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+15] instanceof MissingCellDummyRecord); + + // Row 20 + assertFalse(r[cell00+31] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+32] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+33] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+34] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+35] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+36] instanceof MissingCellDummyRecord); + + // Row 21 + assertFalse(r[cell00+37] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+38] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+39] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+40] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+41] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+42] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+43] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+44] instanceof MissingCellDummyRecord); + + // Row 22 + assertFalse(r[cell00+45] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+46] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+47] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+48] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+49] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+50] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+51] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+52] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+53] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+54] instanceof MissingCellDummyRecord); + assertTrue(r[cell00+55] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+56] instanceof MissingCellDummyRecord); + assertFalse(r[cell00+57] instanceof MissingCellDummyRecord); + + // Check some numbers + MissingCellDummyRecord mc; + + mc = (MissingCellDummyRecord)r[cell00+3]; + assertEquals(1, mc.getRow()); + assertEquals(1, mc.getColumn()); + mc = (MissingCellDummyRecord)r[cell00+4]; + assertEquals(1, mc.getRow()); + assertEquals(2, mc.getColumn()); + + mc = (MissingCellDummyRecord)r[cell00+8]; + assertEquals(2, mc.getRow()); + assertEquals(1, mc.getColumn()); + mc = (MissingCellDummyRecord)r[cell00+9]; + assertEquals(2, mc.getRow()); + assertEquals(2, mc.getColumn()); + + mc = (MissingCellDummyRecord)r[cell00+55]; + assertEquals(22, mc.getRow()); + assertEquals(10, mc.getColumn()); + } + + private static class MockHSSFListener implements HSSFListener { + private MockHSSFListener() {} + private ArrayList records = new ArrayList(); + + public void processRecord(Record record) { + records.add(record); + + if(record instanceof MissingRowDummyRecord) { + MissingRowDummyRecord mr = (MissingRowDummyRecord)record; + System.out.println("Got dummy row " + mr.getRowNumber()); + } + if(record instanceof MissingCellDummyRecord) { + MissingCellDummyRecord mc = (MissingCellDummyRecord)record; + System.out.println("Got dummy cell " + mc.getRow() + " " + mc.getColumn()); + } + if(record instanceof LastCellOfRowDummyRecord) { + LastCellOfRowDummyRecord lc = (LastCellOfRowDummyRecord)record; + System.out.println("Got end-of row, row was " + lc.getRow() + ", last column was " + lc.getLastColumnNumber()); + } + } + } +}