MongoMetaRecord

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit lazy val _formats: Formats

lazy val allFormats: Formats

def appendDispatch(func: PartialFunction[Req, (BaseRecord) ⇒ Box[LiftResponse]]): RulesSeq[PartialFunction[Req, () ⇒ Box[LiftResponse]]]

final def asInstanceOf[T0]: T0

def asJObject(rec: BaseRecord): JObject

def asJSON(inst: BaseRecord): JsObj

def asJValue(rec: BaseRecord): JValue

def asJsExp(inst: BaseRecord): JsExp

def bsonTransformer: Transformer

def bsonTypeClassMap: BsonTypeClassMap

The BsonTypeClassMap to use with this record.

def bulkDelete_!!(k: String, o: Any): Unit

def bulkDelete_!!(qry: Bson): Unit

def clone(): AnyRef

def codec: CollectibleRecordCodec[BaseRecord]

def codecRegistry: CodecRegistry

def collectionName: String

def connectionIdentifier: ConnectionIdentifier

def copy(rec: BaseRecord): BaseRecord

def count(qry: JObject): Box[Long]

def count(qry: Bson): Box[Long]

def count: Box[Long]

def countDistinct(key: String, query: Bson): Box[Long]

def createIndex(keys: JObject, uniq: Boolean): Box[String]

def createIndex(keys: JObject): Box[String]

def createIndex(keys: JObject, opts: IndexOptions): Box[String]

def createIndex(keys: Bson, uniq: Boolean): Box[String]

def createIndex(keys: Bson): Box[String]

def createIndex(keys: Bson, opts: IndexOptions): Box[String]

def createRecord: BaseRecord

def createWithMutableField[FieldType](original: BaseRecord, field: Field[FieldType, BaseRecord], newValue: Box[FieldType]): BaseRecord

def deleteMany(qry: JObject, opts: DeleteOptions): Box[DeleteResult]

def deleteMany(qry: JObject): Box[DeleteResult]

def deleteMany(qry: Bson, opts: DeleteOptions): Box[DeleteResult]

def deleteMany(qry: Bson): Box[DeleteResult]

def deleteOne(inst: BaseRecord): Box[DeleteResult]

def deleteOne(inst: BaseRecord, opts: DeleteOptions): Box[DeleteResult]

def deleteOne(k: String, v: Any, opts: DeleteOptions): Box[DeleteResult]

def deleteOne(qry: JObject, opts: DeleteOptions): Box[DeleteResult]

def deleteOne(qry: JObject): Box[DeleteResult]

def deleteOne(qry: Bson, opts: DeleteOptions): Box[DeleteResult]

def deleteOne(qry: Bson): Box[DeleteResult]

def delete_!(inst: BaseRecord): Boolean

Delete the instance from backing store

def diff(inst: BaseRecord, other: BaseRecord): Seq[(String, Any, Any)]

def dirty_?(inst: BaseRecord): Boolean

