scala.tools.nsc.io

Pickler

object Pickler extends AnyRef

Source
Pickler.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. Pickler
  2. AnyRef
  3. Any
Visibility
  1. Public
  2. All

Type Members

  1. class TildeDecorator[S] extends AnyRef

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

  2. 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

  4. abstract class Unpickled[+T] extends AnyRef

    A base class representing unpickler result.

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

    A class represenenting ~-pairs

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. implicit def array[T](implicit arg0: ClassManifest[T], arg1: Pickler[T]): Pickler[Array[T]]

    A pickler for array values

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  8. implicit def booleanPickler: Pickler[Boolean]

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

  9. implicit val bytePickler: Pickler[Byte]

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

  10. implicit val charPickler: Pickler[Char]

    A pickler for values of type Char, represented as string literals of length 1

  11. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  12. def conditionalPickler[T](p: Pickler[T], condition: (Any) ⇒ Boolean): CondPickler[T]

    Same as p.cond(condition)

  13. implicit val doublePickler: Pickler[Double]

    A pickler for values of type Double, represented as floating point literals

  14. def eitherPickler[T, U <: T, V <: T](p: CondPickler[U], q: ⇒ CondPickler[V]): CondPickler[T] { lazy val qq: scala.tools.nsc.io.CondPickler[V] }

    Same as p | q

  15. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  16. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  17. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  18. implicit val floatPickler: Pickler[Float]

    A pickler for values of type Float, represented as floating point literals

  19. implicit def fromTilde[T1, T2, R](f: (T1, T2) ⇒ R): (~[T1, T2]) ⇒ R

    A converter from binary functions to functions over ~-pairs

  20. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any
  21. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  22. implicit val intPickler: Pickler[Int]

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

  23. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  24. 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.

  25. 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>).newInstance().

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

    Same as p.labelled(label).

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

    A pickler for list values

  28. implicit val longPickler: Pickler[Long]

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

  29. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  30. implicit val nonePickler: CondPickler[None.type]

    A conditional pickler for the scala.None object

  31. final def notify(): Unit

    Definition Classes
    AnyRef
  32. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  33. def nullablePickler[T](p: Pickler[T])(implicit fromNull: <:<[Null, T]): Pickler[T]

    Same as p.orNull

  34. implicit def optionPickler[T](implicit arg0: Pickler[T]): Pickler[Option[T]]

    A pickler for optional values

  35. var picklerDebugMode: Boolean

  36. 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]].

  37. def seqPickler[T, U](p: Pickler[T], q: ⇒ Pickler[U]): Pickler[~[T, U]] { lazy val qq: scala.tools.nsc.io.Pickler[U] }

    Same as p ~ q

  38. implicit val shortPickler: Pickler[Short]

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

  39. 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$().

  40. implicit def somePickler[T](implicit arg0: Pickler[T]): CondPickler[Some[T]]

    A conditional pickler for instances of class scala.Some

  41. implicit val stringPickler: Pickler[String]

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

  42. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  43. implicit def tildeDecorator[S](x: S): TildeDecorator[S]

    An implicit wrapper that adds ~ as a method to any value.

  44. def toString(): String

    Definition Classes
    AnyRef → Any
  45. implicit def toTilde[T1, T2, S](f: (S) ⇒ Option[(T1, T2)]): (S) ⇒ ~[T1, T2]

    An converter from unctions returning Options over pair to functions returning ~-pairs The converted function will raise a MatchError where the original function returned a None.

    An converter from unctions returning Options over pair to functions returning ~-pairs The converted function will raise a MatchError where the original function returned a None. This converter is useful for turning unapply methods of case classes into wrapper methods that can be passed as second argument to wrap.

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

    A pickler for pairs, represented as ~-pairs

  47. 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

  48. implicit def tuple4Pickler[T1, T2, T3, T4](implicit p1: Pickler[T1], p2: Pickler[T2], p3: Pickler[T3], p4: Pickler[T4]): Pickler[(T1, T2, T3, T4)]

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

  49. implicit val unitPickler: Pickler[Unit]

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

  50. implicit def vectorPickler[T](implicit arg0: Pickler[T]): Pickler[Vector[T]]

    A pickler for vector values

  51. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  52. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  53. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  54. def wrappedPickler[S, T](p: Pickler[S])(in: (S) ⇒ T)(out: (T) ⇒ S): Pickler[T]

    Same as p.wrap(in)(out)

Inherited from AnyRef

Inherited from Any