MetaMapper

abstract def getSingleton: MetaMapper[A]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def _dbTableNameLC: String

The table name, to lower case...

def addEndStuffs(in: String, params: List[QueryParam[A]], conn: SuperConnection): (String, Box[Long], Box[Long])

object addlQueryParams extends RequestVar[List[QueryParam[A]]]

def afterCommit: List[(A) ⇒ Unit]

def afterCreate: List[(A) ⇒ Unit]

def afterDelete: List[(A) ⇒ Unit]

def afterSave: List[(A) ⇒ Unit]

def afterSchemifier: Unit

def afterUpdate: List[(A) ⇒ Unit]

def afterValidation: List[(A) ⇒ Unit]

def afterValidationOnCreate: List[(A) ⇒ Unit]

def afterValidationOnUpdate: List[(A) ⇒ Unit]

def allFieldNames(): Seq[(String, SourceFieldMetadata)]

Get a list of all the fields

def allFields: Seq[BaseField]

def appendFieldToStrings(in: A): String

def appendFieldTransform(transform: CssSel): Unit

def asHtml(toLine: A): NodeSeq

def asHtml: NodeSeq

final def asInstanceOf[T0]: T0

def asJs(actual: A): JsExp

def asJs: JsExp

Convert the model to a JavaScript object

def asValid: Box[A]

Returns the instance in a Full Box if the instance is valid, otherwise returns a Failure with the validation errors

def beforeCreate: List[(A) ⇒ Unit]

def beforeDelete: List[(A) ⇒ Unit]

def beforeSave: List[(A) ⇒ Unit]

def beforeSchemifier: Unit

def beforeUpdate: List[(A) ⇒ Unit]

def beforeValidation: List[(A) ⇒ Unit]

def beforeValidationOnCreate: List[(A) ⇒ Unit]

def beforeValidationOnUpdate: List[(A) ⇒ Unit]

implicit def boundedFieldToItem(in: (MappedField[String, A], Int)): BoundedIndexField[A]

def buildMapper(rs: ResultSet): List[Box[(ResultSet, Int, A) ⇒ Unit]]

def buildSelectString(fields: Seq[SelectableField], conn: SuperConnection, by: QueryParam[A]*): (String, Box[Long], Box[Long], List[QueryParam[A]])

Given fields, a connection and the query parameters, build a query and return the query String, and Start or MaxRows values (depending on whether the driver supports LIMIT and OFFSET) and the complete List of QueryParams based on any synthetic query parameters calculated during the query creation.

def bulkDelete_!!(dbId: ConnectionIdentifier, by: QueryParam[A]*): Boolean

def bulkDelete_!!(by: QueryParam[A]*): Boolean

def checkNames: Unit

def clean_?(toCheck: A): Boolean

Returns true if none of the fields are dirty

def clone(): AnyRef

val columnNamesForInsert: String

def columnPrimaryKey_?(name: String): Boolean

This method returns true if the named column is the primary key and it is autogenerated

val columnQueriesForInsert: String

def comparePrimaryKeys(other: A): Boolean

def connectionIdentifier: ConnectionIdentifier

def connectionIdentifier(id: ConnectionIdentifier): A

def count(by: QueryParam[A]*): Long

def count: Long

def countByInsecureSql(query: String, checkedBy: IHaveValidatedThisSQL): Long

def countByInsecureSqlDb(dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): Long

def countDb(dbId: ConnectionIdentifier, by: QueryParam[A]*): Long

def countryField: Box[MappedCountry[A]]

def create: A

def createInstance: A

def createInstance(dbId: ConnectionIdentifier, rs: ResultSet, mapFuncs: List[Box[(ResultSet, Int, A) ⇒ Unit]]): A

def createInstances[T](dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long], f: (A) ⇒ Box[T]): List[T]

def createInstances(dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long]): List[A]

def dbAddTable: Box[() ⇒ Unit]

def dbCalculateConnectionIdentifier: PartialFunction[A, ConnectionIdentifier]

def dbDefaultConnectionIdentifier: ConnectionIdentifier

