scala.io

BytePickle

object BytePickle extends AnyRef

Pickler combinators. Based on a Haskell library by Andrew Kennedy, see http://research.microsoft.com/~akenn/fun/.

Inherits

  1. AnyRef
  2. Any

Type Members

  1. class Def() extends RefDef with Product

  2. class PU[T] extends AnyRef

  3. class PicklerEnv extends HashMap[Any, Int]

  4. class PicklerState extends AnyRef

  5. class Ref() extends RefDef with Product

  6. class RefDef extends AnyRef

  7. class SPU[T] extends AnyRef

  8. class UnPicklerEnv extends HashMap[Int, Any]

  9. class UnPicklerState extends AnyRef

Value Members

  1. val DEF: Int

  2. val REF: Int

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

  4. def bool: SPU[Boolean]

  5. def byte: SPU[Byte]

  6. def bytearray: SPU[Array[Byte]]

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

  8. def equals(arg0: Any): Boolean

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

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

  10. def hashCode(): Int

    Returns a hash code value for the object

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

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

  13. def nat: SPU[Int]

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

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

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

  17. def refDef: PU[RefDef]

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

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

  20. def string: SPU[String]

  21. def toString(): String

    Returns a string representation of the object

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

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

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

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

  26. def unat: PU[Int]

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

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

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

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

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

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

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