Changeset 6890

Timestamp:

02/19/08 01:17:36 (5 years ago)

Author:

ryugate

Message:

POI.scala: Update

Location:

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

Files:

• POI.scala (modified) (7 diffs)
• POISpecification.scala (modified) (2 diffs)

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

@@ -2 +2 @@
 
 /**
-* POI wrapper 
+* POI wrapper
+* 2008/2/18
 */
 object POI {
@@ -14 +15 @@
   import org.apache.poi.hssf.usermodel.HSSFCell._
 
-  private def gets[T](f:int => T, n:int*)
+  private def makeSomeList[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)}
-  
+    
+  private def eachWithIndex[T](lst:List[T], f2:(T,int) => Unit)
+    = lst.zipWithIndex.foreach{case (row,idx) => f2(row,idx)}
+
   /**
   * Book 
   */
-  class Book(book:HSSFWorkbook) {
+  class Book(hssf_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 getSheet(index:int  ) = new Sheet(book.getSheetAt(index))
-    def getSheet(name:String) = new Sheet(book.getSheet(name))
 
-    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 sheet(index:int  ) = new Sheet(hssf_book.getSheetAt(index-1))
+    def sheet(name:String) = hssf_book.getSheet(name) match {
+      case null => throw new NoSuchElementException(name + "(Sheet not found)")
+      case v => new Sheet(v)
+    }
 
-    def sheetWith(index:int  )(f:Sheet => Unit):Unit = f(getSheet(index))
-    def sheetWith(name:String)(f:Sheet => Unit):Unit = f(getSheet(name))
+    def withSheet(index:int  )(f:Sheet => Unit):Unit = f(sheet(index))
+    def withSheet(name:String)(f:Sheet => Unit):Unit = f(sheet(name))
+
+    def sheets(idxs:int*  ) = makeSomeList(sheet, idxs:_*)
+    def sheets(range:Range) = makeSomeList(sheet, range:_*)
 
     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(idxs:_*), f)
+    def eachSheetsWithIndex(range:Range)(f:(Sheet,int) => Unit) = eachWithIndex(sheets(range:_*), 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 each(f:Sheet => Unit):Unit = eachSheets(1 to hssf_book.getNumberOfSheets)(f)
 
     //--------------------------------------------
-    def createSheet()            = new Sheet(book.createSheet)
-    def createSheet(name:String) = new Sheet(book.createSheet(name))  
+    def createSheet()            = new Sheet(hssf_book.createSheet)
+    def createSheet(name:String) = new Sheet(hssf_book.createSheet(name))  
   }
 
@@ -56 +58 @@
   * Sheet 
   */
-  class Sheet(sheet:HSSFSheet) {
-    def getRow(rownum:int) = new Row(sheet.getRow(rownum))
-    def getCol(colnum:int) = new Col(sheet, colnum)
+  class Sheet(hssf_sheet:HSSFSheet) {
+    def row(ri:int) = new Row(ri, hssf_sheet.getRow(ri-1))
+    def col(ci:int) = new Col(this, ci)
 
-    def row(rownum:int) = getRow(rownum)
-    def col(colnum:int) = getCol(colnum)
+    def getCell(ri:int,ci:int) = row(ri).get(ci)
+    def cell(ri:int,ci:int) = row(ri).apply(ci)
 
-    def getCell(row:int,col:int) = getRow(row).getCell(col)
-    def cell(row:int,col:int) = getCell(row,col)
+    def withRow(ri:int)(f:Row => Unit):Unit = f(row(ri))
+    def withCol(ci:int)(f:Col => Unit):Unit = f(col(ci))
 
-    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(num:int)(f:Row => Unit):Unit = f(getRow(num))
-    def colWith(num:int)(f:Col => Unit):Unit = f(getCol(num))
+    def rows(rowIdxs:int*) = makeSomeList(row, rowIdxs:_*)
+    def cols(colIdxs:int*) = makeSomeList(col, colIdxs:_*)
+    def rows(range:Range ) = makeSomeList(row, range:_*)
+    def cols(range:Range ) = makeSomeList(col, range:_*)
 
     def eachRows(rowIdxs:int*)(f:Row => Unit) = rows(rowIdxs:_*).foreach{f(_)}
@@ -79 +78 @@
     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 eachRowsWithIndex(idxs:int*  )(f:(Row,int) => Unit) = eachWithIndex(rows(idxs:_*), f)
+    def eachColsWithIndex(idxs:int*  )(f:(Col,int) => Unit) = eachWithIndex(cols(idxs:_*), f)
+    def eachRowsWithIndex(range:Range)(f:(Row,int) => Unit) = eachWithIndex(rows(range:_*), f)
+    def eachColsWithIndex(range:Range)(f:(Col,int) => Unit) = eachWithIndex(cols(range:_*), f)
 
-    def each(f:Row => Unit):Unit = eachRows(0 to sheet.getLastRowNum)(f)
+    def each(f:Row => Unit):Unit = eachRows(0 to getLastRowNum)(f)
     
     //--------------------------------------------
-    def createRow(rownum:int) = new Row(sheet.createRow(rownum))
+    def createRow(rownum:int) = new Row(rownum, hssf_sheet.createRow(rownum-1))
+    
+    def getLastRowNum = hssf_sheet.getLastRowNum
   }
 
@@ -93 +94 @@
   * Row 
   */
-  class Row(row:HSSFRow) {
-    def getCell(cellnum:int) = new Cell(row.getCell(cellnum.toShort))
-    def cell(cellnum:int) = getCell(cellnum)
-    
-    def cells(idxs:int*  ) = gets(getCell, idxs:_*)
-    def cells(range:Range) = gets(getCell, range:_*)
+  class Row(ri:int, hssf_row:HSSFRow) {
+    def get(cellnum:int) = hssf_row match {
+      case null => None
+      case _ => hssf_row.getCell((cellnum-1).toShort) match {
+        case null => None
+        case v    => new Some(new Cell(v))
+      }
+    }
+
+    def apply(cellnum:int) = get(cellnum) match {
+      case None => throw new NoSuchElementException(ri +"," + cellnum + " (Cell not found)")
+      case Some(v) => v
+    }
+    def col(cellnum:int) = apply(cellnum)
+    def cell(cellnum:int) = apply(cellnum)
+
+    def getCells(idxs:int*  ) = makeSomeList(get, idxs:_*)
+    def getCells(range:Range) = makeSomeList(get, range:_*)
+    def cells(idxs:int*  ) = makeSomeList(apply, idxs:_*)
+    def cells(range:Range) = makeSomeList(apply, range:_*)
 
     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 eachCellsWithIndex(idxs:int*  )(f:(Cell,int) => Unit) = eachWithIndex(cells(idxs:_*), f)
+    def eachCellsWithIndex(range:Range)(f:(Cell,int) => Unit) = eachWithIndex(cells(range:_*), f)
       
-    def each(f:Cell => Unit):Unit = eachCells(1 to row.getLastCellNum-1)(f)
+    def each(f:Cell => Unit):Unit = eachCells(0 to hssf_row.getLastCellNum)(f)
 
     //--------------------------------------------
-    def createCell(cellnum:int) = new Cell(row.createCell(cellnum.toShort))
+    def createCell(cellnum:int) = new Cell(hssf_row.createCell(cellnum.toShort))
 
     def setCell(cellnum:int, value:String, encoding:Short):HSSFCell = {
-      val cell = row.createCell(cellnum.toShort)
+      val cell = hssf_row.createCell(cellnum.toShort)
       cell.setEncoding(encoding)
       cell.setCellValue(value)
@@ -124 +139 @@
   * Col
   */
-  class Col(sheet:HSSFSheet, col:int) {
-    def getCell(row:int) = new Cell(sheet.getRow(row).getCell(col.toShort))
-    def cell(row:int) = getCell(row)
+  class Col(sheet:Sheet, colIdx:int) {
+    def get(ri:int) = sheet.row(ri).get(colIdx)
 
-    def cells(idxs:int*  ) = gets(getCell, idxs:_*)
-    def cells(range:Range) = gets(getCell, range:_*)
+    def apply(ri:int) = sheet.row(ri).apply(colIdx)
+    def row(ri:int) = apply(ri)
+    def cell(ri:int) = apply(ri)
+
+    def getCells(idxs:int*  ) = makeSomeList(get, idxs:_*)
+    def getCells(range:Range) = makeSomeList(get, range:_*)
+    def cells(idxs:int*  ) = makeSomeList(apply, idxs:_*)
+    def cells(range:Range) = makeSomeList(apply, range:_*)
     
     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 eachCellsWithIndex(idxs:int*  )(f:(Cell,int) => Unit) = eachWithIndex(cells(idxs:_*), f)
+    def eachCellsWithIndex(range:Range)(f:(Cell,int) => Unit) = eachWithIndex(cells(range:_*), f)
       
-    def each(f:Cell => Unit):Unit = eachCells(1 to sheet.getLastRowNum-1)(f)
+    def each(f:Cell => Unit):Unit = eachCells(0 to sheet.getLastRowNum)(f)
   }
   
@@ -143 +163 @@
   * Cell
   */
-  class Cell(cell:HSSFCell) {
-    def getNumericCellValue = cell.getNumericCellValue
+  class Cell(hssf_cell:HSSFCell) {
+//    def get = apply match {
+//      case null => None
+//      case v    => new Some(v)
+//    }
+
+    def apply = hssf_cell.getCellType match {
+      case CELL_TYPE_STRING  => hssf_cell.getRichStringCellValue.getString
+      case CELL_TYPE_NUMERIC => hssf_cell.getNumericCellValue
+      case CELL_TYPE_FORMULA => hssf_cell.getCellFormula
+      case CELL_TYPE_BOOLEAN => hssf_cell.getBooleanCellValue
+      case CELL_TYPE_ERROR   => hssf_cell.getErrorCellValue
+      case _ => hssf_cell.toString
+    }
     
-    def getCellValue = {
-      cell.getCellType match {
-        case CELL_TYPE_STRING  => cell.getRichStringCellValue.getString
-        case CELL_TYPE_NUMERIC => cell.getNumericCellValue
-        case CELL_TYPE_FORMULA => cell.getCellFormula
-        case CELL_TYPE_BOOLEAN => cell.getBooleanCellValue
-        case CELL_TYPE_ERROR   => cell.getErrorCellValue
-        case _ => cell.toString
-      }
-    }
-    def value = getCellValue
+    def value = apply
   }
 }

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

@@ -2 +2 @@
 
 import org.specs._
-
-import jp.ryugate.apache.POI._
+import org.specs.matcher._
+import org.specs.matcher.AnyMatchers
+import org.specs.matcher.PatternMatchers.CaseMatcher
 
 object POISpecification extends Specification {
-  "Book module" should {
+  import jp.ryugate.apache.POI._
+
+  import java.lang._
+
+  "POI module" should {
+    val book = new Book("test.xls")
+    val sheet1 = book.sheet(1)
+
+    "open Book" in { book must notBeNull }
+    
+    "get Sheet" in {
+      sheet1 must notBeNull
+      book.sheet(1) must notBeNull
+      book.sheet("Sheet1") must notBeNull
+      book.sheet(10) must throwException(new IndexOutOfBoundsException)
+      book.sheet("nosheet1") must throwException(new NoSuchElementException)
+    }
+    
+    "get meny sheets" in {
+      book.sheets(1 to 10) must throwException(new IndexOutOfBoundsException)
+      book.sheets(1,10) must throwException(new IndexOutOfBoundsException)
+    }
+    
+    "sheet and block" in {
+      book.withSheet("Sheet2") {sheet => sheet must notBeNull }
+      book.withSheet(10) {sheet => ; } must throwException(new IndexOutOfBoundsException)
+
+      book.eachSheets(1 to 3) {sheet => sheet must notBeNull}
+      book.eachSheets(1,10) {sheet => ; } must throwException(new IndexOutOfBoundsException)
+
+      book.eachSheetsWithIndex(1 to 3) {(sheet, idx) => sheet must notBeNull}
+      book.eachSheetsWithIndex(1,10) {(sheet, idx) => ; } must throwException(new IndexOutOfBoundsException)
+
+      book.each {sheet => sheet must notBeNull}
+    }
+
+    "read null cell" in {
+      sheet1.cell(100,100) must throwException(new NoSuchElementException)
+
+      sheet1.row(100) must notBeNull
+      sheet1.col(100) must notBeNull
+
+      sheet1.row(100).col(100) must throwException(new NoSuchElementException)
+      sheet1.col(100).row(100) must throwException(new NoSuchElementException)
+    }
+    
+    "get cell" in {     
+      sheet1.cell(1,1).value must is_==(1.0)
+      sheet1.col(1).row(1).value must is_==(1.0)
+      sheet1.row(1).col(1).value must is_==(1.0)
+    }
 
     "new Book" in {
@@ -16 +67 @@
       val bk = new Book
       bk.createSheet("test")
-      bk.getSheet(0) must notBeNull
-      bk.getSheet("hoge") must notBeNull
+      bk.sheet(1) must notBeNull
+      bk.sheet("hoge") must throwException(new NoSuchElementException)
     }