Changeset 7415 for lang/scala

Timestamp:

03/03/08 21:40:54 (9 months ago)

Author:

ryugate

Message:

POI,Format,Http:改行コードの修正
Timecode:前面改定

Location:

lang/scala/sandbox/src/jp/ryugate

Files:

• apache/POI.scala (modified) (6 diffs)
• apache/POISpecification.scala (modified) (2 diffs)
• net/Http.scala (modified) (4 diffs)
• text/RegexpSpecification.scala (modified) (1 diff)
• video/Timecode.scala (modified) (1 diff)

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

@@ -18 +18 @@
     = n.foldLeft(List[T]()){(acc, i) => f(i) :: acc}.reverse
     
-  private def eachWithIndex[T](lst:List[T], f2:(T,int) => Unit)
+  private def eachWithIndex[T,V](lst:List[T], f2:(T,int) => V)
     = lst.zipWithIndex.foreach{case (row,idx) => f2(row,idx)}
 
@@ -36 +36 @@
     }
 
-    def withSheet(index:int  )(f:Sheet => Unit):Unit = f(sheet(index))
-    def withSheet(name:String)(f:Sheet => Unit):Unit = f(sheet(name))
+    def withSheet[V](index:int  )(f:Sheet => V) = f(sheet(index))
+    def withSheet[V](name:String)(f:Sheet => V) = 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 eachSheets[V](idxs:int*  )(f:Sheet => V) = sheets(idxs:_* ).foreach{f(_)}
+    def eachSheets[V](range:Range)(f:Sheet => V) = 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[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 each(f:Sheet => Unit):Unit = eachSheets(1 to hssf_book.getNumberOfSheets)(f)
+    def each[V](f:Sheet => V) = eachSheets(1 to hssf_book.getNumberOfSheets)(f)
 
     //--------------------------------------------
@@ -65 +65 @@
     def cell(ri:int,ci:int) = row(ri).apply(ci)
 
-    def withRow(ri:int)(f:Row => Unit):Unit = f(row(ri))
-    def withCol(ci:int)(f:Col => Unit):Unit = f(col(ci))
+    def withRow[V](ri:int)(f:Row => V) = f(row(ri))
+    def withCol[V](ci:int)(f:Col => V) = f(col(ci))
 
     def rows(rowIdxs:int*) = makeSomeList(row, rowIdxs:_*)
@@ -73 +73 @@
     def cols(range:Range ) = makeSomeList(col, range:_*)
 
-    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 eachRows[V](rowIdxs:int*)(f:Row => 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 eachCols[V](range:Range )(f:Col => V) = cols(range     ).foreach{f(_)}
 
-    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 eachRowsWithIndex[V](idxs:int*  )(f:(Row,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 eachColsWithIndex[V](range:Range)(f:(Col,int) => V) = eachWithIndex(cols(range:_*), f)
 
-    def each(f:Row => Unit):Unit = eachRows(0 to getLastRowNum)(f)
+    def each[V](f:Row => V) = eachRows(0 to getLastRowNum)(f)
     
     //--------------------------------------------
@@ -115 +115 @@
     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 eachCells[V](idxs:int*  )(f:Cell => V) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells[V](range:Range)(f:Cell => V) = cells(range:_*).foreach{f(_)}
  
-    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 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 each(f:Cell => Unit):Unit = eachCells(0 to hssf_row.getLastCellNum)(f)
+    def each[V](f:Cell => V) = eachCells(0 to hssf_row.getLastCellNum)(f)
 
     //--------------------------------------------
@@ -151 +151 @@
     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 eachCells[V](idxs:int*  )(f:Cell => V) = cells(idxs:_* ).foreach{f(_)}
+    def eachCells[V](range:Range)(f:Cell => V) = cells(range:_*).foreach{f(_)}
  
-    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 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 each(f:Cell => Unit):Unit = eachCells(0 to sheet.getLastRowNum)(f)
+    def each[V](f:Cell => V) = eachCells(0 to sheet.getLastRowNum)(f)
   }
   

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

@@ -3 +3 @@
 import org.specs._
 import org.specs.matcher._
-import org.specs.matcher.AnyMatchers
-import org.specs.matcher.PatternMatchers.CaseMatcher
 
 object POISpecification extends Specification {
@@ -12 +10 @@
 
   "POI module" should {
-    val book = new Book("test.xls")
+    val book = new Book("testdata/test.xls")
     val sheet1 = book.sheet(1)
 

lang/scala/sandbox/src/jp/ryugate/net/Http.scala

@@ +1 @@
+//      if (_proxy != null) {
+//        val proxy_addr = new InetSocketAddress(PROXY_HOST, PROXY_PORT)
+//        val proxy      = new Proxy(Proxy.Type.HTTP, proxy_addr)
+//      }
+
 package jp.ryugate.net
 
@@ -10 +15 @@
     def get(resource:String):String = {
       val url = new URL("http://" + host + resource)
+      val br = new BufferedReader(new InputStreamReader(getInputStream(url)))
+      try {
+        readContents("", (br.readLine _))
+      } finally {
+        br.close
+      }
+    }
+
+    def getInputStream(url: URL) = {
       val con = url.openConnection.asInstanceOf[HttpURLConnection]
       if (_read_timeout > 0) con.setReadTimeout(_read_timeout)
       con.setRequestMethod("GET")
-      val br = new BufferedReader(new InputStreamReader(con.getInputStream))
-      readContents("", (br.readLine _))
+      con.getInputStream
     }
 
-    def readContents(acc:String, reader:()=>String):String = reader() match{
+    def readContents(acc:String, reader:()=>String):String = reader() match {
       case null => acc
       case s => readContents(acc + s, reader)
@@ -23 +36 @@
     
     def read_timeout:int = _read_timeout
-    def read_timeout_=(timeout:int) { _read_timeout = timeout}
+    def read_timeout_=(timeout:int) { _read_timeout = timeout }
+
+//    def proxy_host:String = _proxy_host
+//    def proxy_host_=(proxy_host:String) { _proxy_host = proxy_host }
   }
 
@@ -30 +46 @@
     f(http)
   }
+  
+//  def get(url:String)
 }
   

lang/scala/sandbox/src/jp/ryugate/text/RegexpSpecification.scala

@@ -63 +63 @@
     }
 
-    "=~" in {
-      ("piyohoge" =~ "hoge") must beTrue
+//    "=~" in {
+//      ("piyohoge" =~ "hoge") must beTrue
+//    }
+    
+    "with Pattern match" in {
+      var ans = ""
+      
+      val lst = List("hoge", "piyo", "foo", "hogepiyo")
+      lst.foreach {item =>
+        item match {
+          case s if s =~ "h..e" =>    ans += s
+          case s if s =~ "p[iy]+o" => ans += s
+          case _ => null
+        }
+      }
+      ans must be_==("hogepiyohogepiyo")
     }
+    
   }
 }

lang/scala/sandbox/src/jp/ryugate/video/Timecode.scala

@@ -3 +3 @@
 import jp.ryugate.text.Format
 
-object Timecode {
-  class TimecodeFactory(rate:Any) {
-    def make(hh:int, mm:int, ss:int, ff:int) = rate match {
-      case "ntsc" =>
-        val minutes = hh * 60 + mm
-        new Timecode(17982 * (minutes/10) + 1798 * (minutes%10) + ss * 30 + ff)
-      case r:Int =>
-        val mrate = r * 60
-        val hrate = mrate * 60
-        new Timecode(hh * hrate + mm * mrate + ss * r + ff)
-    }
+class Timecode(val frames:Int, val rate:Any) {
+  def this(hh:Int, mm:Int, ss:Int, ff:Int, rate:Any) = this( rate match {
+    case "ntsc" =>
+      val minutes = hh * 60 + mm
+      17982 * (minutes/10) + 1798 * (minutes%10) + ss * 30 + ff
+    case r:Int =>
+      val mrate = r * 60
+      val hrate = mrate * 60
+      hh * hrate + mm * mrate + ss * r + ff
+  }, rate)
+
+  def changeRate(r:Any) = new Timecode(frames, r)
+
+  override def toString = rate match {
+    case "ntsc" =>
+      val hh = frames / 17982 / 6
+      val mm = frames / 17982 % 6 * 10 + (frames % 17982 - 2) / 1798
+      val ss = ((frames % 17982 - 2) % 1798 + 2) / 30
+      val ff = ((frames % 17982 - 2) % 1798 + 2) % 30
+      sprIntf("%02d:%02d:%02d;%02d", hh,mm,ss,ff)
+    case r:Int =>
+      val m = r * 60
+      val h = m * 60
+      val hh = frames / h
+      val mm = (frames % h) / m
+      val ss = ((frames % h) % m) / r
+      val ff = ((frames % h) % m) % r
+      sprIntf("%02d:%02d:%02d:%02d", hh,mm,ss,ff)
   }
 
-  class Timecode(frames:int) {
-    class Tcode(hh:int, mm:int, ss:int, ff:int) {
-      def hour = hh
-      def minutes = mm
-      def second = ss
-      def frame = ff
-  
-      override def toString() = Format.sprintf("%02d:%02d:%02d.%02d", hh,mm,ss,ff)
-    }
+  def +(add:Int) = new Timecode(frames + add, rate)
+  def -(sub:Int) = new Timecode(frames - sub, rate)
 
-    def ntsc =
-      new Tcode(frames / 17982 / 6,
-                frames / 17982 % 6 * 10 + (frames % 17982 - 2) / 1798,
-                ((frames % 17982 - 2) % 1798 + 2) / 30,
-                ((frames % 17982 - 2) % 1798 + 2) % 30
-              )
+  private def sprIntf(fmt:String, args:Any*) = String.format(fmt, args.map(e => e.asInstanceOf[AnyRef]).toArray)
+}
 
-    def tc:Tcode = tc(30)
-    def tc(rate:int):Tcode = {
-      val m = rate * 60
-      val h = m * 60
-      new Tcode(frames / h,
-                (frames % h) / m,
-                ((frames % h) % m) / rate,
-                ((frames % h) % m) % rate
-              )
-    }
-  }
+object TimecodeTest extends Application {
+  println("DROP")
+  val t1 = new Timecode(0,0,59,27,"ntsc")
+  (1 to 5).foreach {i => println(t1 + i) }
+
+  println("NONDROP")
+  val t2 = t1.changeRate(30)
+  (1 to 5).foreach {i => println(t2 + i) }
+
+  println("DROP 10min")
+  val t4 = new Timecode(0,9,59,27, "ntsc")
+  (1 to 5).foreach {i => println(t4 + i) }
+
+  println("NONDROP 10min")
+  val t3 = new Timecode(0,9,59,27, 30)
+  (1 to 5).foreach {i => println(t3 + i) }
 }