trait Generic extends CoreProtocol
- Alphabetic
- By Inheritance
- Generic
- CoreProtocol
- Protocol
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
abstract
class
CollectionFormat[S, T] extends Format[S]
A more general LengthEncoded (arrays are no longer collections)
-
abstract
class
LengthEncoded[S <: Traversable[T], T] extends CollectionFormat[S, T]
Format instance which encodes the collection by first writing the length of the collection as an int, then writing the collection elements in order.
- case class Summand[T](clazz: Class[_], format: Format[T]) extends Product with Serializable
Abstract Value Members
-
implicit abstract
val
BooleanFormat: Format[Boolean]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
CharFormat: Format[Char]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
DoubleFormat: Format[Double]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
FloatFormat: Format[Float]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
IntFormat: Format[Int]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
LongFormat: Format[Long]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
ShortFormat: Format[Short]
- Definition Classes
- CoreProtocol
-
implicit abstract
val
StringFormat: Format[String]
- Definition Classes
- CoreProtocol
- implicit abstract def arrayFormat[T](implicit fmt: Format[T], mf: Manifest[T]): Format[Array[T]]
- implicit abstract def listFormat[T](implicit fmt: Format[T]): Format[List[T]]
Concrete 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
- implicit def anyToSummand[T](t: T): Summand[T]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
asProduct10[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ⇒ S)(unapply: (S) ⇒ Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10]): Format[S]
Represents this type as 10 consecutive binary blocks of type T1..T10, relative to the specified way of decomposing and composing S as such.
-
def
asProduct11[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) ⇒ S)(unapply: (S) ⇒ Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11]): Format[S]
Represents this type as 11 consecutive binary blocks of type T1..T11, relative to the specified way of decomposing and composing S as such.
-
def
asProduct12[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) ⇒ S)(unapply: (S) ⇒ Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12]): Format[S]
Represents this type as 12 consecutive binary blocks of type T1..T12, relative to the specified way of decomposing and composing S as such.
-
def
asProduct13[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) ⇒ S)(unapply: (S) ⇒ Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13]): Format[S]
Represents this type as 13 consecutive binary blocks of type T1..T13, relative to the specified way of decomposing and composing S as such.
-
def
asProduct14[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) ⇒ S)(unapply: (S) ⇒ Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14]): Format[S]
Represents this type as 14 consecutive binary blocks of type T1..T14, relative to the specified way of decomposing and composing S as such.
-
def
asProduct15[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) ⇒ S)(unapply: (S) ⇒ Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15]): Format[S]
Represents this type as 15 consecutive binary blocks of type T1..T15, relative to the specified way of decomposing and composing S as such.
-
def
asProduct16[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) ⇒ S)(unapply: (S) ⇒ Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16]): Format[S]
Represents this type as 16 consecutive binary blocks of type T1..T16, relative to the specified way of decomposing and composing S as such.
-
def
asProduct17[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) ⇒ S)(unapply: (S) ⇒ Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16], bin17: Format[T17]): Format[S]
Represents this type as 17 consecutive binary blocks of type T1..T17, relative to the specified way of decomposing and composing S as such.
-
def
asProduct18[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) ⇒ S)(unapply: (S) ⇒ Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16], bin17: Format[T17], bin18: Format[T18]): Format[S]
Represents this type as 18 consecutive binary blocks of type T1..T18, relative to the specified way of decomposing and composing S as such.
-
def
asProduct19[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) ⇒ S)(unapply: (S) ⇒ Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16], bin17: Format[T17], bin18: Format[T18], bin19: Format[T19]): Format[S]
Represents this type as 19 consecutive binary blocks of type T1..T19, relative to the specified way of decomposing and composing S as such.
-
def
asProduct2[S, T1, T2](apply: (T1, T2) ⇒ S)(unapply: (S) ⇒ Product2[T1, T2])(implicit bin1: Format[T1], bin2: Format[T2]): Format[S]
Represents this type as 2 consecutive binary blocks of type T1..T2, relative to the specified way of decomposing and composing S as such.
-
def
asProduct20[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) ⇒ S)(unapply: (S) ⇒ Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16], bin17: Format[T17], bin18: Format[T18], bin19: Format[T19], bin20: Format[T20]): Format[S]
Represents this type as 20 consecutive binary blocks of type T1..T20, relative to the specified way of decomposing and composing S as such.
-
def
asProduct21[S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) ⇒ S)(unapply: (S) ⇒ Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9], bin10: Format[T10], bin11: Format[T11], bin12: Format[T12], bin13: Format[T13], bin14: Format[T14], bin15: Format[T15], bin16: Format[T16], bin17: Format[T17], bin18: Format[T18], bin19: Format[T19], bin20: Format[T20], bin21: Format[T21]): Format[S]
Represents this type as 21 consecutive binary blocks of type T1..T21, relative to the specified way of decomposing and composing S as such.
-
def
asProduct3[S, T1, T2, T3](apply: (T1, T2, T3) ⇒ S)(unapply: (S) ⇒ Product3[T1, T2, T3])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3]): Format[S]
Represents this type as 3 consecutive binary blocks of type T1..T3, relative to the specified way of decomposing and composing S as such.
-
def
asProduct4[S, T1, T2, T3, T4](apply: (T1, T2, T3, T4) ⇒ S)(unapply: (S) ⇒ Product4[T1, T2, T3, T4])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4]): Format[S]
Represents this type as 4 consecutive binary blocks of type T1..T4, relative to the specified way of decomposing and composing S as such.
-
def
asProduct5[S, T1, T2, T3, T4, T5](apply: (T1, T2, T3, T4, T5) ⇒ S)(unapply: (S) ⇒ Product5[T1, T2, T3, T4, T5])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5]): Format[S]
Represents this type as 5 consecutive binary blocks of type T1..T5, relative to the specified way of decomposing and composing S as such.
-
def
asProduct6[S, T1, T2, T3, T4, T5, T6](apply: (T1, T2, T3, T4, T5, T6) ⇒ S)(unapply: (S) ⇒ Product6[T1, T2, T3, T4, T5, T6])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6]): Format[S]
Represents this type as 6 consecutive binary blocks of type T1..T6, relative to the specified way of decomposing and composing S as such.
-
def
asProduct7[S, T1, T2, T3, T4, T5, T6, T7](apply: (T1, T2, T3, T4, T5, T6, T7) ⇒ S)(unapply: (S) ⇒ Product7[T1, T2, T3, T4, T5, T6, T7])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7]): Format[S]
Represents this type as 7 consecutive binary blocks of type T1..T7, relative to the specified way of decomposing and composing S as such.
-
def
asProduct8[S, T1, T2, T3, T4, T5, T6, T7, T8](apply: (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ S)(unapply: (S) ⇒ Product8[T1, T2, T3, T4, T5, T6, T7, T8])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8]): Format[S]
Represents this type as 8 consecutive binary blocks of type T1..T8, relative to the specified way of decomposing and composing S as such.
-
def
asProduct9[S, T1, T2, T3, T4, T5, T6, T7, T8, T9](apply: (T1, T2, T3, T4, T5, T6, T7, T8, T9) ⇒ S)(unapply: (S) ⇒ Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(implicit bin1: Format[T1], bin2: Format[T2], bin3: Format[T3], bin4: Format[T4], bin5: Format[T5], bin6: Format[T6], bin7: Format[T7], bin8: Format[T8], bin9: Format[T9]): Format[S]
Represents this type as 9 consecutive binary blocks of type T1..T9, relative to the specified way of decomposing and composing S as such.
-
def
asSingleton[T](t: T): Format[T]
Trivial serialization.
Trivial serialization. Writing is a no-op, reading always returns this instance.
-
def
asUnion[S](summands: Summand[_ <: S]*): Format[S]
Uses a single tag byte to represent S as a union of subtypes.
- implicit def classToSummand[T](clazz: Class[T])(implicit bin: Format[T]): Summand[T]
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
enumerationFormat[V <: Value](enumeration: Enumeration): Format[V]
Create a format for an enumeration, representing values by their integer IDs.
Create a format for an enumeration, representing values by their integer IDs.
Note that due to type system limitations we cannot enforce that you pass the right Enumeration to this method. Be good.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- implicit def formatToSummand[T](format: Format[T])(implicit mf: Manifest[T]): Summand[T]
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
lazyFormat[S](bin: ⇒ Format[S]): Format[S] { lazy val delegate: sbinary.Format[S] }
Lazy wrapper around a binary.
Lazy wrapper around a binary. Useful when you want e.g. mutually recursive binary instances.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
viaArray[S <: Traversable[T], T](f: (Array[T]) ⇒ S)(implicit binary: Format[T], mf: Manifest[T]): Format[S]
Length encodes, but with the result built from an array.
-
def
viaSeq[S <: Traversable[T], T](f: (Seq[T]) ⇒ S)(implicit binary: Format[T]): Format[S]
Length encodes, but with the result built from a Seq.
Length encodes, but with the result built from a Seq. Useful for when a
ClassManifest
is not available the underlying typeT
. -
def
viaString[T](f: (String) ⇒ T): Format[T]
Encodes and decodes via some String representation.
-
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( ... ) @native()
-
def
withStamp[S, T](stamp: S)(binary: Format[T])(implicit binS: Format[S]): Format[T]
Attaches a stamp to the data.
Attaches a stamp to the data. This stamp is placed at the beginning of the format and may be used to verify the integrity of the data (e.g. a magic number for the data format version).
-
def
wrap[S, T](to: (S) ⇒ T, from: (T) ⇒ S)(implicit bin: Format[T]): Format[S]
Serializes this via a bijection to some other type.
-
implicit
object
ByteFormat extends Format[Byte]
- Definition Classes
- Protocol
-
implicit
object
UnitFormat extends Format[Unit]
- Definition Classes
- Protocol