Packages

object Pickler

Source
Pickler.scala
Linear Supertypes
AnyRef, Any
Content Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Pickler
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. implicit class TildeDecorator[S] extends AnyRef

    A wrapper class to be able to use ~ s an infix method

  2. final class UnpickleFailure extends Unpickled[Nothing]

    A class representing unpickle failures

  3. case class UnpickleSuccess[+T](result: T) extends Unpickled[T] with Product with Serializable

    A class representing successful unpicklings

    A class representing successful unpicklings

    T

    the type of the unpickled value

    result

    the unpickled value

  4. sealed abstract class Unpickled[+T] extends AnyRef

    A base class representing unpickler result.

    A base class representing unpickler result. It has two subclasses: UnpickleSuccess for successful unpicklings and UnpickleFailure for failures, where a value of the given type T could not be unpickled from input.

    T

    the type of unpickled values in case of success.

  5. case class ~[+S, +T](fst: S, snd: T) extends Product with Serializable

    A class representing ~-pairs

Value Members

  1. implicit def booleanPickler: Pickler[Boolean]

    A pickler for values of type Boolean, represented as the literals true or false.

  2. def conditionalPickler[T](p: Pickler[T], condition: (Any) => Boolean): CondPickler[T]

    Same as p.cond(condition)

  3. def eitherPickler[T, U <: T, V <: T](p: CondPickler[U], q: => CondPickler[V]): CondPickler[T] { lazy val qq: scala.tools.nsc.interactive.CondPickler[V] }

    Same as p | q

  4. implicit val intPickler: Pickler[Int]

    A pickler for values of type Int, represented as integer literals

  5. implicit def iterPickler[T](implicit arg0: Pickler[T]): Pickler[Iterator[T]]

    A picklers that handles iterators.

    A picklers that handles iterators. It pickles all values returned by an iterator separated by commas. When unpickling, it always returns an UnpickleSuccess containing an iterator. This iterator returns 0 or more values that are obtained by unpickling until a closing parenthesis, bracket or brace or the end of input is encountered.

    This means that iterator picklers should not be directly followed by ~ because the pickler would also read any values belonging to the second part of the ~-pair.

    What's usually done instead is that the iterator pickler is wrapped and labelled to handle other kinds of sequences.

  6. def javaInstancePickler[T <: AnyRef]: Pickler[T]

    A pickler the handles instances of classes that have an empty constructor.

    A pickler the handles instances of classes that have an empty constructor. It represents than as $new ( <name of class> ). When unpickling, a new instance of the class is created using the empty constructor of the class via Class.forName(<name of class>).getConstructor().newInstance().

  7. def labelledPickler[T](label: String, p: Pickler[T]): Pickler[T]

    Same as p.labelled(label).

  8. implicit def listPickler[T](implicit arg0: Pickler[T]): Pickler[List[T]]

    A pickler for list values

  9. implicit val longPickler: Pickler[Long]

    A pickler for values of type Long, represented as integer literals

  10. def pkl[T](implicit arg0: Pickler[T]): Pickler[T]

    The implicit Pickler value for type T.

    The implicit Pickler value for type T. Equivalent to implicitly[Pickler[T]].

  11. def seqPickler[T, U](p: Pickler[T], q: => Pickler[U]): Pickler[~[T, U]] { lazy val qq: scala.tools.nsc.interactive.Pickler[U] }

    Same as p ~ q

  12. def singletonPickler[T <: AnyRef](x: T): CondPickler[T]

    A conditional pickler for singleton objects.

    A conditional pickler for singleton objects. It represents these with the object's underlying class as a label. Example: Object scala.None would be represented as scala.None$().

  13. implicit val stringPickler: Pickler[String]

    A pickler for values of type String, represented as string literals

  14. implicit def tuple2Pickler[T1, T2](implicit arg0: Pickler[T1], arg1: Pickler[T2]): Pickler[(T1, T2)]

    A pickler for pairs, represented as ~-pairs

  15. implicit def tuple3Pickler[T1, T2, T3](implicit p1: Pickler[T1], p2: Pickler[T2], p3: Pickler[T3]): Pickler[(T1, T2, T3)]

    A pickler for 3-tuples, represented as ~-tuples

  16. implicit val unitPickler: Pickler[Unit]

    A pickler for values of type Unit, represented by the empty character string

  17. def wrappedPickler[S, T](p: Pickler[S])(in: (S) => T)(out: (T) => S): Pickler[T]

    Same as p.wrap(in)(out)