BSONDocument

abstract def elements: Seq[BSONElement]

The document fields as a sequence of BSONElements.

abstract def headOption: Option[BSONElement]

The first/mandatory element, if any.

import reactivemongo.api.bson.BSONDocument

BSONDocument("foo" -> 1).
  headOption // Some(BSONInteger(1))

abstract def isEmpty: Boolean

Indicates whether this document is empty

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++(seq: BSONElement*): BSONDocument

Creates a new BSONDocument containing all the elements of this one and the specified element sequence.

import reactivemongo.api.bson.{
  BSONDocument, BSONElement, BSONString
}

val doc = BSONDocument("foo" -> 1)

doc ++ BSONElement("bar", BSONString("lorem"))
// { 'foo': 1, 'bar': 'lorem' }

def ++(doc: BSONDocument): BSONDocument

Returns the BSONDocument containing all the elements of this one and the elements of the given document.

import reactivemongo.api.bson.BSONDocument

val doc1 = BSONDocument("foo" -> 1)
val doc2 = BSONDocument("bar" -> "lorem")

doc1 ++ doc2 // { 'foo': 1, 'bar': 'lorem' }

def ++(producers: ElementProducer*): BSONDocument

Creates a new BSONDocument containing all the elements of this one and the specified element producers.

import reactivemongo.api.bson.BSONDocument

val doc = BSONDocument("foo" -> 1)

doc ++ ("bar" -> "lorem") // { 'foo': 1, 'bar': 'lorem' }

def --(keys: String*): BSONDocument

Returns a set without the values corresponding to the specified keys.

import reactivemongo.api.bson.BSONDocument

val doc = BSONDocument("foo" -> 1, "bar" -> "v")

doc -- "bar" // { 'foo': 1 }

def ->[B](y: B): (BSONDocument, B)

final def ==(arg0: Any): Boolean

def array(name: String): Option[Seq[BSONValue]]

EXPERIMENTAL: Returns the named element from the current document, if the element is an array field.

final def asInstanceOf[T0]: T0

final def asOpt[T](implicit reader: BSONReader[T]): Option[T]

Optionally parses this value as a T one.

def asStrict: Strict

EXPERIMENTAL: Returns a strict representation (with only the last value kept per each field name).

reactivemongo.api.bson.BSONDocument(
  "foo" -> 1, "bar" -> 2, "foo" -> 3).asStrict
// { 'foo': 3, 'bar': 2 }

final def asTry[T](implicit reader: BSONReader[T]): Try[T]

Tries to parse this value as a T one.

import scala.util.Try
import reactivemongo.api.bson.BSONValue

def foo(v: BSONValue): Try[String] = v.asTry[String]

def binary(name: String): Option[Array[Byte]]

EXPERIMENTAL: Returns the named element from the current document, if the element is a binary field.

def booleanLike(name: String): Option[Boolean]

EXPERIMENTAL: Returns the named element from the current document, if the element is a boolean-like field (numeric or boolean).

val byteCode: Byte

The code indicating the BSON type for this value as Byte

def child(name: String): Option[BSONDocument]

EXPERIMENTAL: Returns the named element from the current document, if the element is a nested document.

def children(name: String): List[BSONDocument]

EXPERIMENTAL: Returns the named element from the current document, if the element is a list of nested documents.

def clone(): AnyRef

val code: Int

The code indicating the BSON type for this value

def contains(key: String): Boolean

Checks whether the given key is found in this element set.

import reactivemongo.api.bson.BSONDocument

val doc = BSONDocument("foo" -> 1)

doc.contains("foo") // true
doc.contains("bar") // false

def double(name: String): Option[Double]

EXPERIMENTAL: Returns the named element from the current document, if the element is a double field.

def ensuring(cond: (BSONDocument) ⇒ Boolean, msg: ⇒ Any): BSONDocument

def ensuring(cond: (BSONDocument) ⇒ Boolean): BSONDocument

