Adding method return types to Serialization, and adding ScalaDoc, and cleaning up some of the code

akka-actor/src/main/scala/akka/serialization/Serialization.scala

@@ -10,12 +10,14 @@ import akka.config.Config._
 import akka.actor.{ ActorRef, Actor }
 import akka.AkkaException
 
+
+case class NoSerializerFoundException(m: String) extends AkkaException(m)
+
 /**
  * Serialization module. Contains methods for serialization and deserialization as well as
  * locating a Serializer for a particular class as defined in the mapping in the 'akka.conf' file.
  */
 object Serialization {
-  case class NoSerializerFoundException(m: String) extends AkkaException(m)
 
   def serialize(o: AnyRef): Either[Exception, Array[Byte]] = serializerFor(o.getClass) match {
     case Left(ex)          ⇒ Left(ex)
@@ -27,59 +29,60 @@ object Serialization {
     clazz: Class[_],
     classLoader: Option[ClassLoader]): Either[Exception, AnyRef] =
     serializerFor(clazz) match {
-      case Left(ex)          ⇒ Left(ex)
+      case Left(e)         ⇒ Left(e)
       case Right(serializer) ⇒ Right(serializer.fromBinary(bytes, Some(clazz), classLoader))
     }
 
-  def serializerFor(clazz: Class[_]): Either[Exception, Serializer] = {
-    serializerMap.get(clazz.getName) match {
-      case Some(serializerName: String) ⇒
-        getClassFor(serializerName) match {
-          case Right(serializer) ⇒ Right(serializer.newInstance.asInstanceOf[Serializer])
-          case Left(exception)   ⇒ Left(exception)
-        }
-      case _ ⇒
-        defaultSerializer match {
-          case Some(s: Serializer) ⇒ Right(s)
-          case None                ⇒ Left(NoSerializerFoundException("No default serializer found for " + clazz))
-        }
+  def serializerFor(clazz: Class[_]): Either[Exception, Serializer] =
+    getClassFor(serializerMap.get(clazz.getName).getOrElse(serializers("default"))) match {
+      case Right(serializer) ⇒ Right(serializer.newInstance.asInstanceOf[Serializer])
+      case Left(e) => Left(e)
     }
-  }
 
-  private def defaultSerializer = serializers.get("default") match {
-    case Some(ser: String) ⇒
-      getClassFor(ser) match {
-        case Right(serializer) ⇒ Some(serializer.newInstance.asInstanceOf[Serializer])
-        case Left(exception)   ⇒ None
-      }
-    case None ⇒ None
-  }
-
-  private def getSerializerInstanceForBestMatchClass(cl: Class[_]) = bindings match {
-    case Some(mappings) ⇒ mappings find {
-      case (clazzName, ser) ⇒
+  private def getSerializerInstanceForBestMatchClass(cl: Class[_]): Either[Exception, Serializer] = {
+    if (bindings.isEmpty)
+      Left(NoSerializerFoundException("No mapping serializer found for " + cl))
+    else {
+     bindings find {
+      case (clazzName, _) ⇒
         getClassFor(clazzName) match {
           case Right(clazz) ⇒ clazz.isAssignableFrom(cl)
           case _            ⇒ false
         }
-    } map {
-      case (_, ser) ⇒
-        getClassFor(ser) match {
-          case Right(s) ⇒ Right(s.newInstance.asInstanceOf[Serializer])
-          case _        ⇒ Left(new Exception("Error instantiating " + ser))
-        }
-    } getOrElse Left(NoSerializerFoundException("No mapping serializer found for " + cl))
-    case None ⇒ Left(NoSerializerFoundException("No mapping serializer found for " + cl))
+      } map {
+        case (_, ser) ⇒
+          getClassFor(ser) match {
+            case Right(s) ⇒ Right(s.newInstance.asInstanceOf[Serializer])
+            case _        ⇒ Left(new Exception("Error instantiating " + ser))
+          }
+      } getOrElse Left(NoSerializerFoundException("No mapping serializer found for " + cl))
+    }
   }
 
-  //TODO: Add type and docs
-  val serializers = config.getSection("akka.actor.serializers").map(_.map).getOrElse(Map("default" -> "akka.serialization.JavaSerializer"))
+  /**
+   * A Map of serializer from alias to implementation (FQN of a class implementing akka.serialization.Serializer)
+   * By default always contains the following mapping: "default" -> "akka.serialization.JavaSerializer"
+   * But "default" can be overridden in config
+   */
+  val serializers: Map[String, String] = config.getSection("akka.actor.serializers") map {
+    _.map.foldLeft(Map("default" -> "akka.serialization.JavaSerializer")) {
+      case (result, (k: String, v: String)) => result + (k -> v)
+      case (result, _) => result
+    }
+  } getOrElse Map("default" -> "akka.serialization.JavaSerializer")
 
-  //TODO: Add type and docs
-  val bindings = config.getSection("akka.actor.serialization-bindings")
-    .map(_.map)
-    .map(m ⇒ Map() ++ m.map { case (k, v: List[String]) ⇒ Map() ++ v.map((_, k)) }.flatten)
+  /**
+   *  bindings is a Map whose keys = FQN of class that is serializable and values = the alias of the serializer to be used
+   */
+  val bindings: Map[String, String] = config.getSection("akka.actor.serialization-bindings") map {
+    _.map.foldLeft(Map[String,String]()) {
+      case (result, (k: String, vs: List[_])) => result ++ (vs collect { case v: String => (v, k) }) //All keys which are lists, take the Strings from them and Map them
+      case (result, _) => result //For any other values, just skip them, TODO: print out warnings?
+    }
+  } getOrElse Map()
 
-  //TODO: Add type and docs
-  val serializerMap = bindings.map(m ⇒ m.map { case (k, v: String) ⇒ (k, serializers(v)) }).getOrElse(Map())
+  /**
+   * serializerMap is a Map whose keys = FQN of class that is serializable and values = the FQN of the serializer to be used for that class
+   */
+  val serializerMap: Map[String, String] = bindings mapValues serializers
 }