BytePickle

class Def() extends RefDef with Product

class PU[T] extends AnyRef

class PicklerEnv extends HashMap[Any, Int]

class PicklerState extends AnyRef

class Ref() extends RefDef with Product

class RefDef extends AnyRef

class SPU[T] extends AnyRef

class UnPicklerEnv extends HashMap[Int, Any]

class UnPicklerState extends AnyRef

val DEF: Int

val REF: Int

def appendByte(a: Array[Byte], b: Int): Array[Byte]

def bool: SPU[Boolean]

def byte: SPU[Byte]

def bytearray: SPU[Array[Byte]]

def data[a](tag: (a) ⇒ Int, ps: List[() ⇒ SPU[a]]): SPU[a]

def equals(arg0: Any): Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence

def fixedList[a](pa: SPU[a])(n: Int): SPU[List[a]]

def hashCode(): Int

Returns a hash code value for the object

def lift[t](x: t): SPU[t]

def list[a](pa: SPU[a]): SPU[List[a]]

def nat: SPU[Int]

def nat2Bytes(x: Int): Array[Byte]

def pair[a, b](pa: SPU[a], pb: SPU[b]): SPU[(a, b)]

def pickle[T](p: SPU[T], a: T): Array[Byte]

def refDef: PU[RefDef]

def sequ[t, u](f: (u) ⇒ t, pa: SPU[t], k: (t) ⇒ SPU[u]): SPU[u]

def share[a](pa: SPU[a]): SPU[a]

def string: SPU[String]

def toString(): String

Returns a string representation of the object

def triple[a, b, c](pa: SPU[a], pb: SPU[b], pc: SPU[c]): SPU[(a, b, c)]

def ufixedList[A](pa: PU[A])(n: Int): PU[List[A]]

def ulift[t](x: t): PU[t]

def ulist[a](pa: PU[a]): PU[List[a]]

def unat: PU[Int]

def unpickle[T](p: SPU[T], stream: Array[Byte]): T

def upair[a, b](pa: PU[a], pb: PU[b]): PU[(a, b)]

def upickle[T](p: PU[T], a: T): Array[Byte]

def usequ[t, u](f: (u) ⇒ t, pa: PU[t], k: (t) ⇒ PU[u]): PU[u]

def uunpickle[T](p: PU[T], stream: Array[Byte]): T

def uwrap[a, b](i: (a) ⇒ b, j: (b) ⇒ a, pa: PU[a]): PU[b]

def wrap[a, b](i: (a) ⇒ b, j: (b) ⇒ a, pa: SPU[a]): SPU[b]