scala.io

object BytePickle

[source: scala/io/BytePickle.scala]

object BytePickle
extends AnyRef
Pickler combinators. Based on a Haskell library by Andrew Kennedy, see http://research.microsoft.com/~akenn/fun/.
Author
Philipp Haller
Version
1.1
Value Summary
val DEF : Int
val REF : Int
Method Summary
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 fixedList [a](pa : SPU[a])(n : Int) : SPU[List[a]]
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 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]
Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized
Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf
Class Summary
case class Def extends RefDef with Product
abstract class PU [t] extends AnyRef
class PicklerEnv extends HashMap[Any, Int]
class PicklerState (val stream : Array[Byte], val dict : PicklerEnv) extends AnyRef
case class Ref extends RefDef with Product
abstract class RefDef extends AnyRef
abstract class SPU [t] extends AnyRef
class UnPicklerEnv extends HashMap[Int, Any]
class UnPicklerState (val stream : Array[Byte], val dict : UnPicklerEnv) extends AnyRef
Value Details
val REF : Int

val DEF : Int

Method Details
def pickle[t](p : SPU[t], a : t) : Array[Byte]

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

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

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

def refDef : PU[RefDef]

def unat : PU[Int]

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

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

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

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

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

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

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

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

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]

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

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

def nat : SPU[Int]

def byte : SPU[Byte]

def string : SPU[String]

def bytearray : SPU[Array[Byte]]

def bool : SPU[Boolean]

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

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

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

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

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