Changeset 6747 for lang/scala/sandbox

Timestamp:

02/16/08 00:36:57 (10 months ago)

Author:

ryugate

Message:

POI.scala: Update

Files:

• lang/scala/sandbox/src/jp/ryugate/apache/POI.scala (modified) (6 diffs)

lang/scala/sandbox/src/jp/ryugate/apache/POI.scala

@@ -13 +13 @@
   import org.apache.poi.hssf.usermodel.HSSFCell
   import org.apache.poi.hssf.usermodel.HSSFCell._
+
+  private def gets[T](f:int => T, n:int*)
+    = n.foldLeft(List[T]()){(acc, i) => f(i) :: acc}.reverse
+  private def eachWithIndex[T](f:(int*) => List[T], f2:(T,int) => Unit, arg:int*)
+    = f(arg:_*).zipWithIndex.foreach{case (row,idx) => f2(row,idx)}
   
   /**
@@ -18 +23 @@
   */
   class Book(book:HSSFWorkbook) {
+    def this()                    = this(new HSSFWorkbook())
     def this(is:InputStream)      = this(new HSSFWorkbook(is))
     def this(ist:FileInputStream) = this(new HSSFWorkbook(ist))
     def this(filename:String)     = this(new FileInputStream(filename))
-    def this()                    = this(new HSSFWorkbook())
   
-    def getSheet(index:int)      = new Sheet(book.getSheetAt(index))
-    def getSheet(name:String)    = new Sheet(book.getSheet(name))
+    def getSheet(index:int  ) = new Sheet(book.getSheetAt(index))
+    def getSheet(name:String) = new Sheet(book.getSheet(name))
 
-    def sheetWith(index:int)(f:Sheet => Unit):Unit = f(getSheet(index))
+    def sheet(index:int  ) = getSheet(index)
+    def sheet(name:String) = getSheet(name)
+    
+    def sheets(idxs:int*  ) = gets(sheet, idxs:_*)
+    def sheets(range:Range) = gets(sheet, range:_*)
 
-    def eachSheets(range:Range)(f:Sheet => Unit):Unit = range.foreach{i => f(new Sheet(book.getSheetAt(i)))}
+    def sheetWith(index:int  )(f:Sheet => Unit):Unit = f(getSheet(index))
+    def sheetWith(name:String)(f:Sheet => Unit):Unit = f(getSheet(name))
+
+    def eachSheets(idxs:int*  )(f:Sheet => Unit):Unit = sheets(idxs:_* ).foreach{f(_)}
+    def eachSheets(range:Range)(f:Sheet => Unit):Unit = sheets(range:_*).foreach{f(_)}
+
+    def eachSheetsWithIndex(idxs:int*  )(f:(Sheet,int) => Unit) = eachWithIndex(sheets, f, idxs:_*)
+    def eachSheetsWithIndex(range:Range)(f:(Sheet,int) => Unit) = eachWithIndex(sheets, f, range:_*)
 
     def each(f:Sheet => Unit):Unit = eachSheets(0 to book.getNumberOfSheets-1)(f)
-  
+
+    //--------------------------------------------
     def createSheet()            = new Sheet(book.createSheet)
     def createSheet(name:String) = new Sheet(book.createSheet(name))  
@@ -41 +58 @@
   class Sheet(sheet:HSSFSheet) {
     def getRow(rownum:int) = new Row(sheet.getRow(rownum))
-    def row(rownum:int) = getRow(rownum)
-    
     def getCol(colnum:int) = new Col(sheet, colnum)
 
+    def row(rownum:int) = getRow(rownum)
+    def col(colnum:int) = getCol(colnum)
+
     def getCell(row:int,col:int) = getRow(row).getCell(col)
+    def cell(row:int,col:int) = getCell(row,col)
 
-    def gets[T](f:int => T, n:Array[int]) = n.foldLeft(List[T]()){(acc, i) => f(i) :: acc}.reverse
-    def rows(rs:int*) = gets(getRow, rs.toArray)
-    def rows(range:Range) = gets(getRow, range.toArray)
-    def cols(cs:int*) = gets(getCol, cs.toArray)
+    def rows(rowIdxs:int*) = gets(getRow, rowIdxs:_*)
+    def cols(colIdxs:int*) = gets(getCol, colIdxs:_*)
+    def rows(range:Range ) = gets(getRow, range:_*)
+    def cols(range:Range ) = gets(getCol, range:_*)
 
-    def rowWith(rownum:int)(f:Row => Unit):Unit = f(getRow(rownum))
+    def rowWith(num:int)(f:Row => Unit):Unit = f(getRow(num))
+    def colWith(num:int)(f:Col => Unit):Unit = f(getCol(num))
 
-    def eachRows(range:Range)(f:Row => Unit) = range.foreach{i => f(new Row(sheet.getRow(i)))}
-    def eachCols(cs:int*)(f:Col => Unit) = cs.foreach {col => f(new Col(sheet, col))}
+    def eachRows(rowIdxs:int*)(f:Row => Unit) = rows(rowIdxs:_*).foreach{f(_)}
+    def eachCols(colIdxs:int*)(f:Col => Unit) = cols(colIdxs:_*).foreach{f(_)}
+    def eachRows(range:Range )(f:Row => Unit) = rows(range     ).foreach{f(_)}
+    def eachCols(range:Range )(f:Col => Unit) = cols(range     ).foreach{f(_)}
+
+    def eachRowsWithIndex(idxs:int*  )(f:(Row,int) => Unit) = eachWithIndex(rows, f, idxs:_*)
+    def eachColsWithIndex(idxs:int*  )(f:(Col,int) => Unit) = eachWithIndex(cols, f, idxs:_*)
+    def eachRowsWithIndex(range:Range)(f:(Row,int) => Unit) = eachWithIndex(rows, f, range:_*)
+    def eachColsWithIndex(range:Range)(f:(Col,int) => Unit) = eachWithIndex(cols, f, range:_*)
 
     def each(f:Row => Unit):Unit = eachRows(0 to sheet.getLastRowNum)(f)
     
+    //--------------------------------------------
     def createRow(rownum:int) = new Row(sheet.createRow(rownum))
   }
@@ -68 +96 @@
     def getCell(cellnum:int) = new Cell(row.getCell(cellnum.toShort))
     def cell(cellnum:int) = getCell(cellnum)
-    def cells(cs:int*) = cs.foldLeft(List[Cell]()){(acc,cell) => getCell(cell) :: acc}.reverse
+    
+    def cells(idxs:int*  ) = gets(getCell, idxs:_*)
+    def cells(range:Range) = gets(getCell, range:_*)
 
-    def eachCells(range:Range)(f:Cell => Unit) = range.foreach{i => f(new Cell(row.getCell(i.toShort)))}
-    def eachCells(cols:int*)(f:Cell => Unit)   =  cols.foreach{i => f(new Cell(row.getCell(i.toShort)))}
-
+    def eachCells(idxs:int*  )(f:Cell => Unit) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells(range:Range)(f:Cell => Unit) = cells(range:_*).foreach{f(_)}
+ 
+    def eachCellsWithIndex(idxs:int*  )(f:(Cell,int) => Unit) = eachWithIndex(cells, f, idxs:_*)
+    def eachCellsWithIndex(range:Range)(f:(Cell,int) => Unit) = eachWithIndex(cells, f, range:_*)
+      
     def each(f:Cell => Unit):Unit = eachCells(1 to row.getLastCellNum-1)(f)
 
+    //--------------------------------------------
     def createCell(cellnum:int) = new Cell(row.createCell(cellnum.toShort))
 
@@ -93 +127 @@
     def getCell(row:int) = new Cell(sheet.getRow(row).getCell(col.toShort))
     def cell(row:int) = getCell(row)
+
+    def cells(idxs:int*  ) = gets(getCell, idxs:_*)
+    def cells(range:Range) = gets(getCell, range:_*)
     
-    def eachCells(rows:int*)(f:Cell => Unit) = rows.foreach{i => f(getCell(i))}
+    def eachCells(idxs:int*  )(f:Cell => Unit) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells(range:Range)(f:Cell => Unit) = cells(range:_*).foreach{f(_)}
+ 
+    def eachCellsWithIndex(idxs:int*  )(f:(Cell,int) => Unit) = eachWithIndex(cells, f, idxs:_*)
+    def eachCellsWithIndex(range:Range)(f:(Cell,int) => Unit) = eachWithIndex(cells, f, range:_*)
+      
+    def each(f:Cell => Unit):Unit = eachCells(1 to sheet.getLastRowNum-1)(f)
   }
   
@@ -102 +145 @@
   class Cell(cell:HSSFCell) {
     def getNumericCellValue = cell.getNumericCellValue
+    
     def getCellValue = {
       cell.getCellType match {