Changeset 7772

Timestamp:

03/10/08 23:51:21 (5 years ago)

Author:

ryugate

Message:

POI: Views化した

Location:

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

Files:

• POI.scala (modified) (9 diffs)
• POISpecification.scala (modified) (4 diffs)

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

@@ -6 +6 @@
 */
 object POI {
-  import java.io.FileInputStream
+
   import java.io.InputStream
 
@@ -24 +24 @@
   * Book 
   */
-  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 sheet(index:int  ) = new Sheet(hssf_book.getSheetAt(index-1))
+  class MyBook(hssf_book:HSSFWorkbook) {
+    def sheet(index:int  ) = 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)
+      case v => v
     }
 
-    def withSheet[V](index:int  )(f:Sheet => V) = f(sheet(index))
-    def withSheet[V](name:String)(f:Sheet => V) = f(sheet(name))
+    def withSheet[V](index:int  )(f:HSSFSheet => V) = f(sheet(index))
+    def withSheet[V](name:String)(f:HSSFSheet => V) = f(sheet(name))
 
-    def sheets(idxs:int*  ) = makeSomeList(sheet, idxs:_*)
-    def sheets(range:Range) = makeSomeList(sheet, range:_*)
+    def getSheets(idxs:int*  ) = makeSomeList(sheet, idxs:_*)
+    def getSheets(range:Range) = makeSomeList(sheet, range:_*)
 
-    def eachSheets[V](idxs:int*  )(f:Sheet => V) = sheets(idxs:_* ).foreach{f(_)}
-    def eachSheets[V](range:Range)(f:Sheet => V) = sheets(range:_*).foreach{f(_)}
+    def eachSheets[V](idxs:int*  )(f:HSSFSheet => V) = getSheets(idxs:_* ).foreach{f(_)}
+    def eachSheets[V](range:Range)(f:HSSFSheet => V) = getSheets(range:_*).foreach{f(_)}
     
-    def eachSheetsWithIndex[V](idxs:int*  )(f:(Sheet,int) => V) = eachWithIndex(sheets(idxs:_*), f)
-    def eachSheetsWithIndex[V](range:Range)(f:(Sheet,int) => V) = eachWithIndex(sheets(range:_*), f)
+    def eachSheetsWithIndex[V](idxs:int*  )(f:(HSSFSheet,int) => V) = eachWithIndex(getSheets(idxs:_*), f)
+    def eachSheetsWithIndex[V](range:Range)(f:(HSSFSheet,int) => V) = eachWithIndex(getSheets(range:_*), f)
 
-    def each[V](f:Sheet => V) = eachSheets(1 to hssf_book.getNumberOfSheets)(f)
-
-    //--------------------------------------------
-    def createSheet()            = new Sheet(hssf_book.createSheet)
-    def createSheet(name:String) = new Sheet(hssf_book.createSheet(name))  
+    def each[V](f:HSSFSheet => V) = eachSheets(1 to hssf_book.getNumberOfSheets)(f)
   }
+  implicit def HSSFWorkbookToExtBook(book:HSSFWorkbook) = new MyBook(book)
 
   /**
   * Sheet 
   */
