Mongo Scala Driver - org.mongodb.scala.bson.collection.immutable.Document (original) (raw)

case class Document(underlying: BsonDocument) extends BaseDocument[Document] with IterableOps[(String, BsonValue), Iterable, Document] with StrictOptimizedIterableOps[(String, BsonValue), Iterable, Document] with Product with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Document

2. Serializable

3. Product

4. Equals

5. StrictOptimizedIterableOps

6. BaseDocument

7. Bson

8. Iterable

9. IterableFactoryDefaults

10. IterableOps

11. IterableOnceOps

12. IterableOnce

13. AnyRef

14. Any

15. Hide All

16. Show All

Visibility

1. Public
2. Protected

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(elems: CanBeBsonElement*): Document
4.  final def ++(suffix: IterableOnce[(String, BsonValue)]): Document
5.  final def ++[B >: (String, BsonValue)](suffix: IterableOnce[B]): Iterable[B]
6.  def -(elems: String*): Document
7.  def --(xs: GenTraversableOnce[String]): Document
8.  final def ==(arg0: Any): Boolean
9.  final def addString(b: StringBuilder): StringBuilder
10.  final def addString(b: StringBuilder, sep: String): StringBuilder
11.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
12.  def apply(underlying: BsonDocument): Document
13.  def apply[TResult <: BsonValue](key: String)(implicit e: DefaultsTo[TResult, BsonValue], ct: ClassTag[TResult]): TResult
14.  final def asInstanceOf[T0]: T0
15.  def className: String
16.  def clone(): AnyRef
17.  final def coll: Document.this.type
18.  def collect[B](pf: PartialFunction[(String, BsonValue), B]): Iterable[B]
19.  def collectFirst[B](pf: PartialFunction[(String, BsonValue), B]): Option[B]
20.  def concat(suffix: IterableOnce[(String, BsonValue)]): Document
21.  def concat[B >: (String, BsonValue)](suffix: IterableOnce[B]): Iterable[B]
22.  def contains(key: String): Boolean
23.  def copyToArray[B >: (String, BsonValue)](xs: Array[B], start: Int, len: Int): Int
24.  def copyToArray[B >: (String, BsonValue)](xs: Array[B], start: Int): Int
25.  def copyToArray[B >: (String, BsonValue)](xs: Array[B]): Int
26.  def corresponds[B](that: IterableOnce[B])(p: ((String, BsonValue), B) => Boolean): Boolean
27.  def count(p: ((String, BsonValue)) => Boolean): Int
28.  def drop(n: Int): Document
29.  def dropRight(n: Int): Document
30.  def dropWhile(p: ((String, BsonValue)) => Boolean): Document
31.  def empty: Document
32.  final def eq(arg0: AnyRef): Boolean
33.  def exists(p: ((String, BsonValue)) => Boolean): Boolean
34.  def filter(pred: ((String, BsonValue)) => Boolean): Document
35.  def filterImpl(pred: ((String, BsonValue)) => Boolean, isFlipped: Boolean): Document
36.  def filterKeys(p: (String) => Boolean): Document
37.  def filterNot(pred: ((String, BsonValue)) => Boolean): Document
38.  def finalize(): Unit
39.  def find(p: ((String, BsonValue)) => Boolean): Option[(String, BsonValue)]
40.  def flatMap[B](f: ((String, BsonValue)) => IterableOnce[B]): Iterable[B]
41.  def flatten[B](implicit toIterableOnce: ((String, BsonValue)) => IterableOnce[B]): Iterable[B]
42.  def fold[A1 >: (String, BsonValue)](z: A1)(op: (A1, A1) => A1): A1
43.  def foldLeft[B](z: B)(op: (B, (String, BsonValue)) => B): B
44.  def foldRight[B](z: B)(op: ((String, BsonValue), B) => B): B
45.  def forall(p: ((String, BsonValue)) => Boolean): Boolean
46.  def foreach[U](f: ((String, BsonValue)) => U): Unit
47.  def fromSpecific(coll: IterableOnce[(String, BsonValue)]): Document
48.  def get[TResult <: BsonValue](key: String)(implicit e: DefaultsTo[TResult, BsonValue], ct: ClassTag[TResult]): Option[TResult]
49.  final def getClass(): Class[_ <: AnyRef]
50.  def getOrElse[B >: BsonValue](key: String, default: CanBeBsonValue): B
51.  def groupBy[K](f: ((String, BsonValue)) => K): Map[K, Document]
52.  def groupMap[K, B](key: ((String, BsonValue)) => K)(f: ((String, BsonValue)) => B): Map[K, Iterable[B]]
53.  def groupMapReduce[K, B](key: ((String, BsonValue)) => K)(f: ((String, BsonValue)) => B)(reduce: (B, B) => B): Map[K, B]
54.  def grouped(size: Int): Iterator[Document]
55.  def head: (String, BsonValue)
56.  def headOption: Option[(String, BsonValue)]
57.  def init: Document
58.  def inits: Iterator[Document]
59.  def isEmpty: Boolean
60.  final def isInstanceOf[T0]: Boolean
61.  def isTraversableAgain: Boolean
62.  def iterableFactory: IterableFactory[Iterable]
63.  def iterator: Iterator[(String, BsonValue)]
64.  def keySet: Set[String]
65.  def keys: Iterable[String]
66.  def keysIterator: Iterator[String]
67.  def knownSize: Int
68.  def last: (String, BsonValue)
69.  def lastOption: Option[(String, BsonValue)]
70.  def lazyZip[B](that: Iterable[B]): LazyZip2[(String, BsonValue), B, Document.this.type]
71.  def map[B](f: ((String, BsonValue)) => (String, BsonValue)): Document
72.  def map[B](f: ((String, BsonValue)) => B): Iterable[B]
73.  def max[B >: (String, BsonValue)](implicit ord: Ordering[B]): (String, BsonValue)
74.  def maxBy[B](f: ((String, BsonValue)) => B)(implicit cmp: Ordering[B]): (String, BsonValue)
75.  def maxByOption[B](f: ((String, BsonValue)) => B)(implicit cmp: Ordering[B]): Option[(String, BsonValue)]
76.  def maxOption[B >: (String, BsonValue)](implicit ord: Ordering[B]): Option[(String, BsonValue)]
77.  def min[B >: (String, BsonValue)](implicit ord: Ordering[B]): (String, BsonValue)
78.  def minBy[B](f: ((String, BsonValue)) => B)(implicit cmp: Ordering[B]): (String, BsonValue)
79.  def minByOption[B](f: ((String, BsonValue)) => B)(implicit cmp: Ordering[B]): Option[(String, BsonValue)]
80.  def minOption[B >: (String, BsonValue)](implicit ord: Ordering[B]): Option[(String, BsonValue)]
81.  final def mkString: String
82.  final def mkString(sep: String): String
83.  final def mkString(start: String, sep: String, end: String): String
84.  final def ne(arg0: AnyRef): Boolean
85.  def newSpecificBuilder: Builder[(String, BsonValue), Document]
86.  def nonEmpty: Boolean
87.  final def notify(): Unit
88.  final def notifyAll(): Unit
89.  def partition(p: ((String, BsonValue)) => Boolean): (Document, Document)
90.  def partitionMap[A1, A2](f: ((String, BsonValue)) => Either[A1, A2]): (Iterable[A1], Iterable[A2])
91.  def product[B >: (String, BsonValue)](implicit num: Numeric[B]): B
92.  def productElementNames: Iterator[String]
93.  def reduce[B >: (String, BsonValue)](op: (B, B) => B): B
94.  def reduceLeft[B >: (String, BsonValue)](op: (B, (String, BsonValue)) => B): B
95.  def reduceLeftOption[B >: (String, BsonValue)](op: (B, (String, BsonValue)) => B): Option[B]
96.  def reduceOption[B >: (String, BsonValue)](op: (B, B) => B): Option[B]
97.  def reduceRight[B >: (String, BsonValue)](op: ((String, BsonValue), B) => B): B
98.  def reduceRightOption[B >: (String, BsonValue)](op: ((String, BsonValue), B) => B): Option[B]
99.  def reversed: Iterable[(String, BsonValue)]
100.  def scan[B >: (String, BsonValue)](z: B)(op: (B, B) => B): Iterable[B]
101.  def scanLeft[B](z: B)(op: (B, (String, BsonValue)) => B): Iterable[B]
102.  def scanRight[B](z: B)(op: ((String, BsonValue), B) => B): Iterable[B]
103.  def size: Int
104.  def sizeCompare(that: Iterable[_]): Int
105.  def sizeCompare(otherSize: Int): Int
106.  final def sizeIs: SizeCompareOps
107.  def slice(from: Int, until: Int): Document
108.  def sliding(size: Int, step: Int): Iterator[Document]
109.  def sliding(size: Int): Iterator[Document]
110.  def span(p: ((String, BsonValue)) => Boolean): (Document, Document)
111.  def splitAt(n: Int): (Document, Document)
112.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[(String, BsonValue), S]): S
113.  final def strictOptimizedCollect[B, C2](b: Builder[B, C2], pf: PartialFunction[(String, BsonValue), B]): C2
114.  final def strictOptimizedConcat[B >: (String, BsonValue), C2](that: IterableOnce[B], b: Builder[B, C2]): C2
115.  final def strictOptimizedFlatMap[B, C2](b: Builder[B, C2], f: ((String, BsonValue)) => IterableOnce[B]): C2
116.  final def strictOptimizedFlatten[B, C2](b: Builder[B, C2])(implicit toIterableOnce: ((String, BsonValue)) => IterableOnce[B]): C2
117.  final def strictOptimizedMap[B, C2](b: Builder[B, C2], f: ((String, BsonValue)) => B): C2
118.  final def strictOptimizedZip[B, C2](that: IterableOnce[B], b: Builder[((String, BsonValue), B), C2]): C2
119.  def stringPrefix: String
120.  def sum[B >: (String, BsonValue)](implicit num: Numeric[B]): B
121.  final def synchronized[T0](arg0: => T0): T0
122.  def tail: Document
123.  def tails: Iterator[Document]
124.  def take(n: Int): Document
125.  def takeRight(n: Int): Document
126.  def takeWhile(p: ((String, BsonValue)) => Boolean): Document
127.  def tapEach[U](f: ((String, BsonValue)) => U): Document
128.  def to[C1](factory: Factory[(String, BsonValue), C1]): C1
129.  def toArray[B >: (String, BsonValue)](implicit arg0: ClassTag[B]): Array[B]
130.  def toBsonDocument[TDocument](documentClass: Class[TDocument], codecRegistry: CodecRegistry): BsonDocument
131.  def toBsonDocument: BsonDocument
132.  final def toBuffer[B >: (String, BsonValue)]: Buffer[B]
133.  def toIndexedSeq: IndexedSeq[(String, BsonValue)]
134.  final def toIterable: Document.this.type
135.  def toJson(settings: JsonWriterSettings): String
136.  def toJson(): String
137.  def toList: List[(String, BsonValue)]
138.  def toMap[K, V](implicit ev: <:<[(String, BsonValue), (K, V)]): Map[K, V]
139.  def toSeq: Seq[(String, BsonValue)]
140.  def toSet[B >: (String, BsonValue)]: Set[B]
141.  def toString(): String
142.  def toVector: Vector[(String, BsonValue)]
143.  def transpose[B](implicit asIterable: ((String, BsonValue)) => Iterable[B]): Iterable[Iterable[B]]
144.  val underlying: BsonDocument
145.  def unzip[A1, A2](implicit asPair: ((String, BsonValue)) => (A1, A2)): (Iterable[A1], Iterable[A2])
146.  def unzip3[A1, A2, A3](implicit asTriple: ((String, BsonValue)) => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
147.  def updated(elems: CanBeBsonElement*): Document
148.  def updated[B](key: String, value: B)(implicit transformer: BsonTransformer[B]): Document
149.  def values: Iterable[BsonValue]
150.  def valuesIterator: Iterator[BsonValue]
151.  def view: View[(String, BsonValue)]
152.  final def wait(): Unit
153.  final def wait(arg0: Long, arg1: Int): Unit
154.  final def wait(arg0: Long): Unit
155.  def withFilter(p: ((String, BsonValue)) => Boolean): WithFilter[(String, BsonValue), Iterable]
156.  def zip[B](that: IterableOnce[B]): Iterable[((String, BsonValue), B)]
157.  def zipAll[A1 >: (String, BsonValue), B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
158.  def zipWithIndex: Iterable[((String, BsonValue), Int)]

Deprecated Value Members

1.  def ++:[B >: (String, BsonValue)](that: IterableOnce[B]): Iterable[B]
2.  final def /:[B](z: B)(op: (B, (String, BsonValue)) => B): B
3.  final def :\[B](z: B)(op: ((String, BsonValue), B) => B): B
4.  def aggregate[B](z: => B)(seqop: (B, (String, BsonValue)) => B, combop: (B, B) => B): B
5.  def companion: IterableFactory[Iterable]
6.  final def copyToBuffer[B >: (String, BsonValue)](dest: Buffer[B]): Unit
7.  def hasDefiniteSize: Boolean
8.  final def repr: Document
9.  def seq: Document.this.type
10.  final def toIterator: Iterator[(String, BsonValue)]
11.  final def toStream: Stream[(String, BsonValue)]
12.  final def toTraversable: Traversable[(String, BsonValue)]
13.  def view(from: Int, until: Int): View[(String, BsonValue)]

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from StrictOptimizedIterableOps[(String, BsonValue), Iterable, Document]

Inherited from BaseDocument[Document]

Inherited from Bson

Inherited from Iterable[(String, BsonValue)]

Inherited from IterableFactoryDefaults[(String, BsonValue), Iterable]

Inherited from IterableOps[(String, BsonValue), Iterable, Document]

Inherited from IterableOnceOps[(String, BsonValue), Iterable, Document]

Inherited from IterableOnce[(String, BsonValue)]

Inherited from AnyRef

Inherited from Any

Ungrouped