CodecBson

abstract val decoder: DecodeBson[A]

abstract val encoder: EncodeBson[A]

final def !=(arg0: Any): Boolean

final def ##(): Int

def &&&[B](x: DecodeBson[B]): DecodeBson[(A, B)]

creates a decoder that applies this decoder and x and returns both results together.

final def ==(arg0: Any): Boolean

def apply(dbo: DBObject): DecodeResult[A]

an alias for decode

def apply(a: A): DBObject

alias for encode

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contramap[B](f: (B) ⇒ A): EncodeBson[B]

derives a new encoder by transforming them into things this encoder applies to.

def decode(c: DBObject): DecodeResult[A]

this is the method that needs to be implemented to decode.

def encode(a: A): DBObject

encodes an A into a mongo DBObject

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[B](f: (A) ⇒ DecodeBson[B]): DecodeBson[B]

derives a new DecodeBson by transforming decoded values using a function that produces a new DecodeBson.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): DecodeBson[B]

derives a new DecodeBson from this one by transforming the values decoded from this one

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[B >: A](x: ⇒ DecodeBson[B]): DecodeBson[B]

creates a decoder that first uses this decoder and then another decoder.

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

def toString(): String

def validate(f: (DBObject) ⇒ Boolean, msg: (DBObject) ⇒ DecodeError): DecodeBson[A]

creates a decoder that applies a predicate to a dbo before it tries to apply this decoder.

def validateFields(count: Int): DecodeBson[A]

creates a decoder that only applies this decoder if the dbo has exactly count fields

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |||[B >: A](x: ⇒ DecodeBson[B]): DecodeBson[B]

alias for orElse