-  class Sheet(hssf_sheet:HSSFSheet) {
-    def row(ri:int) = new Row(ri, hssf_sheet.getRow(ri-1))
+  class MySheet(hssf_sheet:HSSFSheet) {
+    def row(ri:int) = hssf_sheet.getRow(ri-1)
     def col(ci:int) = new Col(this, ci)
 
@@ -65 +57 @@
     def cell(ri:int,ci:int) = row(ri).apply(ci)
 
-    def withRow[V](ri:int)(f:Row => V) = f(row(ri))
+    def withRow[V](ri:int)(f:HSSFRow => V) = f(row(ri))
     def withCol[V](ci:int)(f:Col => V) = f(col(ci))
 
@@ -73 +65 @@
     def cols(range:Range ) = makeSomeList(col, range:_*)
 
-    def eachRows[V](rowIdxs:int*)(f:Row => V) = rows(rowIdxs:_*).foreach{f(_)}
+    def eachRows[V](rowIdxs:int*)(f:HSSFRow => V) = rows(rowIdxs:_*).foreach{f(_)}
     def eachCols[V](colIdxs:int*)(f:Col => V) = cols(colIdxs:_*).foreach{f(_)}
-    def eachRows[V](range:Range )(f:Row => V) = rows(range     ).foreach{f(_)}
+    def eachRows[V](range:Range )(f:HSSFRow => V) = rows(range     ).foreach{f(_)}
     def eachCols[V](range:Range )(f:Col => V) = cols(range     ).foreach{f(_)}
 
-    def eachRowsWithIndex[V](idxs:int*  )(f:(Row,int) => V) = eachWithIndex(rows(idxs:_*), f)
+    def eachRowsWithIndex[V](idxs:int*  )(f:(HSSFRow,int) => V) = eachWithIndex(rows(idxs:_*), f)
     def eachColsWithIndex[V](idxs:int*  )(f:(Col,int) => V) = eachWithIndex(cols(idxs:_*), f)
-    def eachRowsWithIndex[V](range:Range)(f:(Row,int) => V) = eachWithIndex(rows(range:_*), f)
+    def eachRowsWithIndex[V](range:Range)(f:(HSSFRow,int) => V) = eachWithIndex(rows(range:_*), f)
     def eachColsWithIndex[V](range:Range)(f:(Col,int) => V) = eachWithIndex(cols(range:_*), f)
 
-    def each[V](f:Row => V) = eachRows(0 to getLastRowNum)(f)
+    def each[V](f:HSSFRow => V) = eachRows(0 to getLastRowNum)(f)
     
     //--------------------------------------------
-    def createRow(rownum:int) = new Row(rownum, hssf_sheet.createRow(rownum-1))
+    def createRow(rownum:int) = hssf_sheet.createRow(rownum-1)
     
     def getLastRowNum = hssf_sheet.getLastRowNum
   }
-
+  implicit def HSSFSheetToExtSheet(sheet:HSSFSheet) = new MySheet(sheet)
+  
   /**
   * Row 
   */
-  class Row(ri:int, hssf_row:HSSFRow) {
+  class MyRow(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))
+        case v    => new Some(v)
       }
     }
 
     def apply(cellnum:int) = get(cellnum) match {
-      case None => throw new NoSuchElementException(ri +"," + cellnum + " (Cell not found)")
+      case None => throw new NoSuchElementException(cellnum + " (Cell not found)")
       case Some(v) => v
     }
@@ -115 +108 @@
     def cells(range:Range) = makeSomeList(apply, range:_*)
 
-    def eachCells[V](idxs:int*  )(f:Cell => V) = cells(idxs:_* ).foreach{f(_)}
-    def eachCells[V](range:Range)(f:Cell => V) = cells(range:_*).foreach{f(_)}
+    def eachCells[V](idxs:int*  )(f:HSSFCell => V) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells[V](range:Range)(f:HSSFCell => V) = cells(range:_*).foreach{f(_)}
  
-    def eachCellsWithIndex[V](idxs:int*  )(f:(Cell,int) => V) = eachWithIndex(cells(idxs:_*), f)
-    def eachCellsWithIndex[V](range:Range)(f:(Cell,int) => V) = eachWithIndex(cells(range:_*), f)
+    def eachCellsWithIndex[V](idxs:int*  )(f:(HSSFCell,int) => V) = eachWithIndex(cells(idxs:_*), f)
+    def eachCellsWithIndex[V](range:Range)(f:(HSSFCell,int) => V) = eachWithIndex(cells(range:_*), f)
       
-    def each[V](f:Cell => V) = eachCells(0 to hssf_row.getLastCellNum)(f)
+    def each[V](f:HSSFCell => V) = eachCells(0 to hssf_row.getLastCellNum)(f)
 
     //--------------------------------------------
