Add some implicit magic in the serialize package

dwins · dwins · commit ed03aef7dd81 · 2012-07-31T22:00:29.000-04:00
Now client code looks like:

   GeoJSON.read(text)

Instead of:

   GeoJSON.read(Source.string(text))
diff --git a/geoscript/src/main/scala/geometry/io/package.scala b/geoscript/src/main/scala/geometry/io/package.scala
@@ -6,58 +6,44 @@ object WKT extends Format[Geometry] {
   private val reader = new com.vividsolutions.jts.io.WKTReader()
   private val writer = new com.vividsolutions.jts.io.WKTWriter()
  
-  def read(source: Source): Geometry = 
-    source { in =>
-      val chars = new java.io.InputStreamReader(in)
-      val res = reader.read(chars)
-      chars.close()
-
-      res
-    }
-
-  def write[T](geom: Geometry, sink: Sink[T]): T =
-    sink { out =>
-      val chars = new java.io.OutputStreamWriter(out)
-      writer.write(geom, chars)
-      chars.close()
-    }
+  def readFrom(in: java.io.Reader): Geometry = reader.read(in)
+
+  def writeTo(out: java.io.Writer, geom: Geometry) { writer.write(geom, out) }
 }
 
-object WKB extends Format[Geometry] {
+object WKB extends Codec[Geometry] {
   private val reader = new com.vividsolutions.jts.io.WKBReader()
   private val writer = new com.vividsolutions.jts.io.WKBWriter()
  
-  def read(source: Source): Geometry = 
-    source { in =>
-      val s = new com.vividsolutions.jts.io.InputStreamInStream(in)
-      reader.read(s)
-    }
-
-  def write[T](geom: Geometry, sink: Sink[T]): T =
-    sink { out =>
-      val s = new com.vividsolutions.jts.io.OutputStreamOutStream(out)
-      writer.write(geom, s)
-    }
+  def decodeFrom(in: java.io.InputStream): Geometry =
+    reader.read(new com.vividsolutions.jts.io.InputStreamInStream(in))
+
+  def encodeTo(out: java.io.OutputStream, g: Geometry) {
+    writer.write(g, new com.vividsolutions.jts.io.OutputStreamOutStream(out))
+  }
 }
 
 import org.geotools.geojson.geom.GeometryJSON
 class GeoJSON(format: GeometryJSON) extends Format[Geometry] {
   def this(precision: Int) = this(new GeometryJSON(precision))
-  def read(source: Source): Geometry = source { format.read(_) }
-  def write[T](g: Geometry, sink: Sink[T]): T = sink { format.write(g, _) }
+
+  def readFrom(source: java.io.Reader) = format.read(source)
+
+  def writeTo(sink: java.io.Writer, g: Geometry): Unit =
+    format.write(g, sink)
 }
 
 object GeoJSON extends GeoJSON(new GeometryJSON)
 
-import org.geotools.xml.{ Parser, Encoder }
-import org.geotools.gml2
+object GML extends Encoder[Geometry] {
+  import org.geotools.xml.{ Parser, Encoder }
+  import org.geotools.gml2
 
-object GML extends Writer[Geometry] {
-  def write[T](g: Geometry, sink: Sink[T]): T = {
+  def encodeTo(sink: java.io.OutputStream, g: Geometry) {
     val configuration = new gml2.GMLConfiguration
     val encoder = new Encoder(configuration)
     val nsUri = configuration.getNamespaceURI
     val qname = new javax.xml.namespace.QName(nsUri, g.getGeometryType)
-    sink { encoder.encode(g, qname, _) }
+    encoder.encode(g, qname, sink)
   }
 }
diff --git a/geoscript/src/main/scala/serialize/package.scala b/geoscript/src/main/scala/serialize/package.scala
@@ -1,103 +1,152 @@
-package org.geoscript
-package serialize
+package org.geoscript.serialize
 
-import java.io.{ File, InputStream, OutputStream }
+import java.io.File
 
 trait Reader[+T] {
-  def read(source: Source): T
+  def read[U : Readable](source: U): T =
+    implicitly[Readable[U]].read(source)(readFrom(_))
+  def readFrom(source: java.io.Reader): T
 }
 
 trait Writer[-T] {
-  def write[A](t: T, sink: Sink[A]): A
-}
+  def format(t: T): String = write(t, ())(Writable.writeString)
 
-trait Format[T] extends Reader[T] with Writer[T]
+  def write[Spec, Out](t: T, spec: Spec)(implicit writable: Writable[Spec, Out]): Out =
+    implicitly[Writable[Spec, Out]].write(spec)(writeTo(_, t))
 
-trait Sink[T] {
-  def apply(op: OutputStream => Unit): T
+  def writeTo(sink: java.io.Writer, t: T): Unit
 }
 
-object Sink {
-  implicit def stream(out: OutputStream): Sink[Unit] =
-    new Sink[Unit] { 
-      def apply(op: OutputStream => Unit) = op(out)
-    }
+trait Format[T] extends Reader[T] with Writer[T]
 
-  implicit def file(name: String): Sink[File] =
-    file(new java.io.File(name))
+trait Readable[T] {
+  def read[U](t: T)(op: java.io.Reader => U): U
+}
 
-  implicit def file(file: File): Sink[File] =
-    new Sink[java.io.File] { 
-      def apply(op: OutputStream => Unit) = {
-        val output =
-          new java.io.BufferedOutputStream(new java.io.FileOutputStream(file))
-        stream(output)(op)
-        output.close()
+trait Writable[Spec, Out] {
+  def write(spec: Spec)(op: java.io.Writer => Unit): Out
+}
 
-        file
+object Writable {
+  implicit object writeWriter extends Writable[java.io.Writer, Unit] {
+    def write(spec: java.io.Writer)(op: java.io.Writer => Unit): Unit = op(spec)
+  }
+
+  implicit object writeFile extends Writable[File, Unit] {
+    def write(spec: File)(op: java.io.Writer => Unit): Unit = {
+      val writer = new java.io.FileWriter(spec)
+      try 
+        op(writer)
+      finally
+        writer.close()
+    }
+  }
+
+  implicit object writeString extends Writable[Unit, String] {
+    def write(spec: Unit)(op: java.io.Writer => Unit): String = {
+      val writer = new java.io.StringWriter
+      try {
+        op(writer)
+        writer.toString
+      } finally {
+        writer.close()
       }
     }
+  }
+}
 
-  def string: Sink[String] =
-    new Sink[String] { // TODO: Needs better text support
-      def apply(op: OutputStream => Unit) = 
-        buffer(op).view.map(_.toChar).mkString
+object Readable {
+  implicit object readReader extends Readable[java.io.Reader] {
+    def read[T](in: java.io.Reader)(f: java.io.Reader => T): T = f(in)
+  }
+
+  implicit object readFile extends Readable[File] {
+    def read[T](file: File)(f: java.io.Reader => T): T = {
+      val in = new java.io.BufferedReader(new java.io.FileReader(file))
+      try
+        f(in)
+      finally
+        in.close()
     }
-
-  def buffer: Sink[Array[Byte]] =
-    new Sink[Array[Byte]] {
-      def apply(op: OutputStream => Unit) = {
-        val output = new java.io.ByteArrayOutputStream
-        stream(output)(op)
-        output.close()
-        output.toByteArray
-      }
+  }
+
+  implicit object readString extends Readable[String] {
+    def read[T](s: String)(f: java.io.Reader => T): T = {
+      val in = new java.io.StringReader(s)
+      try
+        f(in)
+      finally
+        in.close()
     }
+  }
 }
 
-trait Source {
-  def apply[T](op: InputStream => T): T
+trait Decoder[+T] {
+  def decode[U : Decodable](source: U): T =
+    implicitly[Decodable[U]].decode(source)(decodeFrom(_))
+  def decodeFrom(source: java.io.InputStream): T
 }
 
-object Source {
-  implicit def stream(in: InputStream): Source =
-    new Source { 
-      def apply[T](op: InputStream => T): T = op(in)
-    }
+trait Encoder[-T] {
+  def buffer(t: T): Array[Byte] = encode(t, ())(Encodable.encodeBytes)
 
-  implicit def file(name: String): Source =
-    file(new java.io.File(name))
+  def format(t: T): String = new String(buffer(t))
 
-  implicit def file(file: File): Source =
-    new Source { 
-      def apply[T](op: InputStream => T): T = {
-        val input =
-          new java.io.BufferedInputStream(new java.io.FileInputStream(file))
-        val res = stream(input)(op)
-        input.close()
+  def encode[Spec, Out](t: T, spec: Spec)(implicit encodable: Encodable[Spec, Out]): Out =
+    implicitly[Encodable[Spec, Out]].encode(spec)(encodeTo(_, t))
 
-        res
-      }
-    }
+  def encodeTo(sink: java.io.OutputStream, t: T): Unit
+}
 
-  def string(data: String): Source =
-    new Source {
-      def apply[T](op: InputStream => T): T = {
-        val input = new java.io.ByteArrayInputStream(data.getBytes())
-        val res = stream(input)(op)
-        input.close()
-        res
-      }
-    }
+trait Codec[T] extends Encoder[T] with Decoder[T]
 
-  def buffer(data: Array[Byte]): Source =
-    new Source {
-      def apply[T](op: InputStream => T): T = {
-        val input = new java.io.ByteArrayInputStream(data)
-        val res = stream(input)(op)
-        input.close()
+trait Decodable[T] {
+  def decode[U](t: T)(op: java.io.InputStream => U): U
+}
 
-        res
-      }
+trait Encodable[Spec, Out] {
+  def encode(spec: Spec)(op: java.io.OutputStream => Unit): Out
+}
+
+object Encodable {
+  implicit object encodeOutputStream extends Encodable[java.io.OutputStream, Unit] {
+    def encode(spec: java.io.OutputStream)(op: java.io.OutputStream => Unit): Unit = op(spec)
+  }
+
+  implicit object encodeBytes extends Encodable[Unit, Array[Byte]] {
+    def encode(spec: Unit)(op: java.io.OutputStream => Unit): Array[Byte] = {
+      val buff = new java.io.ByteArrayOutputStream
+      try {
+        op(buff)
+        buff.toByteArray
+      } finally
+        buff.close()
+    }
+  }
+}
+
+object Decodable {
+  implicit object decodeDecoder extends Decodable[java.io.InputStream] {
+    def decode[T](in: java.io.InputStream)(f: java.io.InputStream => T): T = f(in)
+  }
+
+  implicit object decodeFile extends Decodable[File] {
+    def decode[T](file: File)(f: java.io.InputStream => T): T = {
+      val in = new java.io.BufferedInputStream(new java.io.FileInputStream(file))
+      try
+        f(in)
+      finally
+        in.close()
+    }
+  }
+
+  implicit object decodeString extends Decodable[Array[Byte]] {
+    def decode[T](bs: Array[Byte])(f: java.io.InputStream => T): T = {
+      val in = new java.io.ByteArrayInputStream(bs)
+      try
+        f(in)
+      finally
+        in.close()
     }
+  }
 }
diff --git a/geoscript/src/test/scala/org/geoscript/geometry/SerializationSpec.scala b/geoscript/src/test/scala/org/geoscript/geometry/SerializationSpec.scala
@@ -1,22 +1,21 @@
 package org.geoscript
 package geometry
 
-import org.geoscript.serialize.{ Sink, Source }
 import org.scalatest._, matchers._
 
 class SerializationSpec extends FunSuite with ShouldMatchers {
   test("round-trip points") {
     val p = point(100, 0)
-    val json = GeoJSON.write(p, Sink.string)
+    val json = GeoJSON.format(p)
     json should be("""{"type":"Point","coordinates":[100,0.0]}""")
-    GeoJSON.read(Source.string(json)) should be(p)
+    GeoJSON.read(json) should be(p)
     // TODO: Implement equality for geometries
   }
 
   test("round-trip linestrings") {
     val ls = lineString(Seq((100, 0), (101, 1)))
-    GeoJSON.write(ls, Sink.string) should be
-      ("""{"type":"LineString","coordinates":[[100,0.0],[101,1]]}""")
+    GeoJSON.format(ls) should be(
+      """{"type":"LineString","coordinates":[[100,0.0],[101,1]]}""")
   }
 
   test("round-trip polygons") {
@@ -31,15 +30,15 @@ class SerializationSpec extends FunSuite with ShouldMatchers {
       )
     )
 
-    GeoJSON.write(solid, Sink.string) should be(
+    GeoJSON.format(solid) should be(
       """{"type":"Polygon","coordinates":[[[100,0.0],[101,0.0],[101,1],[100,1],[100,0.0]]]}""")
-    GeoJSON.write(withHoles, Sink.string) should be(
+    GeoJSON.format(withHoles) should be(
       """{"type":"Polygon","coordinates":[[[100,0.0],[101,0.0],[101,1],[100,1],[100,0.0]],[[100.2,0.2],[100.8,0.2],[100.8,0.8],[100.2,0.8],[100.2,0.2]]]}""")
   }
 
   test("round-trip a multipoint") {
     val mp = multiPoint(Seq((100.0, 0.0), (101.0, 1.0)))
-    GeoJSON.write(mp, Sink.string) should be(
+    GeoJSON.format(mp) should be(
       """{"type":"MultiPoint","coordinates":[[100,0.0],[101,1]]}""")
   }
 
@@ -49,7 +48,7 @@ class SerializationSpec extends FunSuite with ShouldMatchers {
       Seq((102, 2), (103, 3))
     ))
 
-    GeoJSON.write(mls, Sink.string) should be(
+    GeoJSON.format(mls) should be(
     """{"type":"MultiLineString","coordinates":[[[100,0.0],[101,1]],[[102,2],[103,3]]]}""")
   }
 
@@ -59,13 +58,18 @@ class SerializationSpec extends FunSuite with ShouldMatchers {
       (Seq((100, 0), (101, 0), (101, 1), (100, 1), (100, 0)),
         Seq(Seq((100.2, 0.2), (100.8, 0.2), (100.8, 0.8), (100.2, 0.8), (100.2, 0.2))))))
 
-    GeoJSON.write(mp, Sink.string) should be(
+    GeoJSON.format(mp) should be(
       """{"type":"MultiPolygon","coordinates":[[[[102,2],[103,2],[103,3],[102,3],[102,2]]],[[[100,0.0],[101,0.0],[101,1],[100,1],[100,0.0]],[[100.2,0.2],[100.8,0.2],[100.8,0.8],[100.2,0.8],[100.2,0.2]]]]}""")
   }
 
   test("round-trip a GeometryCollection") {
     val gc = multi(Seq(point(100, 0), lineString(Seq((101, 0), (102, 1)))))
-    GeoJSON.write(gc, Sink.string) should be(
+    GeoJSON.format(gc) should be(
       """{"type":"GeometryCollection","geometries":[{"type":"Point","coordinates":[100,0.0]},{"type":"LineString","coordinates":[[101,0.0],[102,1]]}]}""")
   }
+
+  test("We should be able to stream JSON straight to a file") {
+    val p = point(1, 2)
+    GeoJSON.write(p, new java.io.File("/home/dwins/Blub.json"))
+  }
 }
diff --git a/geoscript/src/test/scala/tutorial/BasicGeometry.scala b/geoscript/src/test/scala/tutorial/BasicGeometry.scala
@@ -52,11 +52,10 @@ object BasicGeometry extends App {
   line.buffer(1)
 
   // serialization
-  import org.geoscript.serialize.{ Sink, Source }
-  geometry.WKT.write(point, Sink.string)
-  geometry.GeoJSON.write(point, Sink.string)
+  geometry.WKT.format(point)
+  geometry.GeoJSON.format(point)
 
   // deserialization
-  geometry.WKT.read(Source.string("POINT (30 10)"))
-  geometry.GeoJSON.read(Source.string("POINT (30 10)"))
+  geometry.WKT.read("POINT (30 10)")
+  geometry.GeoJSON.read("POINT (30 10)")
 }
