ReactiveMongo API
1.1
API
Generated with
ReactiveMongo API/reactivemongo.api/TestCursor

TestCursor

reactivemongo.api.TestCursor
class TestCursor[T] extends Cursor[T]

'''EXPERIMENTAL:''' Base class to implement test-only/mocked Cursor.

All functions failed future by default, make sure to override the required functions with appropriate results to execute the tests.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.{ Cursor, TestCursor }

final class MyTestCursor[T](h: T) extends TestCursor[T] {
 override def head(implicit ctx: ExecutionContext): Future[T] =
   Future.successful(h)
}

val cursor: Cursor[String] = new MyTestCursor("foo")

def foo(implicit ec: ExecutionContext): Unit = {
 cursor.headOption // Future.failed by default

 cursor.head // Future.successful("foo")

 ()
}

Attributes

Graph
Supertypes
trait Cursor[T]
class Object
trait Matchable
class Any

Members list

Value members

Concrete methods

def collect[M[_]](maxDocs: Int, err: () => M[T])(implicit cbf: Factory[T, M[T]], ec: ExecutionContext): Future[M[T]]

$collect.

$collect.

Value parameters

err

$errorHandlerParam (default: Cursor.FailOnError)

import scala.concurrent.ExecutionContext
import reactivemongo.api.Cursor
import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection
def foo(collection: BSONCollection, query: BSONDocument)(
 implicit ec: ExecutionContext) = {
 val cursor = collection.find(query).cursor[BSONDocument]()
 // return the 3 first documents in a Vector[BSONDocument].
 cursor.collect[Vector](3, Cursor.FailOnError[Vector[BSONDocument]]())
}
maxDocs

$maxDocsParam.

Attributes

def foldBulks[A](z: => A, maxDocs: Int)(suc: (A, Iterator[T]) => State[A], err: () => A)(implicit ctx: ExecutionContext): Future[A]

$foldBulks

$foldBulks

Type parameters

A

$resultTParam

import reactivemongo.api.Cursor
import scala.concurrent.ExecutionContext
case class Person(name: String, age: Int)
def foo(cursor: Cursor[Person])(implicit ec: ExecutionContext) =
 cursor.foldBulks(Nil: Seq[Person])(
   (s, bulk: Iterator[Person]) => Cursor.Cont(s ++ bulk),
   { (l, e) => println("last valid value: " + l); Cursor.Fail(e) })

Value parameters

err

$errorHandlerParam

maxDocs

$maxDocsParam. $maxDocsWarning.

suc

$sucRespParam.

z

$zeroParam

Attributes

def foldBulksM[A](z: => A, maxDocs: Int)(suc: (A, Iterator[T]) => Future[State[A]], err: () => A)(implicit ctx: ExecutionContext): Future[A]

$foldBulks

$foldBulks

Type parameters

A

$resultTParam

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.Cursor
case class Person(name: String, age: Int)
def foo(cursor: Cursor[Person])(implicit ec: ExecutionContext) =
 cursor.foldBulksM(Nil: Seq[Person])(
   { (s, bulk: Iterator[Person]) =>
    Future.successful(Cursor.Cont(s ++ bulk))
  },
   { (l, e) =>
     println("last valid value: " + l)
     Cursor.Fail[Seq[Person]](e)
   })

Value parameters

err

$errorHandlerParam

maxDocs

$maxDocsParam. $maxDocsWarning.

suc

$sucRespParam. $sucSafeWarning.

z

$zeroParam

Attributes

def foldWhile[A](z: => A, maxDocs: Int)(suc: (A, T) => State[A], err: () => A)(implicit ctx: ExecutionContext): Future[A]

$foldWhile

$foldWhile

Type parameters

A

$resultTParam

import reactivemongo.api.Cursor
import scala.concurrent.ExecutionContext
case class Person(name: String, age: Int)
def foo(cursor: Cursor[Person])(implicit ec: ExecutionContext) =
 cursor.foldWhile(Nil: Seq[Person])((s, p) => Cursor.Cont(s :+ p),
   { (l, e) => println("last valid value: " + l); Cursor.Fail(e) })

Value parameters

err

$errorHandlerParam

maxDocs

$maxDocsParam.

suc

$sucDocParam.

z

$zeroParam

Attributes

def foldWhileM[A](z: => A, maxDocs: Int)(suc: (A, T) => Future[State[A]], err: () => A)(implicit ctx: ExecutionContext): Future[A]

$foldWhile

$foldWhile

Type parameters

A

$resultTParam

import scala.concurrent.{ ExecutionContext, Future }
import reactivemongo.api.Cursor
case class Person(name: String, age: Int)
def foo(cursor: Cursor[Person])(implicit ec: ExecutionContext) =
 cursor.foldWhileM(Nil: Seq[Person])(
   (s, p) => Future.successful(Cursor.Cont(s :+ p)),
   { (l, e) =>
     println("last valid value: " + l)
     Cursor.Fail[Seq[Person]](e)
   })

Value parameters

err

$errorHandlerParam

maxDocs

$maxDocsParam.

suc

$sucDocParam. $sucSafeWarning.

z

$zeroParam

Attributes

def head(implicit ctx: ExecutionContext): Future[T]

$getHead, or fails with Cursor.NoSuchResultException if none.

$getHead, or fails with Cursor.NoSuchResultException if none.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.bson.BSONDocument
import reactivemongo.api.bson.collection.BSONCollection

def first(query: BSONDocument)(collection: BSONCollection)(
 implicit ec: ExecutionContext): Future[BSONDocument] = {
 val cursor = collection.find(query).cursor[BSONDocument]()
 // return option of the first element.
 cursor.head
}

Attributes

def headOption(implicit ctx: ExecutionContext): Future[Option[T]]

$getHead, if any.

$getHead, if any.

import scala.concurrent.{ ExecutionContext, Future }

import reactivemongo.api.bson.BSONDocument

import reactivemongo.api.bson.collection.BSONCollection

def maybeFirst(query: BSONDocument)(collection: BSONCollection)(
 implicit ec: ExecutionContext): Future[Option[BSONDocument]] = {
 val cursor = collection.find(query).cursor[BSONDocument]()
 // return option of the first element.
 cursor.headOption
}

Attributes

def peek[M[_]](maxDocs: Int)(implicit cbf: Factory[T, M[T]], ec: ExecutionContext): Future[Result[M[T]]]

'''EXPERIMENTAL:''' The cursor state, if already resolved.

'''EXPERIMENTAL:''' The cursor state, if already resolved.

Attributes

Inherited methods

def fold[A](z: => A, maxDocs: Int)(suc: (A, T) => A)(implicit ec: ExecutionContext): Future[A]

Applies a binary operator to a start value and all elements retrieved by this cursor, going first to last.

Applies a binary operator to a start value and all elements retrieved by this cursor, going first to last.

Type parameters

A

the result type of the binary operator

import scala.concurrent.ExecutionContext
import reactivemongo.api.Cursor
case class Person(name: String, age: Int)
def foo(cursor: Cursor[Person])(implicit ec: ExecutionContext) =
 cursor.foldWhile(Nil: Seq[Person])((s, p) => Cursor.Cont(s :+ p),
   { (l, e) => println("last valid value: " + l); Cursor.Fail(e) })

Value parameters

err

The binary operator to be applied when failing to get the next response. Exception or Fail raised within the suc function cannot be recovered by this error handler.

maxDocs

the maximum number of documents to be retrieved (-1 for unlimited).

suc

The binary operator to be applied when the next document is successfully read.

z

the initial value

Attributes

Inherited from:
Cursor
Generated with