trait Cursor[T] extends CursorCompatAPI[T]
Cursor over results from MongoDB.
import scala.concurrent.{ ExecutionContext, Future } import reactivemongo.api.Cursor import reactivemongo.api.bson.{ BSONDocument, BSONDocumentReader, Macros } import reactivemongo.api.bson.collection.BSONCollection case class User(name: String, pass: String) implicit val reader: BSONDocumentReader[User] = Macros.reader[User] def findUsers(coll: BSONCollection)( implicit ec: ExecutionContext): Future[List[User]] = coll.find(BSONDocument("enabled" -> true)). cursor[User](). // obtain cursor for User results collect[List]( maxDocs = 10, err = Cursor.FailOnError[List[User]]())
- T
the type parsed from each result document
- Alphabetic
- By Inheritance
- Cursor
- CursorCompatAPI
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
def
collect[M[_]](maxDocs: Int = Int.MaxValue, err: ErrorHandler[M[T]] = Cursor.FailOnError[M[T]]())(implicit cbf: CanBuildFrom[M[_], T, M[T]], ec: ExecutionContext): Future[M[T]]
Collects all the documents into a collection of type
M[T]
.Collects all the documents into a collection of type
M[T]
.- maxDocs
the maximum number of documents to be retrieved (-1 for unlimited).
- 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. (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]]()) }
- Definition Classes
- CursorCompatAPI
-
abstract
def
foldBulks[A](z: ⇒ A, maxDocs: Int = -1)(suc: (A, Iterator[T]) ⇒ State[A], err: ErrorHandler[A] = FailOnError[A]())(implicit ec: ExecutionContext): Future[A]
Applies a binary operator to a start value and all bulks of documents retrieved by this cursor, going first to last.
Applies a binary operator to a start value and all bulks of documents retrieved by this cursor, going first to last.
- A
the result type of the binary operator
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) })
- z
the initial value
- maxDocs
the maximum number of documents to be retrieved (-1 for unlimited). The actual document count can exceed this, when this maximum devided by the batch size given a non-zero remainder.
- suc
The binary operator to be applied when the next response is successfully read.
- 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.
-
abstract
def
foldBulksM[A](z: ⇒ A, maxDocs: Int = -1)(suc: (A, Iterator[T]) ⇒ Future[State[A]], err: ErrorHandler[A] = FailOnError[A]())(implicit ec: ExecutionContext): Future[A]
Applies a binary operator to a start value and all bulks of documents retrieved by this cursor, going first to last.
Applies a binary operator to a start value and all bulks of documents retrieved by this cursor, going first to last.
- A
the result type of the binary operator
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) })
- z
the initial value
- maxDocs
the maximum number of documents to be retrieved (-1 for unlimited). The actual document count can exceed this, when this maximum devided by the batch size given a non-zero remainder.
- suc
The binary operator to be applied when the next response is successfully read. This must be safe, and any error must be returned as
Future.failed[State[A]]
.- 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.
-
abstract
def
foldWhile[A](z: ⇒ A, maxDocs: Int = -1)(suc: (A, T) ⇒ State[A], err: ErrorHandler[A] = FailOnError[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.
- A
the result type of the binary operator
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) })
- z
the initial value
- 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.
- 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.
-
abstract
def
foldWhileM[A](z: ⇒ A, maxDocs: Int = -1)(suc: (A, T) ⇒ Future[State[A]], err: ErrorHandler[A] = FailOnError[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.
- A
the result type of the binary operator
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) })
- z
the initial value
- 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. This must be safe, and any error must be returned as
Future.failed[State[A]]
.- 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.
-
abstract
def
head(implicit ec: ExecutionContext): Future[T]
Returns the first document matching the query, or fails with Cursor.NoSuchResultException if none.
Returns the first document matching the query, 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 }
-
abstract
def
headOption(implicit ec: ExecutionContext): Future[Option[T]]
Returns the first document matching the query, if any.
Returns the first document matching the query, 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 }
-
abstract
def
peek[M[_]](maxDocs: Int)(implicit cbf: CanBuildFrom[M[_], T, M[T]], ec: ExecutionContext): Future[Result[M[T]]]
EXPERIMENTAL: The cursor state, if already resolved.
EXPERIMENTAL: The cursor state, if already resolved.
- Definition Classes
- CursorCompatAPI
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (Cursor[T], B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- def ensuring(cond: (Cursor[T]) ⇒ Boolean, msg: ⇒ Any): Cursor[T]
- def ensuring(cond: (Cursor[T]) ⇒ Boolean): Cursor[T]
- def ensuring(cond: Boolean, msg: ⇒ Any): Cursor[T]
- def ensuring(cond: Boolean): Cursor[T]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
fold[A](z: ⇒ A, maxDocs: Int = -1)(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.
- 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) })
- z
the initial value
- 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.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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( ... ) @native()
- def →[B](y: B): (Cursor[T], B)
Deprecated Value Members
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from Cursor[T] to StringFormat[Cursor[T]] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.12.16) Use
formatString.format(value)
instead ofvalue.formatted(formatString)
, or use thef""
string interpolator. In Java 15 and later,formatted
resolves to the new method in String which has reversed parameters.