def dbIndexes: List[BaseIndex[A]]

def dbName: String

The name of the mapped object

def dbTableName: String

The name of the database table.

def db_can_delete_?: Boolean

Can this model object be deleted?

def decodeFromJSON_!(json: JObject, markFieldsAsDirty: Boolean): A

Decode the fields from a JSON Object.

def delete_!(toDelete: A): Boolean

def delete_!: Boolean

Delete the model from the RDBMS

def dirty_?(toTest: A): Boolean

def dirty_?: Boolean

var displayFieldAsLineElement: (NodeSeq) ⇒ NodeSeq

This function converts an element into the appropriate XHTML format for displaying across a line formatted block.

var displayNameToHeaderElement: (String) ⇒ NodeSeq

This function converts a header name into the appropriate XHTML format for displaying across the headers of a formatted block.

lazy val doAllFieldNames: Seq[(String, SourceFieldMetadata)]

Get a list of all the fields

def doHtmlLine(toLine: A): NodeSeq

def doPostCommit(func: () ⇒ Unit): A

Append a function to perform after the commit happens

val elemName: String

def encodeAsJSON_!(toEncode: A): JObject

This method will encode the instance as JSON.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldByName[T](fieldName: String, actual: A): Box[MappedField[T, A]]

Get a field by the field name

def fieldByName[T](fieldName: String): Box[MappedField[T, A]]

Find the field by name

def fieldMapperTransforms(fieldHtml: (BaseOwnedMappedField[A]) ⇒ NodeSeq, mappedObject: A): Seq[CssSel]

A set of CssSels that can be used to bind this MetaMapper's fields.

Seq(
".name" #> fieldHtml(-name field-),
".date" #> fieldHtml(-date field-),
".description" #> fieldHtml(-description field-)
)

def fieldMapperTransforms(fieldTransform: (BaseOwnedMappedField[A]) ⇒ NodeSeq): Seq[CssSel]

Given a function that takes a mapper field and returns a NodeSeq for the field, return, for this mapper instance, a set of CSS selector transforms that will transform a form for those fields into a fully-bound form that will interact with this instance.

lazy val fieldMatcher: PartialFunction[(A, String), MappedField[Any, A]]

A partial function that takes an instance of A and a field name and returns the mapped field

lazy val fieldNamesAsMap: Map[String, SourceFieldMetadata]

Get a list of all the fields as a map

def fieldOrder: List[BaseOwnedMappedField[A]]

implicit def fieldToItem[T](in: MappedField[T, A]): IndexItem[A]

def fieldTransforms: Seq[CssSel]

A list of CSS selector transforms that will help render the fields of this mapper object.

def finalize(): Unit

def findAll(by: QueryParam[A]*): List[A]

def findAll(): List[A]

def findAllByInsecureSql(query: String, checkedBy: IHaveValidatedThisSQL): List[A]

def findAllByInsecureSqlDb(dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): List[A]

def findAllByPreparedStatement(dbId: ConnectionIdentifier, stmt: PreparedStatement): List[A]

def findAllByPreparedStatement(f: (SuperConnection) ⇒ PreparedStatement): List[A]

Execute a PreparedStatement and return a List of Mapper instances.

def findAllByPreparedStatementDb[T](dbId: ConnectionIdentifier, stmt: PreparedStatement)(f: (A) ⇒ Box[T]): List[T]

def findAllDb(dbId: ConnectionIdentifier, by: QueryParam[A]*): List[A]

def findAllDb(dbId: ConnectionIdentifier): List[A]

def findAllFields(fields: Seq[SelectableField], by: QueryParam[A]*): List[A]

def findAllFieldsDb(dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[A]*): List[A]

def findApplier(name: String, inst: AnyRef): Box[(A, AnyRef) ⇒ Unit]

def findMap[T](by: QueryParam[A]*)(f: (A) ⇒ Box[T]): List[T]

def findMapByInsecureSql[T](query: String, checkedBy: IHaveValidatedThisSQL)(f: (A) ⇒ Box[T]): List[T]

