Macros

Macros for generating BSONReader and BSONWriter implementations for case at compile time. Invoking these macros is equivalent to writing anonymous class implementations by hand.

Example

case class Person(name: String, surname: String)
implicit val personHandler = Macros.handler[Person]

Use reader to generate the BSONReader and writer for BSONWriter or handler for a class that extends both. Respective methods with 'Opts' appended take additional options in form of type parameters.

The A type parameter defines case class that will be the basis for auto-generated implementation. Some other types with matching apply-unapply might work but behaviour is undefined. Since macros will match the apply-unapply pair you are free to overload these methods in the companion object.

Fields in the case class get mapped into BSON properties with respective names and BSON handlers are pulled from implicit scope to (de)serialize them. In order to use custom types inside case classes just make sure appropriate handlers are in scope. Note that companion objects are searched too. For example if you have case class Foo(bar: Bar) and want to create a handler for it is enough to put an implicit handler for Bar in it's companion object. That handler might be macro generated or written by hand.

Case classes can also be defined inside other classes, objects or traits but not inside functions(known limitation). In order to work you should have the case class in scope(where you call the macro) so you can refer to it by it's short name - without package. This is necessary because the generated implementations refer to it by the short name to support nested declarations. You can work around this with local imports.

Example

implicit val handler = {
  import some.package.Foo
  Macros.handler[Foo]
}

Option types are handled somewhat specially: a field of type Option[T] will only be appended to the document if it contains a value. Similarly if a document does not contain a value it will be read as None.

Also supported neat trick are 'union types' that make for easy work with algebraic data types. See the UnionType option for more details.

You can also create recursive structures by explicitly annotating types of the implicit handlers. (To let the compiler know they exist) Example

sealed trait Tree
case class Node(left: Tree, right: Tree) extends Tree
case class Leaf(data: String) extends Tree

object Tree {
  import Macros.Options._
  implicit val bson: Handler[Tree] = Macros.handlerOpts[Tree, UnionType[Node \/ Leaf]]
}

See also: Macros.Options for specific options

Linear Supertypes

AnyRef, Any

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
object Annotations

Annotations to use on case classes that are being processed by macros
object Options

Methods with 'Opts' postfix will take additional options in the form of type parameters that will customize behavior of the macros during compilation.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
macro def handler[A]: BSONDocumentReader[A] with BSONDocumentWriter[A] with BSONHandler[BSONDocument, A]

Creates an instance of BSONReader and BSONWriter for case class A
macro def handlerOpts[A, Opts <: Default]: BSONDocumentReader[A] with BSONDocumentWriter[A] with BSONHandler[BSONDocument, A]

Creates an instance of BSONReader and BSONWriter for case class A and takes additional options
def hashCode(): Int

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

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
macro def reader[A]: BSONDocumentReader[A]

Creates an instance of BSONReader for case class A
Creates an instance of BSONReader for case class A

See also
Macros
macro def readerOpts[A, Opts <: Default]: BSONDocumentReader[A]

Creates an instance of BSONReader for case class A and takes additional options
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )
macro def writer[A]: BSONDocumentWriter[A]

Creates an instance of BSONWriter for case class A
macro def writerOpts[A, Opts <: Default]: BSONDocumentWriter[A]

Creates an instance of BSONWriter for case class A and takes additional options

Related Doc: package bson

object Macros

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Annotations

object Options

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

macro def handler[A]: BSONDocumentReader[A] with BSONDocumentWriter[A] with BSONHandler[BSONDocument, A]

macro def handlerOpts[A, Opts <: Default]: BSONDocumentReader[A] with BSONDocumentWriter[A] with BSONHandler[BSONDocument, A]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

macro def reader[A]: BSONDocumentReader[A]

macro def readerOpts[A, Opts <: Default]: BSONDocumentReader[A]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

macro def writer[A]: BSONDocumentWriter[A]

macro def writerOpts[A, Opts <: Default]: BSONDocumentWriter[A]

Inherited from AnyRef

Inherited from Any

Ungrouped