From 749b3dac20b0ccdd4107e832a2d8ca5746e3b4e2 Mon Sep 17 00:00:00 2001 From: Viktor Klang Date: Thu, 14 Jul 2011 11:25:40 +0200 Subject: [PATCH] Adding method return types to Serialization, and adding ScalaDoc, and cleaning up some of the code --- .../akka/serialization/Serialization.scala | 89 ++++++++++--------- 1 file changed, 46 insertions(+), 43 deletions(-) diff --git a/akka-actor/src/main/scala/akka/serialization/Serialization.scala b/akka-actor/src/main/scala/akka/serialization/Serialization.scala index ae56c8d2b1..4f8e360bca 100644 --- a/akka-actor/src/main/scala/akka/serialization/Serialization.scala +++ b/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 }