BSONArray

abstract def values: IndexedSeq[BSONValue]

The BSON values

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ++(values: BSONValue*): BSONArray

Returns a BSON array with the given values appended.

import reactivemongo.api.bson.{ BSONArray, BSONLong }

val arr = BSONArray(1, "foo")

arr ++ BSONLong(3L) // [ 1, 'foo', NumberLong(3) ]

def ++(arr: BSONArray): BSONArray

Returns a BSON array with the values of the given one appended.

import reactivemongo.api.bson.BSONArray

val arr1 = BSONArray(1, "foo")
val arr2 = BSONArray(2L, "bar")

arr1 ++ arr2 // [ 1, 'foo', NumberLong(2), 'bar' ]

def +:(value: BSONValue): BSONArray

Returns a BSON array with the given value prepended.

import reactivemongo.api.bson.{ BSONArray, BSONString }

BSONString("foo") +: BSONArray(1L) // [ 'foo', NumberLong(1) ]

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

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

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

Optionally parses this value as a T one.

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]

val byteCode: Byte

The code indicating the BSON type for this value as Byte

def clone(): AnyRef

val code: Int

The code indicating the BSON type for this value

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

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

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

def ensuring(cond: Boolean): BSONArray

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

def get(index: Int): Option[BSONValue]

Returns the BSONValue at the given index.

def secondAsString(
  a: reactivemongo.api.bson.BSONArray): Option[String] =
  a.get(1).flatMap(_.asOpt[String])

def getAsOpt[T](index: Int)(implicit reader: BSONReader[T]): Option[T]

Returns the BSONValue at the given index, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.BSONArray

val arr = BSONArray(1, "foo")

arr.getAsOpt[Int](0) // Some(1)
arr.getAsOpt[Int](1) // None; "foo" not int

def getAsTry[T](index: Int)(implicit reader: BSONReader[T]): Try[T]

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

import reactivemongo.api.bson.BSONArray

val arr = BSONArray(1, "foo")

arr.getAsTry[Int](0) // Success(1)
arr.getAsTry[Int](1) // Failure(BSONValueNotFoundException(..))

def getAsUnflattenedTry[T](index: Int)(implicit reader: BSONReader[T]): Try[Option[T]]

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

import reactivemongo.api.bson.BSONArray

val arr = BSONArray(1, "foo")

arr.getAsUnflattenedTry[Int](0) // Success(Some(1))
arr.getAsUnflattenedTry[Int](1) // Failure(BSONValueNotFoundException(..))
arr.getAsUnflattenedTry[Int](2) // Success(None) // no value at 2

final def getClass(): Class[_]

def getOrElse[T](index: Int, default: ⇒ T)(implicit reader: BSONReader[T]): T

Returns the BSONValue at the given index, and converts it with the given implicit BSONReader.

import reactivemongo.api.bson.BSONArray

val arr = BSONArray(1, "foo")

arr.getOrElse[Int](0, -1) // 1
arr.getOrElse[Int](1, -1) // -1; "foo" not int

def hashCode(): Int

def headOption: Option[BSONValue]

The first/mandatory value, if any

def isEmpty: Boolean

Indicates whether this array is empty

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def size: Int

The number of values

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

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