def drop: Box[Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldByName(fieldName: String, inst: BaseRecord): Box[Field[_, BaseRecord]]

def fieldOrder: List[Field[_, BaseRecord]]

def fields(rec: BaseRecord): List[Field[_, BaseRecord]]

def finalize(): Unit

def find(k: String, o: Any): Box[BaseRecord]

Find a single row by a qry using String key and Any value

def find(json: JObject): Box[BaseRecord]

Find a single document by a qry using a json value

def find(id: Long): Box[BaseRecord]

Find a single row by a Long id

def find(id: Int): Box[BaseRecord]

Find a single row by an Int id

def find(s: String): Box[BaseRecord]

Find a single row by a String id

def find(uid: UUID): Box[BaseRecord]

Find a single row by a UUID

def find(oid: ObjectId): Box[BaseRecord]

Find a single row by an ObjectId

def find(qry: Bson): Box[BaseRecord]

Find a single row by a qry, using a Bson.

def findAll(ids: List[ObjectId]): List[BaseRecord]

def findAll(k: String, o: Any, sort: JObject, opts: FindOption*): List[BaseRecord]

Find all documents using a k, v query with JOBject sort

def findAll(k: String, o: Any, opts: FindOption*): List[BaseRecord]

Find all documents using a k, v query

def findAll(qry: JObject, sort: JObject, opts: FindOption*): List[BaseRecord]

Find all documents using a JObject query with sort

def findAll(qry: JObject, opts: FindOption*): List[BaseRecord]

Find all documents using a JObject query

def findAll(qry: Bson, sort: Bson, opts: FindOption*): List[BaseRecord]

Find all documents using a Bson query with Bson sort

def findAll(qry: Bson, opts: FindOption*): List[BaseRecord]

Find all documents using a Bson query.

def findAll(qry: JObject, keys: JObject, sort: Option[JObject], opts: FindOption*): List[BaseRecord]

Find all rows and retrieve only keys fields.

def findAll(sort: Option[Bson], opts: FindOption*)(f: (MongoCollection[BaseRecord]) ⇒ FindIterable[BaseRecord]): List[BaseRecord]

def findAll(qry: Bson, keys: Bson, sort: Option[Bson], opts: FindOption*): List[BaseRecord]

Find all rows and retrieve only keys fields.

def findAll(qry: Bson, sort: Option[Bson], opts: FindOption*): List[BaseRecord]

Find all rows using a Bson query.

def findAll: List[BaseRecord]

Find all rows in this collection.

def findAllByList[T](ids: List[T]): List[BaseRecord]

Find all documents with the given ids

def findAny(a: Any): Box[BaseRecord]

Find a single row by Any This doesn't work as find because we need JObject's to be implicitly converted.

def fixCollectionName: String

def foreachCallback(inst: BaseRecord, f: (LifecycleCallbacks) ⇒ Any): Unit

var formTemplate: Box[NodeSeq]

def formats: Formats

def fromDocument(doc: Document): BaseRecord

def fromJValue(jvalue: JValue): Box[BaseRecord]

def fromJsonString(json: String): Box[BaseRecord]

def fromReq(r: Req): BaseRecord

final def getClass(): Class[_]

def hashCode(): Int

def insertAll(insts: List[BaseRecord]): Unit

Insert multiple records

def insertOne(inst: BaseRecord, opts: InsertOneOptions = new InsertOneOptions): Box[BaseRecord]

def instantiateRecord: BaseRecord

def introspect(rec: BaseRecord, methods: Array[Method])(f: (Method, Field[_, BaseRecord]) ⇒ Any): Unit

lazy val introspectedCodecRegistry: CodecRegistry

Check this record's fields and add any Codecs needed.

final def isInstanceOf[T0]: Boolean

def metaFields(): List[Field[_, BaseRecord]]

def mutable_?: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prependDispatch(func: PartialFunction[Req, (BaseRecord) ⇒ Box[LiftResponse]]): RulesSeq[PartialFunction[Req, () ⇒ Box[LiftResponse]]]

lazy val recordClass: Class[BaseRecord]

def replaceOne(inst: BaseRecord, opts: ReplaceOptions = new ReplaceOptions): Box[UpdateResult]

val rootClass: Class[?0] forSome {type ?0 >: ?0, type ?0 <: MetaRecord[BaseRecord] with BaseRecord}

def save(inst: BaseRecord): UpdateResult

Save the instance in the appropriate backing store.

def saveOperation[T](inst: BaseRecord)(f: ⇒ T): T

def setFieldsFromDocument(inst: BaseRecord, doc: Document): Unit

def setFieldsFromJValue(rec: BaseRecord, jvalue: JValue): Box[Unit]

def setFieldsFromJsonString(inst: BaseRecord, json: String): Box[Unit]

def setFieldsFromRecord(inst: BaseRecord, rec: BaseRecord): Unit

def setFieldsFromReq(inst: BaseRecord, req: Req): Unit

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

def toForm(inst: BaseRecord, template: NodeSeq): NodeSeq

def toForm(inst: BaseRecord): NodeSeq

def toString(): String

def toXHtml(inst: BaseRecord): NodeSeq

def updateMany(qry: JObject, update: JObject, opts: UpdateOptions): Box[UpdateResult]

def updateMany(qry: JObject, update: JObject): Box[UpdateResult]

def updateMany(qry: Bson, update: Bson, opts: UpdateOptions): Box[UpdateResult]

def updateMany(qry: Bson, update: Bson): Box[UpdateResult]

def updateOne(inst: BaseRecord, update: Bson, opts: UpdateOptions = new UpdateOptions): Box[UpdateResult]

def updateOne(qry: JObject, update: JObject, opts: UpdateOptions): Box[UpdateResult]

def updateOne(qry: JObject, update: JObject): Box[UpdateResult]

def updateOne(qry: Bson, update: Bson, opts: UpdateOptions): Box[UpdateResult]

def updateOne(qry: Bson, update: Bson): Box[UpdateResult]

def updateOp[T](inst: BaseRecord)(f: ⇒ T): T

def useCollection[T](f: (MongoCollection[BaseRecord]) ⇒ T): T

Use the collection associated with this Meta.

def useDatabase[T](f: (MongoDatabase) ⇒ T): T

Use the db associated with this Meta.

def validate(inst: BaseRecord): List[FieldError]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeConcern: WriteConcern

def asDBObject(inst: BaseRecord): DBObject

Create a BasicDBObject from the field names and values.

def asDocument(inst: BaseRecord): Document

def createIndex(keys: JObject, opts: JObject): Unit

def delete(qry: JObject): Unit

def delete(k: String, v: Any): Unit

def delete(qry: DBObject): Unit

def fieldDbValue(f: Field[_, BaseRecord]): Box[Any]

Return the value of a field suitable to be put in a DBObject

def fromDBObject(dbo: DBObject): BaseRecord

Creates a new record, then sets the fields with the given DBObject.

def insertAsync(inst: BaseRecord): Future[Boolean]

def replaceOneAsync(inst: BaseRecord, upsert: Boolean = true, concern: WriteConcern = MongoRules.defaultWriteConcern.vend): Future[BaseRecord]

Replaces document with new one with given id.

def save(inst: BaseRecord, db: DB, concern: WriteConcern): Boolean

Save a document to the db using the given Mongo instance

def save(inst: BaseRecord, concern: WriteConcern): Boolean

Save the instance in the appropriate backing store

def saveOp[T](inst: BaseRecord)(f: ⇒ T): Boolean

def setFieldsFromDBObject(inst: BaseRecord, dbo: DBObject): Unit

Populate the inst's fields with the values from a DBObject.

def update(inst: BaseRecord): Unit

Update only the dirty fields.

def update(obj: BaseRecord, update: DBObject): Unit

Update a record with a DBObject query

def update(query: DBObject, update: DBObject): Unit

Update one record with a DBObject query

def update(qry: JObject, newbr: BaseRecord, opts: UpdateOption*): Unit

Update records with a JObject query

def update(qry: JObject, newbr: BaseRecord, db: DB, opts: UpdateOption*): Unit

Update records with a JObject query using the given Mongo instance

def update(qry: JObject, newobj: JObject, opts: UpdateOption*): Unit

def update(qry: JObject, newobj: JObject, db: DB, opts: UpdateOption*): Unit

def update(qry: DBObject, newobj: DBObject, db: DB, opts: UpdateOption*): Unit

def updateMulti(query: DBObject, update: DBObject): Unit

Update multiple records with a DBObject query

def upsert(query: DBObject, update: DBObject): Unit

Upsert records with a DBObject query

def useColl[T](f: (DBCollection) ⇒ T): T

def useCollAsync[T](f: (MongoCollection[Document]) ⇒ T): T

def useDb[T](f: (DB) ⇒ T): T