SerClassProxy

This class represents an attempt to overcome circular dependency issues for example when you have a structure something like this: trait NodeOrLeaf case class Node(child : NodeOrLeaf) case class Leaf(x : Int) currently this will lead to stack overflows if you try to define serialization for these classs between the ser for NodeOrLeaf and Node's .ser

Used in conjunction with CSerial it looks like this: implicit lazy val ser = proxySerial(forCase(this.apply _))

Linear Supertypes

Serializable, Serializable, Product, Equals, SerClass[A], SerGenable[A], SerSchemable[A], SerReadable[A], SerWritable[A], AnyRef, Any

Instance Constructors

new SerClassProxy(f: () ⇒ SerClass[A])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def copy(schemaFn: () ⇒ SerSchema = () => this.schema, readFn: (SerInput) ⇒ A = this.read, writeFn: (A, SerOutput) ⇒ Unit = this.write, genFn: () ⇒ Gen[A] = () => this.gen): SerClass[A]

Definition Classes
SerClass
def ensureSet: SerClass[A]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val f: () ⇒ SerClass[A]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def gen: Gen[A]

Definition Classes
SerClassProxy → SerGenable
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val lock: oscala.util.OLock
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var proxied: SerClass[A]
def read(in: SerInput): A

Definition Classes
SerClassProxy → SerReadable
def sample: A

Definition Classes
SerGenable
def schema: XUnknown

Definition Classes
SerClassProxy → SerSchemable
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def write(a: A, out: SerOutput): Unit

Definition Classes
SerClassProxy → SerWritable

case class SerClassProxy[A](f: () ⇒ SerClass[A]) extends SerClass[A] with Product with Serializable

Instance Constructors

new SerClassProxy(f: () ⇒ SerClass[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def copy(schemaFn: () ⇒ SerSchema = () => this.schema, readFn: (SerInput) ⇒ A = this.read, writeFn: (A, SerOutput) ⇒ Unit = this.write, genFn: () ⇒ Gen[A] = () => this.gen): SerClass[A]

def ensureSet: SerClass[A]

final def eq(arg0: AnyRef): Boolean

val f: () ⇒ SerClass[A]

def finalize(): Unit

def gen: Gen[A]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

val lock: oscala.util.OLock

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var proxied: SerClass[A]

def read(in: SerInput): A

def sample: A

def schema: XUnknown

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write(a: A, out: SerOutput): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from SerClass[A]

Inherited from SerGenable[A]

Inherited from SerSchemable[A]

Inherited from SerReadable[A]

Inherited from SerWritable[A]

Inherited from AnyRef

Inherited from Any

Ungrouped