Pickling java.nio.ByteBuffer #345

gistfile1.scala

import java.nio.ByteBuffer

import scala.pickling.pickler.PrimitiveArrayPicklers

trait JavaByteBufferPicklers extends PrimitiveArrayPicklers {
  import scala.pickling.{Pickler, Unpickler, FastTypeTag,
                         PBuilder, PReader, PicklingException}

  implicit val javaByteBufferPickler: Pickler[ByteBuffer] with Unpickler[ByteBuffer] =
    new Pickler[ByteBuffer] with Unpickler[ByteBuffer] {

    def tag = FastTypeTag[ByteBuffer]

    def pickle(picklee: ByteBuffer, builder: PBuilder): Unit = {
      builder.beginEntry(picklee)
      builder.hintStaticallyElidedType()

      val arr = if (picklee.hasArray) picklee.array else ???

      builder.putField("array", { b =>
        b.hintTag(FastTypeTag.ArrayByte)
        b.hintStaticallyElidedType()
        byteArrayPickler.pickle(arr, b)
      })

      builder.endEntry()
    }

    def unpickle(tag: String, reader: PReader): Any = try {
      reader.hintTag(FastTypeTag.ArrayByte)
      reader.hintStaticallyElidedType()
      val r1 = reader.readField("array")

      val tag1 = r1.beginEntry()
      val arr = byteArrayPickler.unpickle(tag1, r1).asInstanceOf[Array[Byte]]
      r1.endEntry()

      ByteBuffer.wrap(arr)
    } catch {
      case PicklingException(msg, cause) =>
        throw PicklingException(s"""error in unpickle of ByteBuffer unpickler:
                                   |tag in unpickle: '${tag}'
                                   |message:
                                   |$msg""".stripMargin, cause)
    }

  }

}

object Test extends App with JavaByteBufferPicklers {
  import scala.pickling._, Defaults._, binary._

  val arr = Array[Byte](3, 2, 1, 0)
  val buf = ByteBuffer.wrap(arr)

  val ser = buf.pickle.value

  val toUnpickle = BinaryPickle(ser)
  val des = toUnpickle.unpickle[ByteBuffer]

  val arr2 = des.array
  assert(arr2.mkString("[", ",", "]") == "[3,2,1,0]")
  println("success")
}