Merge pull request #159 from phaller/topic/debug

Ignore known size when generating pickler for Externalizable

Author: heathermiller

core/src/main/scala/pickling/Macros.scala

@@ -33,6 +33,12 @@ trait PicklerMacros extends Macro {
       if (fir.isPublic) q"picklee.${newTermName(fir.name)}"
       else reflectively("picklee", fir)(fm => q"$fm.get.asInstanceOf[${fir.tpe}]").head //TODO: don't think it's possible for this to return an empty list, so head should be OK
 
+    def computeKnownSizeOfObjectOutput(cir: ClassIR): (Option[Tree], List[Tree]) = {
+      // for now we cannot compute a fixed size for ObjectOutputs
+      // in the future this will be a possible optimization (faster Externalizables)
+      None -> List()
+    }
+
     // this exists so as to provide as much information as possible about the size of the object
     // to-be-pickled to the picklers at runtime. In the case of the binary format for example,
     // this allows us to remove array copying and allocation bottlenecks
@@ -45,6 +51,11 @@ trait PicklerMacros extends Macro {
           if (elTpe.isEffectivelyPrimitive) Some(q"picklee.length * ${primitiveSizes(elTpe)} + 4")
           else None
         knownSize -> Nil
+      } else if (tpe <:< typeOf[java.io.Externalizable]) {
+        computeKnownSizeOfObjectOutput(cir) match {
+          case (None, lst) => None -> List()
+          case _ => c.abort(c.enclosingPosition, "not implemented")
+        }
       } else {
         val possibleSizes: List[(Option[Tree], Option[Tree])] = cir.fields map {
           case fld if fld.tpe.isEffectivelyPrimitive =>

core/src/test/scala/pickling/run/externalizable.scala

@@ -2,7 +2,6 @@ package scala.pickling.externalizable
 
 import org.scalatest.FunSuite
 import scala.pickling._
-import json._
 import java.io.{Externalizable, IOException, ObjectInput, ObjectOutput}
 import java.nio.ByteBuffer
 
@@ -111,11 +110,63 @@ object StorageLevel {
   }
 }
 
+class StorageLevel2 (
+    private var useDisk_ : Boolean,
+    private var useMemory_ : Boolean,
+    private var deserialized_ : Boolean,
+    private var replication_ : Int)
+  extends Externalizable {
+
+  def toInt: Int = {
+    var ret = 0
+    if (useDisk_) {
+      ret |= 4
+    }
+    if (useMemory_) {
+      ret |= 2
+    }
+    if (deserialized_) {
+      ret |= 1
+    }
+    ret
+  }
+
+  override def writeExternal(out: ObjectOutput) {
+    out.writeByte(toInt)
+    out.writeByte(replication_)
+  }
+
+  override def readExternal(in: ObjectInput) {
+    val flags = in.readByte()
+    useDisk_ = (flags & 4) != 0
+    useMemory_ = (flags & 2) != 0
+    deserialized_ = (flags & 1) != 0
+    replication_ = in.readByte()
+  }
+
+  override def equals(other: Any): Boolean =
+    other.isInstanceOf[StorageLevel2] && {
+      val o = other.asInstanceOf[StorageLevel2]
+      o.useDisk_ == useDisk_ && o.useMemory_ == useMemory_ && o.deserialized_ == deserialized_ && o.replication_ == replication_
+    }
+}
+
 class ExternalizableTest extends FunSuite {
   test("main") {
+    import json._
+
     val sl = StorageLevel.MEMORY_ONLY_SER
     val pickle: JSONPickle = sl.pickle
     val up = pickle.unpickle[StorageLevel]
     assert(sl == up)
   }
+
+  test("Externalizable pickler must not use knownSize") {
+    import binary._
+
+    val obj = new StorageLevel2(false, true, false, 1)
+    val p = obj.pickle
+    val up = p.unpickle[StorageLevel2]
+    assert(up == obj)
+  }
 }