API overhaul

Author: loverdos

Diff for: project/build.properties

@@ -3,7 +3,7 @@
 project.organization=com.ckkloverdos
 project.name=converter
 sbt.version=0.7.7
-project.version=0.3.0
+project.version=0.4.0-SNAPSHOT
 publish.remote=false
 build.scala.versions=2.9.1
 project.initialize=false

Diff for: project/build/Project.scala

@@ -62,7 +62,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.3.0"        % "compile"  withSources()
+  val lib_maybe           = "com.ckkloverdos" %% "maybe"     % "0.4.0-SNAPSHOT"    % "compile"  withSources()
 
   override def repositories =
     if (version.toString.endsWith("-SNAPSHOT")) super.repositories + ScalaToolsSnapshots

Diff for: src/main/scala/com/ckkloverdos/convert/CanConvert.scala

@@ -22,34 +22,6 @@ import com.ckkloverdos.maybe.Maybe
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>.
  */
-trait Converter[S, T] extends CanConvert {
-  def sourceType: Manifest[S]
-  def targetType: Manifest[T]
+trait Converter extends ConverterBase {
   def isStrictSource: Boolean
-
-  /**
-   * 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 apply(sourceValue: S): Maybe[T] = convert(sourceValue)
-  def toFunction: S => Maybe[T] = (s) => convert(s)
-}
-
-/**
- * @author Christos KK Loverdos <loverdos@gmail.com>.
- */
-object Converter {
-  type AnyConverter = Converter[_, _]
-  type AnyManifest  = Manifest[_]
-
-  def newConverter[S: Manifest, T: Manifest](strictSource: Boolean)(f: S => T): Converter[S, T] = {
-    new ConverterImpl(manifest[S], manifest[T], strictSource, f)
-  }
 }
-

Diff for: src/main/scala/com/ckkloverdos/convert/Converter.scala

@@ -0,0 +1,50 @@
+/*
+ * 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
+
+import com.ckkloverdos.maybe.Maybe
+import org.slf4j.LoggerFactory
+
+/**
+ * 
+ * @author Christos KK Loverdos <loverdos@gmail.com>
+ */
+
+trait ConverterBase {
+  protected val logger = LoggerFactory.getLogger(getClass)
+  
+  def canConvertValueToType[S: Manifest, T: Manifest](sourceValue: S): Boolean =
+    canConvertType[S, T]
+
+  def canConvertValueToValue[S: Manifest, T: Manifest](sourceValue: S, targetValue: T): Boolean =
+    canConvertType[S, T]
+
+  def canConvertType[S: Manifest, T: Manifest]: Boolean
+
+  /**
+   * Convert or throw an exception.
+   *
+   * This is a low-level function.
+   */
+  @throws(classOf[ConverterException])
+  def convertEx[T: Manifest](sourceValue: Any): T
+
+  def convert[T: Manifest](sourceValue: Any): Maybe[T] = Maybe {
+//    logger.debug("ConverterBase::convert(%s: %s): %s".format(sourceValue, sourceValue.getClass, manifest[T]))
+    convertEx[T](sourceValue)
+  }
+}

Diff for: src/main/scala/com/ckkloverdos/convert/ConverterBase.scala

@@ -18,50 +18,74 @@ package com.ckkloverdos.convert
 
 import select.ConverterSelectionStrategy
 import com.ckkloverdos.maybe._
+import com.ckkloverdos.manifest.ManifestHelpers
+import org.slf4j.LoggerFactory
 
 /**
  * An immutable registry for converters.
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>.
  */
-class Converters(selector: ConverterSelectionStrategy) extends CanConvert {
-  def canConvertType(sm: Converter.AnyManifest, tm: Converter.AnyManifest) = {
-    selector.find(sm, tm).isJust
-  }
+class Converters(selector: ConverterSelectionStrategy) extends ConverterBase {
+  def canConvertType[S: Manifest, T: Manifest]: Boolean = selector.canConvertType[S, T]
 
-  def findConverter[S, T](sm: Manifest[S], tm: Manifest[T]): Maybe[Converter[S, T]] = {
-    selector.find(sm, tm).asInstanceOf[Maybe[Converter[S, T]]]
+  def findConverter[S : Manifest, T : Manifest]: Maybe[Converter] = {
+    val sm = manifest[S]
+    val tm = manifest[T]
+//    logger.debug("findConverter(%s, %s)".format(sm, tm))
+    selector.find(sm, tm)
   }
 
   /**
    * Converts a value or throws an exception if the value cannot be converted.
    */
   @throws(classOf[ConverterException])
-  def convertValueEx[S: Manifest, T](sourceValue: S, tm: Manifest[T]): T = {
-    val sm = manifest[S]
+  def convertEx[T: Manifest](sourceValue: Any): T = {
+    val sm = ManifestHelpers.manifestOfAny(sourceValue)
+    val tm = manifest[T]
+//    logger.debug("[1] Converters::convertEx(%s: %s)(tm=%s)".format(sourceValue, if(null eq sourceValue.asInstanceOf[AnyRef]) "Null" else sourceValue.getClass, tm))
+//    logger.debug("[2] Converters::convertEx(%s: %s): %s".format(sourceValue, sm, tm))
     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 Just(cv) ⇒
+        try {
+//          logger.debug("Converters::convertEx:: found %s".format(cv))
+          cv.convertEx[T](sourceValue)
+        } catch {
+          case e: Exception =>
+            val errMsg = "Error converting %s -> %s for value %s".format(sm, tm, sourceValue)
+//            logger.error("Converters::convertEx:: " + errMsg)
+            ConverterException(e, errMsg)
+        }
+      case NoVal ⇒
+        val errMsg = "Could not find converter %s -> %s for value %s".format(sm, tm, sourceValue)
+//        logger.error("Converters::convertEx:: " + errMsg)
+        throw new ConverterException(errMsg)
       case Failed(exception, explanation) =>
-        ConverterException(exception, "Error [%s] trying to find converter from %s -> %s for value %s", explanation, sm, tm, sourceValue)
+        val errMsg = "Could not find converter %s -> %s for value %s".format(sm, tm, sourceValue)
+//        logger.error("Converters::convertEx:: " + errMsg)
+        throw new ConverterException(errMsg, exception)
     }
   }
 
-  def convertValue[S: Manifest, T](sourceValue: S, tm: Manifest[T]): Maybe[T] = {
-    findConverter(manifest[S], tm) flatMap (_.convert(sourceValue))
-  }
-
-  def convertValueToByte[S: Manifest](sourceValue: S): Maybe[Byte] = convertValue(sourceValue, Manifest.Byte)
-  def convertValueToShort[S: Manifest](sourceValue: S): Maybe[Short] = convertValue(sourceValue, Manifest.Short)
-  def convertValueToBoolean[S: Manifest](sourceValue: S): Maybe[Boolean] = convertValue(sourceValue, Manifest.Boolean)
-  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 convertValueToFloat[S: Manifest](sourceValue: S): Maybe[Float] = convertValue(sourceValue, Manifest.Float)
-  def convertValueToDouble[S: Manifest](sourceValue: S): Maybe[Double] = convertValue(sourceValue, Manifest.Double)
+  def convertToByte[S: Manifest](sourceValue: S): Maybe[Byte] = convert[Byte](sourceValue)
+  def convertToBoolean[S: Manifest](sourceValue: S): Maybe[Boolean] = convert[Boolean](sourceValue)
+  def convertToShort[S: Manifest](sourceValue: S): Maybe[Short] = convert[Short](sourceValue)
+  def convertToChar[S: Manifest](sourceValue: S): Maybe[Char] = convert[Char](sourceValue)
+  def convertToInt[S: Manifest](sourceValue: S): Maybe[Int] = convert[Int](sourceValue)
+  def convertToLong[S: Manifest](sourceValue: S): Maybe[Long] = convert[Long](sourceValue)
+  def convertToFloat[S: Manifest](sourceValue: S): Maybe[Float] = convert[Float](sourceValue)
+  def convertToDouble[S: Manifest](sourceValue: S): Maybe[Double] = convert[Double](sourceValue)
 }
 
 object Converters {
-  val DefaultConverters = new StdConvertersBuilder().registerDefaultConversions().build
+  final val DefaultConverters = new StdConvertersBuilder().registerDefaultConversions().build
+  
+  final def identityConverter: IdentityConverter.type =
+    IdentityConverter
+  
+  final def justIdentityConverter: Just[IdentityConverter.type] =
+    Just(IdentityConverter)
+
+  final def newSourceTargetConverter[S, T](sm: Manifest[S], tm: Manifest[T], strictSource: Boolean)(f: S => T): SourceTargetConverter[S, T] =
+    new SourceTargetConverter[S, T](sm, tm, strictSource, f)
 }

Diff for: src/main/scala/com/ckkloverdos/convert/ConverterImpl.scala

@@ -17,7 +17,6 @@
 package com.ckkloverdos.convert
 
 import java.util.concurrent.locks.ReentrantLock
-import Converter.{AnyConverter}
 import ConverterHelpers.{lock}
 import org.slf4j.LoggerFactory
 import select.{ConverterSelectionStrategy, CachedMostSpecificTypeFirstSelection}
@@ -32,46 +31,44 @@ import select.{ConverterSelectionStrategy, CachedMostSpecificTypeFirstSelection}
 class ConvertersBuilder {
   protected val logger = LoggerFactory.getLogger(getClass)
   private[this] val _lock = new ReentrantLock()
-  private[this] var _converters: Vector[AnyConverter] = Vector()
+  private[this] var _converters: Vector[Converter] = Vector()
 
-  def registerConverter(converter: AnyConverter): this.type = {
+  def registerConverter(converter: Converter): this.type = {
     lock(_lock) {
       logger.trace("Adding converter %s".format(converter))
       _converters = converter +: _converters
     }
     this
   }
 
-  def +=[S: Manifest, T: Manifest](cw: Converter[S, T]): this.type = {
+  def +=[S: Manifest, T: Manifest](cw: Converter): this.type = {
     this.registerConverter(cw)
   }
 
-  def ++=(cw1: AnyConverter, cw2: AnyConverter, cwSeq: AnyConverter*): this.type = {
+  def ++=(cw1: Converter, cw2: Converter, cwSeq: Converter*): this.type = {
     this += cw1 += cw2
     for(cw <- cwSeq) { this += cw }
     this
   }
 
-  def ++=(cwTrav: Traversable[AnyConverter]): this.type = {
+  def ++=(cwTrav: Traversable[Converter]): this.type = {
     for(cw <- cwTrav) { this += cw }
     this
   }
 
-  def register[S, T](sm: Manifest[S], tm: Manifest[T], ss: Boolean = true)(f: (S) => T): this.type = {
-    implicit val ism = sm
-    implicit val itm = tm
-    this += Converter.newConverter[S, T](ss)(f)
+  def registerST[S, T](sm: Manifest[S], tm: Manifest[T], strictSource: Boolean = true)(f: (S) => T): this.type = {
+    val converter = Converters.newSourceTargetConverter(sm, tm, strictSource)(f)
+    this += converter
     this
   }
 
-  def register[S: Manifest, T: Manifest](ss: Boolean)(f: (S) => T): this.type = {
-    this += Converter.newConverter[S, T](ss)(f)
-    this
+  def register[S: Manifest, T: Manifest](strictSource: Boolean)(f: (S) => T): this.type = {
+    registerST(manifest[S], manifest[T], strictSource)(f)
   }
 
   def build: Converters =
     buildWithStrategy(new CachedMostSpecificTypeFirstSelection(_))
 
-  def buildWithStrategy(f: (Traversable[AnyConverter]) => ConverterSelectionStrategy): Converters =
+  def buildWithStrategy(f: (Traversable[Converter]) => ConverterSelectionStrategy): Converters =
     new Converters(f(_converters))
 }