Bring Layer and Workspace up to the new style

dwins · dwins · commit deacd6d503aa · 2013-03-02T21:51:59.000-05:00
diff --git a/geoscript/src/main/scala/layer/Layer.scala b/geoscript/src/main/scala/layer/Layer.scala
@@ -2,16 +2,13 @@ package org.geoscript
 
 import java.io.File
 
-// import org.opengis.feature.simple.{ SimpleFeature, SimpleFeatureType }
-// import org.opengis.feature.`type`.{ AttributeDescriptor, GeometryDescriptor }
-import org.{ geotools => gt }
 import com.vividsolutions.jts.{ geom => jts }
 
 import org.geoscript.feature._
 import org.geoscript.filter._
 import org.geoscript.geometry._
 import org.geoscript.projection._
-import org.geoscript.workspace.{Directory,Workspace}
+import org.geoscript.workspace._
 
 package object layer {
   type Layer = org.geotools.data.FeatureSource[Schema, Feature]
@@ -36,23 +33,33 @@ package object layer {
      * operations.
      */
     def features: FeatureCollection =
-      source.getFeatures(new gt.data.Query)
+      source.getFeatures(new org.geotools.data.Query)
     
     /** 
      * Get a filtered feature collection.
      */
     def filter(pred: Filter): FeatureCollection =
-      source.getFeatures(new gt.data.Query(name, pred))
+      source.getFeatures(new org.geotools.data.Query(name, pred))
 
     /**
      * Get the number of features currently in the layer.
      */
-    def count: Int = source.getCount(new gt.data.Query())
+    def count: Int = source.getCount(new org.geotools.data.Query())
 
     /**
      * Get the bounding box of this Layer, in the format:
      */
     def envelope: Envelope = source.getBounds() // in schema.geometry.projection
+
+    /**
+     * Test whether the data source supports modifications and return a
+     * WritableLayer if so.  Otherwise, a None is returned.
+     */
+    def writable: Option[WritableLayer] =
+      source match {
+        case (writable: WritableLayer) => Some(writable)
+        case _ => None
+      }
   }
 
   implicit class RichWritableLayer(val store: WritableLayer) extends AnyVal {
@@ -69,7 +76,7 @@ package object layer {
      * repeated use of += when adding multiple features.
      */
     def ++= (features: Traversable[Feature]) {
-      val tx = new gt.data.DefaultTransaction
+      val tx = new org.geotools.data.DefaultTransaction
       val writer = dstore.getFeatureWriterAppend(store.name, tx)
 
       try {
@@ -107,7 +114,7 @@ package object layer {
     }
 
     def update(filter: Filter)(replace: Feature => Unit) {
-      val tx = new gt.data.DefaultTransaction
+      val tx = new org.geotools.data.DefaultTransaction
       val writer = filter match {
         case Include => dstore.getFeatureWriter(store.name, tx)
         case filter => dstore.getFeatureWriter(store.name, filter, tx)
diff --git a/geoscript/src/main/scala/workspace/Workspace.scala b/geoscript/src/main/scala/workspace/Workspace.scala
@@ -1,104 +1,88 @@
-package org.geoscript.workspace
+package org.geoscript
 
 import java.io.{File, Serializable}
 import org.geoscript.feature._
 import org.geoscript.layer._
 import org.{geotools => gt}
 import scala.collection.JavaConversions._
 
-class Workspace(
-  val underlying: gt.data.DataStore,
-  val params: java.util.HashMap[String, java.io.Serializable]
-) {
-  def count = underlying.getTypeNames.length
-  def names: Seq[String] = underlying.getTypeNames
-  def layer(theName: String): Layer = underlying.getFeatureSource(theName)
+package object workspace {
+  type Workspace = org.geotools.data.DataStore
 
-  def create(name: String, fields: Field*): Layer = create(name, fields) 
+  implicit class RichWorkspace(val workspace: Workspace) {
+    def count = workspace.getTypeNames.length
+    def names: Seq[String] = workspace.getTypeNames
+    def layer(theName: String): Layer = workspace.getFeatureSource(theName)
 
-  def create(name: String, fields: Traversable[Field]): Layer = {
-    val builder = new gt.feature.simple.SimpleFeatureTypeBuilder
-    builder.setName(name)
-    fields foreach {
-      case field: GeoField =>
-        builder.crs(field.projection)
-        builder.add(field.name, field.binding)
-      case field =>
-        builder.add(field.name, field.binding)
+    def create(name: String, fields: Field*): Layer = create(name, fields) 
+
+    def create(name: String, fields: Traversable[Field]): Layer = {
+      val builder = new gt.feature.simple.SimpleFeatureTypeBuilder
+      builder.setName(name)
+      fields foreach {
+        case field: GeoField =>
+          builder.crs(field.projection)
+          builder.add(field.name, field.binding)
+        case field =>
+          builder.add(field.name, field.binding)
+      }
+      workspace.createSchema(builder.buildFeatureType())
+      layer(name)
     }
-    underlying.createSchema(builder.buildFeatureType())
-    layer(name)
+     
+    def create(schema: Schema): Layer = create(schema.name, schema.fields: _*)
   }
-   
-  def create(schema: Schema): Layer = create(schema.name, schema.fields: _*)
-  override def toString = "<Workspace: %s>".format(params)
 }
 
-object Workspace {
-  def apply(params: Pair[String, java.io.Serializable]*): Workspace = {
-    val jparams = new java.util.HashMap[String, java.io.Serializable]()
-    jparams.putAll(params.toMap[String, java.io.Serializable])
-    new Workspace(
-      org.geotools.data.DataStoreFinder.getDataStore(jparams),
-      jparams
-    )
+package workspace {
+  object Memory {
+    def apply() = new org.geotools.data.memory.MemoryDataStore()
   }
-}
 
-object Memory {
-  def apply() = 
-    new Workspace(
-      new gt.data.memory.MemoryDataStore(),
-      new java.util.HashMap
-    )
-}
+  object Postgis {
+    val factory = new gt.data.postgis.PostgisNGDataStoreFactory
+    val create: (java.util.HashMap[_,_]) => gt.data.DataStore = 
+      factory.createDataStore
 
-object Postgis {
-  val factory = new gt.data.postgis.PostgisNGDataStoreFactory
-  val create: (java.util.HashMap[_,_]) => gt.data.DataStore = 
-    factory.createDataStore
-
-  def apply(params: (String,java.io.Serializable)*) = { 
-    val connection = new java.util.HashMap[String,java.io.Serializable] 
-    connection.put("port", "5432")
-    connection.put("host", "localhost")
-    connection.put("user", "postgres")
-    connection.put("passwd","")
-    connection.put("charset","utf-8")
-    connection.put("dbtype", "postgis")
-    for ((key,value) <- params)  { 
-      connection.put(key,value)           
-    }
-    new Workspace(create(connection), connection)
- } 
-}
+    def apply(params: (String,java.io.Serializable)*) = { 
+      val connection = new java.util.HashMap[String,java.io.Serializable] 
+      connection.put("port", "5432")
+      connection.put("host", "localhost")
+      connection.put("user", "postgres")
+      connection.put("passwd","")
+      connection.put("charset","utf-8")
+      connection.put("dbtype", "postgis")
+      for ((key,value) <- params)  { 
+        connection.put(key,value)           
+      }
+      create(connection)
+   } 
+  }
 
-object SpatiaLite {
-  val factory = new gt.data.spatialite.SpatiaLiteDataStoreFactory 
-  private val create: (java.util.HashMap[_,_]) => gt.data.DataStore =
-    factory.createDataStore
+  object SpatiaLite {
+    val factory = new gt.data.spatialite.SpatiaLiteDataStoreFactory 
+    private val create: (java.util.HashMap[_,_]) => gt.data.DataStore =
+      factory.createDataStore
 
-  def apply(params: (String,java.io.Serializable)*) = { 
-    val connection = new java.util.HashMap[String,java.io.Serializable] 
-    connection.put("dbtype","spatialite")
-    for ((key,value) <- params) { 
-      connection.put(key,value)  
-    }
-    new Workspace(create(connection), connection) 
-  } 
-} 
+    def apply(params: (String,java.io.Serializable)*) = { 
+      val connection = new java.util.HashMap[String,java.io.Serializable] 
+      connection.put("dbtype","spatialite")
+      for ((key,value) <- params) { 
+        connection.put(key,value)  
+      }
+      create(connection: java.util.HashMap[_,_])
+    } 
+  }
 
-object Directory {
-  private val factory = new gt.data.shapefile.ShapefileDataStoreFactory
+  object Directory {
+    private val factory = new gt.data.shapefile.ShapefileDataStoreFactory
 
-  def apply(path: String): Workspace = apply(new File(path))
+    def apply(path: String): Workspace = apply(new File(path))
 
-  def apply(path: File): Workspace = {
-    val params = new java.util.HashMap[String, java.io.Serializable]
-    params.put("url", path.toURI.toURL)
-    val store = factory.createDataStore(params: java.util.Map[_, _])
-    new Workspace(store, params) {
-      override def toString = "<Directory: [%s]>".format(params.get("url"))
+    def apply(path: File): Workspace = {
+      val params = new java.util.HashMap[String, java.io.Serializable]
+      params.put("url", path.toURI.toURL)
+      factory.createDataStore(params: java.util.Map[_, _])
     }
   }
 }