def findMapByInsecureSqlDb[T](dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL)(f: (A) ⇒ Box[T]): List[T]

def findMapDb[T](dbId: ConnectionIdentifier, by: QueryParam[A]*)(f: (A) ⇒ Box[T]): List[T]

def findMapFieldDb[T](dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[A]*)(f: (A) ⇒ Box[T]): List[T]

def findSourceField(name: String): Box[SourceFieldInfo]

Given a name, look up the field

def flatMapFieldTitleForm[T](toMap: A, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm[T](func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm2[T](toMap: A, func: (NodeSeq, MappedField[_, A], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def flatMapFieldTitleForm2[T](func: (NodeSeq, MappedField[_, A], NodeSeq) ⇒ Seq[T]): List[T]

flat map the fields titles and forms to generate a list

def formFields(toMap: A): List[MappedField[_, A]]

Get the fields (in order) for displaying a form

def formFields: List[MappedField[_, A]]

Get the fields (in order) for displaying a form

var formatFormElement: (NodeSeq, NodeSeq) ⇒ NodeSeq

This function converts a name and form for a given field in the model to XHTML for presentation in the browser.

def formatFormLine(displayName: NodeSeq, form: NodeSeq): NodeSeq

def getActualBaseField(actual: A, protoField: BaseOwnedMappedField[A]): BaseOwnedMappedField[A]

Given the prototype field (the field on the Singleton), get the field from the instance

def getActualField[T](actual: A, protoField: MappedField[T, A]): MappedField[T, A]

Given the prototype field (the field on the Singleton), get the field from the instance

final def getClass(): Class[_]

def hashCode(): Int

def htmlHeaders: NodeSeq

def htmlLine: NodeSeq

def indexedField(toSave: A): Box[MappedField[Any, A]]

final def isInstanceOf[T0]: Boolean

def localeField: Box[MappedLocale[A]]

If there's a field in this record that defines the locale, return it

def mapFieldTitleForm[T](toMap: A, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

map the fields titles and forms to generate a list

def mapFieldTitleForm[T](func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

map the fields titles and forms to generate a list

lazy val mappedFields: Seq[BaseMappedField]

The mapped fields

lazy val mappedFieldsForModel: List[MappedField[_, A]]

the mapped fields as MappedField rather than BaseMappedField

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prependFieldTransform(transform: CssSel): Unit

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

def runSafe[T](f: ⇒ T): T

def runValidationList(toValidate: A): List[FieldError]

Run the list of field validations, etc.

final def safe_?: Boolean

def save(toSave: A): Boolean

def save(): Boolean

def saveMe(): A

Save the instance and return the instance

def saved_?(toSave: A): Boolean

def saved_?: Boolean

def suplementalJs(ob: Box[KeyObfuscator]): List[(String, JsExp)]

If the instance calculates any additional fields for JSON object, put the calculated fields here

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

implicit def thisToMappee(in: Mapper[A]): A

def timeZoneField: Box[MappedTimeZone[A]]

def toForm(toMap: A): NodeSeq

def toForm(button: Box[String], redoSnippet: (NodeSeq) ⇒ NodeSeq, onSuccess: (A) ⇒ Unit): NodeSeq

def toForm(button: Box[String], f: (A) ⇒ Any): NodeSeq

Present the model as a form and execute the function on submission of the form

def toForm(button: Box[String], onSuccess: String): NodeSeq

Present the model as a form and execute the function on submission of the form

def toHtml(toMap: A): NodeSeq

Present the model as a HTML using the same formatting as toForm

def toHtml: NodeSeq

Present the model as a HTML using the same formatting as toForm

def toString(): String

def toXml(what: A): Elem

def toXml: Elem

def updateFromJSON_!(toUpdate: A, json: JObject): A

This method will update the instance from JSON.

final def validate(toValidate: A): List[FieldError]

def validate: List[FieldError]

def validation: List[(A) ⇒ List[FieldError]]

If there are model-specific validations to perform, override this method and return an additional list of validations to perform

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whatToSet(toSave: A): String