scala.tools.nsc.io

# Pickler

#### object Pickler

Linear Supertypes
AnyRef, Any
Content Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Pickler
2. AnyRef
3. Any

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Type Members

1. #### implicit 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: ClassTag[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[java.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[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )

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(): 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. #### def toString(): String

    Definition Classes
      AnyRef → Any

44. #### 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`.

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

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

46. #### 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

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

48. #### implicit val unitPickler: Pickler[Unit]

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

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

    A pickler for vector values

50. #### final def wait(): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

51. #### final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

52. #### final def wait(arg0: Long): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

53. #### 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

### Ungrouped