Refactor, version bumps

Author: loverdos

pom.xml

@@ -68,7 +68,7 @@
   </issueManagement>
 
   <properties>
-    <scala.version>2.10.3</scala.version>
+    <scala.version>2.10.4</scala.version>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <project.reporting.outputEncoding>${project.build.sourceEncoding}</project.reporting.outputEncoding>
   </properties>
@@ -128,7 +128,7 @@
       <plugin>
         <groupId>net.alchim31.maven</groupId>
         <artifactId>scala-maven-plugin</artifactId>
-          <version>3.1.6</version>
+          <version>3.2.0</version>
         <configuration>
           <recompileMode>incremental</recompileMode>
           <scalaVersion>${scala.version}</scalaVersion>

project/build.properties

@@ -21,7 +21,6 @@ package typedkey
  * @author Christos KK Loverdos <loverdos@gmail.com>
  */
 final class KeyType(val tpe: AnyRef, val tpeName: CharSequence) extends Ordered[KeyType] {
-
   if(tpe == null) {
     throw new IllegalArgumentException("null type")
   }
@@ -36,8 +35,6 @@ final class KeyType(val tpe: AnyRef, val tpeName: CharSequence) extends Ordered[
 
   override def equals(o: Any) =
     o match {
-      case null ⇒
-        false
       case that: KeyType ⇒
         this.tpe == that.tpe && this.tpeName == that.tpeName
       case _ ⇒

project/build/Project.scala

@@ -23,7 +23,21 @@ package typedkey
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>.
  */
-trait TKey[T] extends Ordered[TKey[_]]{
+trait TKey[T] extends Ordered[TKey[_]] {
   def name: String
   def keyType: KeyType
+
+  override def hashCode = 31 * name.## + keyType.##
+
+  override def equals(obj: Any) = obj match {
+    case that: TKey[_] ⇒
+      this.name == that.name && this.keyType == that.keyType
+    case _ ⇒ false
+  }
+
+  def compare(that: TKey[_]) = this.name compareTo that.name
+}
+
+object TKey {
+  def ofString(name: String)
 }

src/main/scala/typedkey/KeyType.scala

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package typedkey;
+package typedkey
 
 /**
  * A marker interface for type providers.
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>
  */
-public interface TypeProvider {
-}
+trait TypeProvider

src/main/scala/typedkey/TKey.scala

@@ -19,6 +19,7 @@ package typedkey.env
 import typedkey.{TKey, KeyType}
 
 /**
+ * An environment of [[typedkey.TKey]]s.
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>
  */
@@ -57,13 +58,20 @@ trait Env {
 
   def toJavaMapByName(fillMe: java.util.Map[String, AnyRef]): java.util.Map[String, AnyRef]
 
-  def +[T](key: TKey[T], value: T): Env
+  def toImmutable: immutable.Env
 
-  def -[T](key: TKey[T]): Env
+  def toMutable: mutable.Env
 
   def ++(other: Env): Env
 
   def getRemove[T](key: TKey[T]): (Option[TKey[T]], Env)
 
   def keysOfType(keyType: KeyType): scala.collection.Set[TKey[_]]
+
+  def update[T](key: TKey[T], value: T): Env
+
+  def delete[T](key: TKey[T]): Env
+
+  def +[T](key: TKey[T], value: T): Env = update(key, value)
+  def -[T](key: TKey[T]): Env = delete(key)
 }

src/main/scala/typedkey/TKeyImpl.scala

@@ -18,21 +18,31 @@ package typedkey.env
 package immutable
 
 import scala.collection.immutable.Map
-import typedkey.TKey
+import typedkey.{env, TKey}
 import typedkey.env.impl.MapBasedEnv
 
-final class Env private[env](
-  private[env] val map: Map[TKey[_], Any]
-) extends MapBasedEnv[Env, Map[TKey[_], Any]](map) {
-
+final class Env(private[this] val map: Map[TKey[_], Any]) extends MapBasedEnv[Env, Map[TKey[_], Any]](map) {
   protected def newEnv(map: Map[TKey[_], Any]) = new Env(map)
 
   protected def newMap(elems: (TKey[_], Any)*) = Map(elems: _*)
+
+  def toImmutable: Env = this
+
+  def toMutable: mutable.Env = new mutable.Env(scala.collection.mutable.Map() ++= map)
+
+  def update[T](key: TKey[T], value: T) = {
+    val newMap = map.updated(key, value)
+    new Env(newMap)
+  }
+
+  def delete[T](key: TKey[T]) =
+    if(contains(key)) newEnv(map - key)
+    else this
 }
 
 object Env {
   def apply(): Env = new Env(Map())
 
-  def apply(env: Env): Env = new Env(Map() ++ env.map)
+  def ofOne[T](key: TKey[T], value: T): Env = new Env(Map(key → value))
 }
 

src/main/scala/typedkey/TypeProvider.java src/main/scala/typedkey/TypeProvider.scala

@@ -16,17 +16,14 @@
 
 package typedkey.env.impl
 
-import typedkey.env.Env
-import typedkey.{TKey, KeyType}
+import typedkey.env.{immutable, mutable, Env}
+import typedkey.{env, KeyType, TKey}
 
 /**
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>
  */
-abstract class MapBasedEnv[E <: Env, Map <: scala.collection.Map[TKey[_], Any]](
-  map: Map
-) extends Env {
-
+abstract class MapBasedEnv[E <: Env, Map <: scala.collection.Map[TKey[_], Any]](map: Map) extends Env {
   protected def newEnv(map: Map): E
 
   protected def newMap(elems: (TKey[_], Any)*): Map
@@ -60,7 +57,7 @@ abstract class MapBasedEnv[E <: Env, Map <: scala.collection.Map[TKey[_], Any]](
 
   def keysOfName(keyName: String) =
     for {
-      typedKey <- map.keySet if typedKey.name == keyName
+      typedKey ← map.keySet if typedKey.name == keyName
     } yield {
       typedKey
     }
@@ -79,10 +76,6 @@ abstract class MapBasedEnv[E <: Env, Map <: scala.collection.Map[TKey[_], Any]](
         (None, this)
     }
 
-  def -[T](key: TKey[T]) = newEnv((map - key).asInstanceOf[Map])
-
-  def +[T](key: TKey[T], value: T) = newEnv((map + (key -> value)).asInstanceOf[Map])
-
   def ++(other: typedkey.env.Env) = newEnv((map ++ other.toMap).asInstanceOf[Map])
 
   def keysOfType(keyType: KeyType): scala.collection.Set[TKey[_]] =
@@ -101,12 +94,26 @@ abstract class MapBasedEnv[E <: Env, Map <: scala.collection.Map[TKey[_], Any]](
     fillMe
   }
 
-  def valuesOfKeysByName(keyName: String) = {
+  def valuesOfKeysByName(keyName: String): Seq[Any] = {
     val buf = new scala.collection.mutable.ListBuffer[Any]
     val keys = keysOfName(keyName)
     for(key ← keys) {
       buf += map(key)
     }
     buf.toList
   }
+
+  def toString(separator: String = ", ") = {
+    val formattedPairs = map.map {
+      case (key, null) ⇒
+        s"${key.name}: null [${key.keyType.tpeName}]"
+
+      case (key, value) ⇒
+        s"${key.name}: $value [${key.keyType.tpeName}]"
+    }
+
+    val pairStr = formattedPairs.mkString(separator)
+
+    s"Env($pairStr)"
+  }
 }