scala.tools.nsc.io.Pickler

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

Pickler
AnyRef
Any

Visibility

Public
All

Type Members

class TildeDecorator [S] extends AnyRef

A wrapper class to be able to use ~ s an infix method
class UnpickleFailure extends Unpickled[Nothing]

A class representing unpickle failures
case class UnpickleSuccess [+T] (result: T) extends Unpickled[T] with Product with Serializable

A class representing successful unpicklings
class Unpickled [+T] extends AnyRef

A base class representing unpickler result.
case class ~ [S, T] (fst: S, snd: T) extends Product with Serializable

A class represenenting ~-pairs

Value Members

def != (arg0: AnyRef): Boolean

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

Attributes
final
Definition Classes
Any
def ## (): Int

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

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

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

A pickler for array values
A pickler for array values

Attributes
implicit
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
implicit def booleanPickler : Pickler[Boolean]

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

Attributes
implicit
implicit val bytePickler : Pickler[Byte]

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

Attributes
implicit
implicit val charPickler : Pickler[Char]

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

Attributes
implicit
def clone (): AnyRef

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

Same as p.cond(condition)
implicit val doublePickler : Pickler[Double]

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

Attributes
implicit
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
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equals (arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize (): Unit

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

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

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

A converter from binary functions to functions over ~-pairs
A converter from binary functions to functions over ~-pairs

Attributes
implicit
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef → Any
def hashCode (): Int

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

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

Attributes
implicit
def isInstanceOf [T0] : Boolean

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

Attributes
implicit
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().
def labelledPickler [T] (label: String, p: Pickler[T]): Pickler[T]

Same as p.labelled(label).
implicit def listPickler [T] (implicit arg0: Pickler[T]): Pickler[List[T]]

A pickler for list values
A pickler for list values

Attributes
implicit
implicit val longPickler : Pickler[Long]

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

Attributes
implicit
def ne (arg0: AnyRef): Boolean

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

A conditional pickler for the scala.None object
A conditional pickler for the scala.None object

Attributes
implicit
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

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

Same as p.orNull
implicit def optionPickler [T] (implicit arg0: Pickler[T]): Pickler[Option[T]]

A pickler for optional values
A pickler for optional values

Attributes
implicit
var picklerDebugMode : Boolean
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]].
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
implicit val shortPickler : Pickler[Short]

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

Attributes
implicit
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$().
implicit def somePickler [T] (implicit arg0: Pickler[T]): CondPickler[Some[T]]

A conditional pickler for instances of class scala.Some
A conditional pickler for instances of class scala.Some

Attributes
implicit
implicit val stringPickler : Pickler[String]

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

Attributes
implicit
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
implicit def tildeDecorator [S] (x: S): TildeDecorator[S]

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

Attributes
implicit
def toString (): String

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

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

A pickler for pairs, represented as ~-pairs
A pickler for pairs, represented as ~-pairs

Attributes
implicit
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
A pickler for 3-tuples, represented as ~-tuples

Attributes
implicit
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
A pickler for 4-tuples, represented as ~-tuples

Attributes
implicit
implicit val unitPickler : Pickler[Unit]

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

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

A pickler for vector values
A pickler for vector values

Attributes
implicit
def wait (): Unit

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

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

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

Same as p.wrap(in)(out)

Pickler

object Pickler extends AnyRef

Type Members

class TildeDecorator [S] extends AnyRef

class UnpickleFailure extends Unpickled[Nothing]

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

class Unpickled [+T] extends AnyRef

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

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

implicit def array [T] (implicit arg0: ClassManifest[T], arg1: Pickler[T]): Pickler[Array[T]]

def asInstanceOf [T0] : T0

implicit def booleanPickler : Pickler[Boolean]

implicit val bytePickler : Pickler[Byte]

implicit val charPickler : Pickler[Char]

def clone (): AnyRef

def conditionalPickler [T] (p: Pickler[T], condition: (Any) ⇒ Boolean): CondPickler[T]

implicit val doublePickler : Pickler[Double]

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

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

implicit val floatPickler : Pickler[Float]

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

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

def hashCode (): Int

implicit val intPickler : Pickler[Int]

def isInstanceOf [T0] : Boolean

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

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

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

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

implicit val longPickler : Pickler[Long]

def ne (arg0: AnyRef): Boolean

implicit val nonePickler : CondPickler[None.type]

def notify (): Unit

def notifyAll (): Unit

def nullablePickler [T] (p: Pickler[T])(implicit fromNull: <:<[Null, T]): Pickler[T]

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

var picklerDebugMode : Boolean

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

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

implicit val shortPickler : Pickler[Short]

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

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

implicit val stringPickler : Pickler[String]

def synchronized [T0] (arg0: ⇒ T0): T0

implicit def tildeDecorator [S] (x: S): TildeDecorator[S]

def toString (): String

implicit def toTilde [T1, T2, S] (f: (S) ⇒ Option[(T1, T2)]): (S) ⇒ ~[T1, T2]

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

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

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)]

implicit val unitPickler : Pickler[Unit]

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

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def wrappedPickler [S, T] (p: Pickler[S])(in: (S) ⇒ T)(out: (T) ⇒ S): Pickler[T]

Inherited from AnyRef

Inherited from Any