-    def createCell(cellnum:int) = new Cell(hssf_row.createCell(cellnum.toShort))
+    def createCell(cellnum:int) = hssf_row.createCell(cellnum.toShort)
 
     def setCell(cellnum:int, value:String, encoding:Short):HSSFCell = {
@@ -135 +128 @@
     def setCell(cellnum:int, value:String):HSSFCell = setCell(cellnum, value, ENCODING_UNCHANGED)
   }
-
+  implicit def HSSFRowToExtRow(row:HSSFRow) = new MyRow(row)
+  
   /**
   * Col
   */
-  class Col(sheet:Sheet, colIdx:int) {
+  class Col(sheet:MySheet, colIdx:int) {
     def get(ri:int) = sheet.row(ri).get(colIdx)
 
@@ -151 +145 @@
     def cells(range:Range) = makeSomeList(apply, range:_*)
     
-    def eachCells[V](idxs:int*  )(f:Cell => V) = cells(idxs:_* ).foreach{f(_)}
-    def eachCells[V](range:Range)(f:Cell => V) = cells(range:_*).foreach{f(_)}
+    def eachCells[V](idxs:int*  )(f:HSSFCell => V) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells[V](range:Range)(f:HSSFCell => V) = cells(range:_*).foreach{f(_)}
  
-    def eachCellsWithIndex[V](idxs:int*  )(f:(Cell,int) => V) = eachWithIndex(cells(idxs:_*), f)
-    def eachCellsWithIndex[V](range:Range)(f:(Cell,int) => V) = eachWithIndex(cells(range:_*), f)
+    def eachCellsWithIndex[V](idxs:int*  )(f:(HSSFCell,int) => V) = eachWithIndex(cells(idxs:_*), f)
+    def eachCellsWithIndex[V](range:Range)(f:(HSSFCell,int) => V) = eachWithIndex(cells(range:_*), f)
       
-    def each[V](f:Cell => V) = eachCells(0 to sheet.getLastRowNum)(f)
+    def each[V](f:HSSFCell => V) = eachCells(0 to sheet.getLastRowNum)(f)
   }
   
@@ -163 +157 @@
   * Cell
   */
-  class Cell(hssf_cell:HSSFCell) {
+  class MyCell(hssf_cell:HSSFCell) {
 //    def get = apply match {
 //      case null => None
@@ -180 +174 @@
     def value = apply
   }
+  implicit def HSSFCellToExtCell(cell:HSSFCell) = new MyCell(cell)
 }

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

@@ -6 +6 @@
 object POISpecification extends Specification {
   import jp.ryugate.apache.POI._
-
+  import org.apache.poi.hssf.usermodel.HSSFWorkbook
+  import org.apache.poi.hssf.usermodel.HSSFSheet
+  import org.apache.poi.hssf.usermodel.HSSFRow
+  import org.apache.poi.hssf.usermodel.HSSFCell
+  import org.apache.poi.hssf.usermodel.HSSFCell._
+  
   import java.lang._
-
+  import java.io.FileInputStream
+  
   "POI module" should {
-    val book = new Book("testdata/test.xls")
+    val book = new HSSFWorkbook(new FileInputStream("testdata/test.xls"))
     val sheet1 = book.sheet(1)
 
@@ -24 +30 @@
     
     "get meny sheets" in {
-      book.sheets(1 to 10) must throwException(new IndexOutOfBoundsException)
-      book.sheets(1,10) must throwException(new IndexOutOfBoundsException)
+      book.getSheets(1 to 10) must throwException(new IndexOutOfBoundsException)
+      book.getSheets(1,10) must throwException(new IndexOutOfBoundsException)
     }
     
@@ -44 +50 @@
       sheet1.cell(100,100) must throwException(new NoSuchElementException)
 
-      sheet1.row(100) must notBeNull
+      sheet1.row(100) must beNull
       sheet1.col(100) must notBeNull
 
@@ -57 +63 @@
     }
 
-    "new Book" in {
-      val bk = new Book
-      bk must notBeNull
-    }
-
     "create and get Sheet" in {
-      val bk = new Book
+      val bk = new HSSFWorkbook
       bk.createSheet("test")
       bk.sheet(1) must notBeNull