QueryExecutor

def adapter : MongoJavaDriverAdapter[MB]

def defaultWriteConcern : WriteConcern

def optimizer : QueryOptimizer

def serializer [M <: MB, R] (meta: M, select: Option[MongoSelect[M, R]]): RogueSerializer[R]

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

implicit def anyValIsFlattened [A <: AnyVal] : Flattened[A, A]

def asInstanceOf [T0] : T0

implicit def booleanRFieldToModifyField [M] (f: Field[Boolean, M]): ModifyField[Boolean, M]

def bulkDelete_!! [M <: MB, State] (query: com.foursquare.rogue.Query[M, _, State], writeConcern: WriteConcern)(implicit ev1: Required[State, Unselected with Unlimited with Unskipped], ev2: ShardingOk[M, State]): Unit

implicit def byteRFieldToModifyField [M] (f: Field[Byte, M]): NumericModifyField[Byte, M]

implicit def charRFieldToModifyField [M] (f: Field[Char, M]): ModifyField[Char, M]

def clone (): AnyRef

def count [M <: MB, State] (query: com.foursquare.rogue.Query[M, _, State], readPreference: Option[ReadPreference])(implicit ev: ShardingOk[M, State]): Long

def countDistinct [M <: MB, V, State] (query: com.foursquare.rogue.Query[M, _, State], readPreference: Option[ReadPreference])(field: (M) ⇒ Field[V, M])(implicit ev: ShardingOk[M, State]): Long

implicit val dateIsFlattened : Flattened[Date, Date]

implicit def dateRFieldToDateModifyField [M] (f: Field[Date, M]): DateModifyField[M]

implicit def datetimeRFieldToDateModifyField [M] (f: Field[DateTime, M]): DateTimeModifyField[M]

def distinct [M <: MB, V, State] (query: com.foursquare.rogue.Query[M, _, State], readPreference: Option[ReadPreference])(field: (M) ⇒ Field[V, M])(implicit ev: ShardingOk[M, State]): List[V]

implicit def doubleRFieldToModifyField [M] (f: Field[Double, M]): NumericModifyField[Double, M]

implicit def enumIsFlattened [A <: Value] : Flattened[A, A]

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def explain [M <: MB] (query: com.foursquare.rogue.Query[M, _, _]): String

def fetch [M <: MB, R, State] (query: Query[M, R, State], readPreference: Option[ReadPreference])(implicit ev: ShardingOk[M, State]): List[R]

def fetchBatch [M <: MB, R, T, State] (query: Query[M, R, State], batchSize: Int, readPreference: Option[ReadPreference])(f: (List[R]) ⇒ List[T])(implicit ev: ShardingOk[M, State]): List[T]

def fetchOne [M <: MB, R, State, S2] (query: Query[M, R, State], readPreference: Option[ReadPreference])(implicit ev1: AddLimit[State, S2], ev2: ShardingOk[M, S2]): Option[R]

def finalize (): Unit

def findAndDeleteOne [M <: MB, R, State] (query: Query[M, R, State], writeConcern: WriteConcern)(implicit ev: RequireShardKey[M, State]): Option[R]

def findAndUpdateOne [M <: MB, R] (query: FindAndModifyQuery[M, R], returnNew: Boolean, writeConcern: WriteConcern): Option[R]

def findAndUpsertOne [M <: MB, R] (query: FindAndModifyQuery[M, R], returnNew: Boolean, writeConcern: WriteConcern): Option[R]

implicit def floatRFieldToModifyField [M] (f: Field[Float, M]): NumericModifyField[Float, M]

def foreach [M <: MB, R, State] (query: Query[M, R, State], readPreference: Option[ReadPreference])(f: (R) ⇒ Unit)(implicit ev: ShardingOk[M, State]): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

implicit def intRFieldToModifyField [M] (f: Field[Int, M]): NumericModifyField[Int, M]

def isInstanceOf [T0] : Boolean

def iterate [S, M <: MB, R, State] (query: Query[M, R, State], state: S, readPreference: Option[ReadPreference])(handler: (S, Event[R]) ⇒ Command[S])(implicit ev: ShardingOk[M, State]): S

def iterateBatch [S, M <: MB, R, State] (query: Query[M, R, State], batchSize: Int, state: S, readPreference: Option[ReadPreference])(handler: (S, Event[List[R]]) ⇒ Command[S])(implicit ev: ShardingOk[M, State]): S

implicit def longRFieldToModifyField [M, F <: Long] (f: Field[F, M]): NumericModifyField[F, M]

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

implicit val objectIdIsFlattened : Flattened[ObjectId, ObjectId]

implicit def objectidRFieldToModifyField [M, F <: ObjectId] (f: Field[F, M]): ModifyField[F, M]

implicit def rSeqFieldToSeqModifyField [M, F] (f: Field[Seq[F], M])(implicit arg0: BSONType[F]): SeqModifyField[F, M]

