Implement converter selection via strategies and provide one such strategy as the default

Author: loverdos

project/build.properties

@@ -18,7 +18,7 @@
 project.organization=com.ckkloverdos
 project.name=converter
 sbt.version=0.7.7
-project.version=0.1.0
-build.scala.versions=2.9.1 2.8.2
+project.version=0.2.0
+build.scala.versions=2.9.1
 project.initialize=false
 publish.remote=false

project/build/Project.scala

@@ -61,9 +61,7 @@ class Project(info: ProjectInfo) extends DefaultProject(info) {
   val lib_slf4j           = "org.slf4j"       % "slf4j-api"       % "1.6.1"        % "compile"  withSources()
   val lib_logback_simple  = "ch.qos.logback"  % "logback-classic" % "0.9.28"       % "test"     withSources()
   val lib_junit_interface = "com.novocode"    % "junit-interface" % "0.7"          % "test"
-  val lib_maybe           = "com.ckkloverdos" %% "maybe"     % "0.1.0"        % "compile"  withSources()
-  val lib_sysprop         = "com.ckkloverdos" %% "sysprop"   % "0.1.0"        % "compile"  withSources()
-  val lib_typedkey        = "com.ckkloverdos" %% "typedkey"  % "0.1.0"        % "compile"  withSources()
+  val lib_maybe           = "com.ckkloverdos" %% "maybe"     % "0.2.1"        % "compile"  withSources()
 
   override def repositories =
     if (version.toString.endsWith("-SNAPSHOT")) super.repositories + ScalaToolsSnapshots

src/main/scala/com/ckkloverdos/convert/Converter.scala

@@ -25,11 +25,20 @@ import com.ckkloverdos.maybe.Maybe
 trait Converter[S, T] extends CanConvert {
   def sourceType: Manifest[S]
   def targetType: Manifest[T]
+  def isStrictSource: Boolean
 
-  def convert(sourceValue: S): Maybe[T]
-  def apply(sourceValue: S): Maybe[T] = convert(sourceValue)
+  /**
+   * Convert or throw an exception.
+   *
+   * This is a low-level function.
+   */
+  @throws(classOf[ConverterException])
+  def convertEx(sourceValue: S): T
+
+  def convert(sourceValue: S): Maybe[T] = Maybe(convertEx(sourceValue))
 
-  def toFunction: Function1[S,  Maybe[T]] = (s) => convert(s)
+  def apply(sourceValue: S): Maybe[T] = convert(sourceValue)
+  def toFunction: S => Maybe[T] = (s) => convert(s)
 }
 
 /**

src/main/scala/com/ckkloverdos/convert/ConverterException.scala

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2011 Christos KK Loverdos
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ckkloverdos.convert
+
+/**
+ * 
+ * @author Christos KK Loverdos <loverdos@gmail.com>.
+ */
+final class ConverterException(cause: Throwable, msg: String, args: Any*) extends Exception(msg.format(args: _*)) {
+  def this(msg: String, args: Any*) = this(null: Throwable, msg, args: _*)
+}
+
+
+/**
+ *
+ * @author Christos KK Loverdos <loverdos@gmail.com>.
+ */
+object ConverterException {
+  def apply(msg: String, args: Any*): Nothing = throw new ConverterException(msg, args: _*)
+  def apply(cause: Throwable, msg: String, args: Any*): Nothing = throw new ConverterException(msg, args: _*)
+}

src/main/scala/com/ckkloverdos/convert/ConverterImpl.scala

@@ -16,8 +16,6 @@
 
 package com.ckkloverdos.convert
 
-import com.ckkloverdos.maybe.Maybe
-import com.ckkloverdos.maybe.Maybe._
 import Converter.{AnyManifest}
 /**
  * 
@@ -26,12 +24,12 @@ import Converter.{AnyManifest}
 class ConverterImpl[S: Manifest, T: Manifest](
     val sourceType: Manifest[S],
     val targetType: Manifest[T],
-    val strictSource: Boolean,
+    val isStrictSource: Boolean,
     val function: S => T)
   extends Converter[S, T] {
 
   def canConvertType(sm: AnyManifest, tm: AnyManifest) = {
-    if(strictSource)
+    if(isStrictSource)
       canConvertStrictSource(sm, tm)
     else
       canConvertNonStrictSource(sm, tm)
@@ -51,8 +49,8 @@ class ConverterImpl[S: Manifest, T: Manifest](
     sourceType.erasure.isAssignableFrom(from) && targetType.erasure.equals(to)
   }
 
-  def convert(sourceValue: S): Maybe[T] = Maybe(function(sourceValue))
+  def convertEx(sourceValue: S) = function(sourceValue)
 
   override def toString() =
-    "Converter(" + List(sourceType, targetType, strictSource, function).mkString(",") + ")"
+    "Converter(" + List(sourceType, targetType, isStrictSource, function).mkString(",") + ")"
 }

src/main/scala/com/ckkloverdos/convert/Converters.scala

@@ -16,21 +16,46 @@
 
 package com.ckkloverdos.convert
 
-import com.ckkloverdos.maybe.Maybe
 import Converter.AnyConverter
+import select.ConverterSelectionStrategy
+import com.ckkloverdos.maybe._
 
 /**
  * An immutable registry for converters.
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>.
  */
-trait Converters extends CanConvert {
-  def converters: Vector[AnyConverter]
+class Converters(selector: ConverterSelectionStrategy) extends CanConvert {
+  def canConvertType(sm: Converter.AnyManifest, tm: Converter.AnyManifest) = {
+    selector.find(sm, tm).isJust
+  }
 
-  def converterFor[S: Manifest, T: Manifest](sm: Manifest[S], tm: Manifest[T], cacheResult: Boolean = true): Maybe[Converter[S, T]]
+  def findConverter[S: Manifest, T: Manifest](sm: Manifest[S], tm: Manifest[T]): Maybe[Converter[S, T]] = {
+    selector.find(sm, tm).asInstanceOf[Maybe[Converter[S, T]]]
+  }
+
+  /**
+   * Converts a value or throws an exception if the value cannot be converted.
+   */
+  @throws(classOf[ConverterException])
+  def convertValueEx[S: Manifest, T: Manifest](sourceValue: S, tm: Manifest[T]): T = {
+    val sm = manifest[S]
+    findConverter(sm, tm) match {
+      case Just(cv) =>
+        cv.convertEx(sourceValue)
+      case NoVal =>
+        ConverterException("Could not find converter from %s -> %s for value %s", sm, tm, sourceValue)
+      case Failed(exception, explanation) =>
+        ConverterException(exception, "Error [%s] trying to find converter from %s -> %s for value %s", explanation, sm, tm, sourceValue)
+    }
+  }
 
   def convertValue[S: Manifest, T: Manifest](sourceValue: S, tm: Manifest[T]): Maybe[T] = {
-    (for(converter <- converterFor(manifest[S], tm))
+    (for(converter <- findConverter(manifest[S], tm))
        yield converter.convert(sourceValue)).flatten1
   }
+
+  def convertValueToInt[S: Manifest](sourceValue: S): Maybe[Int] = convertValue(sourceValue, Manifest.Int)
+  def convertValueToLong[S: Manifest](sourceValue: S): Maybe[Long] = convertValue(sourceValue, Manifest.Long)
+  def convertValueToBoolean[S: Manifest](sourceValue: S): Maybe[Boolean] = convertValue(sourceValue, Manifest.Boolean)
 }

src/main/scala/com/ckkloverdos/convert/ConvertersBuilder.scala

@@ -17,9 +17,10 @@
 package com.ckkloverdos.convert
 
 import java.util.concurrent.locks.ReentrantLock
-import Converter.{AnyConverter, AnyManifest}
+import Converter.{AnyConverter}
 import ConverterHelpers.{lock}
 import org.slf4j.LoggerFactory
+import select.{ConverterSelectionStrategy, CachedMostSpecificTypeFirstSelection}
 
 /**
  * A builder for converter registries.
@@ -66,5 +67,9 @@ class ConvertersBuilder {
     this
   }
 
-  def build: Converters = new ConvertersImpl(_converters)
+  def build: Converters =
+    buildWithStrategy(new CachedMostSpecificTypeFirstSelection(_))
+
+  def buildWithStrategy(f: (Traversable[AnyConverter]) => ConverterSelectionStrategy): Converters =
+    new Converters(f(_converters))
 }

src/main/scala/com/ckkloverdos/convert/ConvertersImpl.scala

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2011 Christos KK Loverdos
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ckkloverdos.convert
+package select
+
+import com.ckkloverdos.convert.Converter._
+import java.util.concurrent.locks.ReentrantLock
+import com.ckkloverdos.convert.ConverterHelpers._
+import com.ckkloverdos.maybe.{NoVal, Maybe, Just}
+
+/**
+ *
+ * @author Christos KK Loverdos <loverdos@gmail.com>.
+ */
+final class CachedMostSpecificTypeFirstSelection(converters: Traversable[AnyConverter]) extends ConverterSelectionStrategy {
+  private[this] val _lock = new ReentrantLock()
+  private[this] val (_strictSourceConverters, _nonStrictSourceConverters) = converters.map(Just(_)).partition(_.get.isStrictSource)
+  private[this] var _cache: Map[(AnyManifest, AnyManifest), Just[AnyConverter]] = Map()
+
+  def isCaching = true
+
+  def addToCache(sm: AnyManifest, tm: AnyManifest, cv: AnyConverter) = {
+    lock(_lock) {
+      _cache += ((sm, tm) -> Just(cv))
+    }
+  }
+
+  override def findCached(sm: Converter.AnyManifest, tm: Converter.AnyManifest) = {
+    _cache.get((sm, tm)) match {
+      case Some(jcv) =>
+        jcv
+      case None =>
+        NoVal
+    }
+  }
+
+  def findNonCached(sm: AnyManifest, tm: AnyManifest): Maybe[AnyConverter] = {
+    _strictSourceConverters.find(_.get.canConvertType(sm, tm)) match {
+      case Some(jcv) =>
+        jcv
+      case None =>
+        _nonStrictSourceConverters.find(_.get.canConvertType(sm, tm)) match {
+          case Some(jcv) =>
+            jcv
+          case None =>
+            NoVal
+        }
+    }
+  }
+}