def ensuring(cond: Boolean, msg: ⇒ Any): BSONDocument

def ensuring(cond: Boolean): BSONDocument

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def get(key: String): Option[BSONValue]

Returns the BSONValue associated with the given key.

import reactivemongo.api.bson.BSONDocument

val doc = BSONDocument("foo" -> 1)

doc.get("foo") // Some(BSONInteger(1))
doc.contains("bar") // None

final def getAsOpt[T](key: String)(implicit reader: BSONReader[T]): Option[T]

Returns the BSONValue associated with the given key, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.{ BSONDocument, BSONNull }

val doc = BSONDocument("foo" -> 1, "bar" -> BSONNull)

doc.getAsOpt[Int]("foo") // Some(1)
doc.getAsOpt[String]("foo") // None, as not a string
doc.getAsOpt[Int]("lorem") // None, no 'lorem' key
doc.getAsOpt[Int]("bar") // None, as `BSONNull`

final def getAsTry[T](key: String)(implicit reader: BSONReader[T]): Try[T]

Gets the BSONValue associated with the given key, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.{ BSONDocument, BSONNull }

val doc = BSONDocument("foo" -> 1, "bar" -> BSONNull)

doc.getAsTry[Int]("foo") // Success(1)
doc.getAsTry[String]("foo") // Failure(..), as not a string

doc.getAsTry[Int]("lorem")
// Failure(BSONValueNotFoundException), no 'lorem' key

doc.getAsTry[Int]("bar")
// Failure(BSONValueNotFoundException), as `BSONNull`

final def getAsUnflattenedTry[T](key: String)(implicit reader: BSONReader[T]): Try[Option[T]]

Gets the BSONValue at the given key, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.{ BSONDocument, BSONNull }

val doc = BSONDocument("foo" -> 1, "bar" -> BSONNull)

doc.getAsUnflattenedTry[Int]("foo") // Success(Some(1))

doc.getAsUnflattenedTry[String]("foo") // Failure(..), as not a string

doc.getAsUnflattenedTry[Int]("lorem")
// Success(None), no 'lorem' key

doc.getAsUnflattenedTry[Int]("bar")
// Success(None), as `BSONNull`

final def getClass(): Class[_]

final def getOrElse[T](key: String, default: ⇒ T)(implicit reader: BSONReader[T]): T

Returns the BSONValue associated with the given key, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.{ BSONDocument, BSONNull }

val doc = BSONDocument("foo" -> 1, "bar" -> BSONNull)

doc.getOrElse[Int]("foo", -1) // 1
doc.getOrElse[String]("foo", "default") // 'default', as not a string
doc.getOrElse[Int]("lorem", -1) // -1, no 'lorem' key
doc.getOrElse[Int]("bar", -1) // -1, as `BSONNull`

def hashCode(): Int

def int(name: String): Option[Int]

EXPERIMENTAL: Returns the named element from the current document, if the element is a integer field.

final def isInstanceOf[T0]: Boolean

def long(name: String): Option[Long]

EXPERIMENTAL: Returns the named element from the current document, if the element is a long field.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def size: Int

The number of fields

def string(name: String): Option[String]

EXPERIMENTAL: Returns the named element from the current document, if the element is a string field.

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

final def toMap: Map[String, BSONValue]

Returns the Map representation for this document.

import reactivemongo.api.bson.BSONDocument

BSONDocument("foo" -> 1).toMap
// => Map("foo" -> BSONInteger(1))

def toString(): String

def uuid(name: String): Option[UUID]

EXPERIMENTAL: Returns the named element from the current document, if the element is a binary/uuid field.

final def values: Iterable[BSONValue]

Returns the values of the document fields.

import reactivemongo.api.bson.BSONDocument

BSONDocument("foo" -> 1).
  values // Seq(BSONInteger(1))

final def values[T](name: String)(implicit r: BSONReader[T]): Option[Seq[T]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (BSONDocument, B)