implicit def rStringsListFieldToStringsListQueryField [M] (f: Field[List[String], M]): StringsListQueryField[M]

implicit def rbooleanFieldtoQueryField [M] (f: Field[Boolean, M]): QueryField[Boolean, M]

implicit def rbyteFieldtoNumericQueryField [M] (f: Field[Byte, M]): NumericQueryField[Byte, M]

implicit def rcharFieldtoQueryField [M] (f: Field[Char, M]): QueryField[Char, M]

implicit def rdateFieldToDateQueryField [M] (f: Field[Date, M]): DateQueryField[M]

implicit def rdatetimeFieldToDateQueryField [M] (f: Field[DateTime, M]): DateTimeQueryField[M]

implicit def rdbobjectFieldToQueryField [M] (f: Field[DBObject, M]): QueryField[DBObject, M]

implicit def rdoubleFieldtoNumericQueryField [M] (f: Field[Double, M]): NumericQueryField[Double, M]

implicit def recursiveFlattenList [A, B] (implicit ev: Flattened[A, B]): Flattened[List[A], B]

implicit def recursiveFlattenSeq [A, B] (implicit ev: Flattened[A, B]): Flattened[Seq[A], B]

implicit def renumNameFieldToEnumNameQueryField [M, F <: Value] (f: Field[F, M]): EnumNameQueryField[M, F]

implicit def renumerationFieldToEnumerationModifyField [M, F <: Value] (f: Field[F, M]): EnumerationModifyField[M, F]

implicit def renumerationListFieldToEnumerationListModifyField [M, F <: Value] (f: Field[List[F], M]): EnumerationListModifyField[F, M]

implicit def renumerationListFieldToEnumerationListQueryField [M, F <: Value] (f: Field[List[F], M]): EnumerationListQueryField[F, M]

implicit def rfieldToSafeModifyField [M, F] (f: Field[F, M]): SafeModifyField[F, M]

ModifyField implicits

implicit def rfloatFieldtoNumericQueryField [M] (f: Field[Float, M]): NumericQueryField[Float, M]

implicit def rintFieldtoNumericQueryField [M] (f: Field[Int, M]): NumericQueryField[Int, M]

implicit def rjlongFieldtoNumericQueryField [F <: Long, M] (f: Field[F, M]): NumericQueryField[F, M]

implicit def rlatLongFieldToGeoQueryField [M] (f: Field[LatLong, M]): GeoQueryField[M]

implicit def rlatLongFieldToGeoQueryModifyField [M] (f: Field[LatLong, M]): GeoModifyField[M]

implicit def rlistFieldToListModifyField [M, F] (f: Field[List[F], M])(implicit arg0: BSONType[F]): ListModifyField[F, M]

implicit def rlistFieldToListQueryField [M, F] (f: Field[List[F], M])(implicit arg0: BSONType[F]): ListQueryField[F, M]

implicit def rlongFieldtoNumericQueryField [F <: Long, M] (f: Field[F, M]): NumericQueryField[F, M]

implicit def rmapFieldToMapModifyField [M, F] (f: Field[Map[String, F], M]): MapModifyField[F, M]

implicit def rmapFieldToMapQueryField [M, F] (f: Field[Map[String, F], M]): MapQueryField[F, M]

implicit def robjectIdFieldToObjectIdQueryField [F <: ObjectId, M] (f: Field[F, M]): ObjectIdQueryField[F, M]

implicit def roptionalFieldToSelectField [M, V] (f: OptionalField[V, M]): SelectField[Option[V], M]

implicit def rrequiredFieldToSelectField [M, V] (f: RequiredField[V, M]): SelectField[V, M]

implicit def rseqFieldToSeqQueryField [M, F] (f: Field[Seq[F], M])(implicit arg0: BSONType[F]): SeqQueryField[F, M]

implicit def rshortFieldtoNumericQueryField [M] (f: Field[Short, M]): NumericQueryField[Short, M]

implicit def rstringFieldToStringQueryField [F <: String, M] (f: Field[F, M]): StringQueryField[F, M]

implicit def shortRFieldToModifyField [M] (f: Field[Short, M]): NumericModifyField[Short, M]

implicit val stringIsFlattened : Flattened[String, String]

implicit def stringRFieldToModifyField [M] (f: Field[String, M]): ModifyField[String, M]

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

def toString (): String

def updateMulti [M <: MB, State] (query: ModifyQuery[M, State], writeConcern: WriteConcern): Unit

def updateOne [M <: MB, State] (query: ModifyQuery[M, State], writeConcern: WriteConcern)(implicit ev: RequireShardKey[M, State]): Unit

def upsertOne [M <: MB, State] (query: ModifyQuery[M, State], writeConcern: WriteConcern)(implicit ev: RequireShardKey[M, State]): Unit

def wait (): Unit

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

def wait (arg0: Long): Unit