LongMappedMapper

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(v: Long): Long

def :=[Q](v: Q)(implicit arg0: (Q) ⇒ Long): Long

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def _dbColumnNameLC: String

The forced lower case column names

def _toForm: Box[Elem]

Create an input field for the item

def actualField(actual: T): MappedField[Long, T]

Get the field that this prototypical field represents

def afterCreate: Unit

def afterDelete: Unit

def afterSave: Unit

def afterUpdate: Unit

def afterValidation: Unit

def afterValidationOnCreate: Unit

def afterValidationOnUpdate: Unit

def allFields: Seq[BaseField]

def appendFieldId(in: Elem): Elem

If the field has a defined fieldId, append it

def apply(v: O): T

Set the value from an instance of the foreign mapper class.

def apply(v: Box[O]): T

Set the value from a possible instance of the foreign mapper class.

def apply(v: Long): T

def apply[Q](v: Q)(implicit arg0: (Q) ⇒ Long): T

def asHtml: Node

Default read-only rendering of field

final def asInstanceOf[T0]: T0

def asJs: List[(String, JsExp)]

def asJsExp: JsExp

def asJsonField: Box[JField]

def asJsonValue: Box[JValue]

def asSafeJs(obs: Box[KeyObfuscator]): JsExp

def asString: String

Return the field name and field value, delimited by an '='

def atomicUpdate(f: (ValueType) ⇒ ValueType): ValueType

Perform an atomic update of this Settable.

def beforeCreate: Unit

def beforeDelete: Unit

def beforeSave: Unit

This method, which gets called when the mapper class is going to be saved, sets the field's value from obj if it's set to the default (!defined_?).

def beforeUpdate: Unit

def beforeValidation: Unit

def beforeValidationOnCreate: Unit

def beforeValidationOnUpdate: Unit

def box: Box[Long]

def buildSetActualValue(accessor: Method, data: AnyRef, columnName: String): (T, AnyRef) ⇒ Unit

def buildSetBooleanValue(accessor: Method, columnName: String): (T, Boolean, Boolean) ⇒ Unit

def buildSetDateValue(accessor: Method, columnName: String): (T, Date) ⇒ Unit

def buildSetLongValue(accessor: Method, columnName: String): (T, Long, Boolean) ⇒ Unit

def buildSetStringValue(accessor: Method, columnName: String): (T, String) ⇒ Unit

def cached_?: Boolean

Is the obj field cached

def calcFieldName: String

def canEqual(that: Any): Boolean

def clone(): AnyRef

final def convertToJDBCFriendly(value: Long): AnyRef

def dbAddedColumn: Box[() ⇒ Unit]

Called when a column has been added to the database via Schemifier

def dbAddedForeignKey: Box[() ⇒ Unit]

Called when Schemifier adds a foreign key.

def dbAddedIndex: Box[() ⇒ Unit]

Called when a column has indexed via Schemifier

def dbAutogenerated_?: Boolean

Is the primary key autogenerated

def dbColumnCount: Int

The number of database columns that this field represents

def dbColumnName: String

def dbColumnNames(in: String): List[String]

def dbDisplay_?: Boolean

def dbFieldClass: Class[Long]

What is the real class that corresponds to FieldType

def dbForeignKey_?: Boolean

Is the field a foreign key reference

def dbIgnoreSQLType_?: Boolean

Do we ignore the targetSQLType for setObject

def dbIncludeInForm_?: Boolean

def dbIndexFieldIndicatesSaved_?: Boolean

override this method in indexed fields to indicate that the field has been saved

def dbIndexed_?: Boolean

Should the field be indexed?

def dbKeyToColumn: MappedField[Long, O] with IndexedField[Long]

lazy val dbKeyToTable: KeyedMetaMapper[Long, O]

def dbNotNull_?: Boolean

Set to true if the field should be created as NOT NULL

def dbPrimaryKey_?: Boolean

Is the field the table's primary key

def dbSelectString: String

def defaultValue: Long

The default value for the field

def defined_?: Boolean

Is the key defined?

def dirty_?(b: Boolean): Unit

Make the field dirty

def dirty_?: Boolean

Is the field dirty (has it been changed since the record was loaded from the database

def displayHtml: NodeSeq

def displayName: String

The display name of this field (e.

def displayNameHtml: Box[NodeSeq]

def doField(inst: T, meth: Method, func: PartialFunction[MappedField[Long, T], Unit]): Unit

def doneWithSave(): Unit

Called after the field is saved to the database

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

Does the "right thing" comparing mapped fields

def fieldCreatorString(dbType: DriverType, colName: String): String

Given the driver type, return the string required to create the column in the database

def fieldCreatorString(dbType: DriverType): List[String]

Given the driver type, return a list of SQL creation strings for the columns represented by this field

def fieldId: Option[NodeSeq]

A unique 'id' for the field for form generation

val fieldOwner: T

Return the owner of this field

def finalize(): Unit

def findFor(key: KeyedForeignType): List[OwnerType]

def findFor(key: KeyType): List[OwnerType]

def foreignMeta: KeyedMetaMapper[Long, O]

What's the MetaMapper for the foreign key

def formElemAttrs: Seq[http.SHtml.ElemAttr]

What form elements are we going to add to this field?

def formInputType: String

When building the form field, what's the input element's type attribute.

def get: Long

Convert the field to its "context free" type (e.

final def getClass(): Class[_]

def getField(inst: T, meth: Method): MappedField[Long, T]

def hashCode(): Int

def helpAsHtml: Box[NodeSeq]

def i_is_!: Long

The actual value of the field

def i_obscure_!(in: Long): Long

Obscure the incoming value to a "safe" value (e.

final def i_set_!(value: Long): Long

def i_was_!: Long

The value of the field when it was pulled from the DB

def ignoreField_?: Boolean

Should the field be ignored by the OR Mapper?

def immutableMsg: NodeSeq

final def isInstanceOf[T0]: Boolean

def jdbcFriendly: Long

Get a JDBC friendly object for the part of this field that maps to the first column in the database

def jdbcFriendly(field: String): Long

Get a JDBC friendly representation of the named field (this is used for MappedFields that correspond to more than 1 column in the database.

final def name: String

The name of this field

final def ne(arg0: AnyRef): Boolean

def notNullAppender(): String

final def notify(): Unit

final def notifyAll(): Unit

def obj: Box[O]

Load and cache the record that this field references

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

Perform an atomic operation on the Settable.

def primeObj(obj: Box[O]): Unit

Prime the reference of this FK reference

def readPermission_?: Boolean

Given the current execution state, can the field be read?

def real_convertToJDBCFriendly(value: Long): AnyRef

def real_i_set_!(value: Long): Long

Must be implemented to store the value of the field

def renderJs_?: Boolean

def required_?: Boolean

Is the Field required (and will have a style designating it as such)

def resetDirty: Unit

def runFilters(in: Long, filter: List[(Long) ⇒ Long]): Long

final def safe_?: Boolean

Are we in "safe" mode (i.

def set(value: Long): Long

Set the field to the value

def setFilter: List[(Long) ⇒ Long]

A list of functions that transform the value before it is set.

def setFromAny(in: Any): Long

Attempt to figure out what the incoming value is and set the field to that value.

def set_?(value: Box[Long]): Box[Long]

Set the field to the Box value if the Box is Full

def shouldDisplay_?: Boolean

Given the current context, should this field be displayed

def show_?: Boolean

Given the current state of things, should this field be shown

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

def targetSQLType: Int

Get the JDBC SQL Type for this field

def targetSQLType(field: String): Int

Get the JDBC SQL Type for this field

def toForm: Box[NodeSeq]

Create an input field for the item

def toFormAppendedAttributes: MetaData

def toString(): String

def uniqueFieldId: Box[String]

The unique field id is the field name and the mapper name

def update[Q](v: Q)(implicit arg0: (Q) ⇒ Long): Unit

Assignment from the underlying type.

def uploadField_?: Boolean

Is this an upload field so that a form that includes this field must be multi-part mime

val valHasObj: (Long) ⇒ List[FieldError]

A validation function that checks that obj is nonempty

def validSelectValues: Box[List[(Long, String)]]

def validate: List[FieldError]

Validate this field and return a list of Validation Issues

def validations: List[(Long) ⇒ List[FieldError]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def was: Long

What value was the field's value when it was pulled from the DB?

def writePermission_?: Boolean

Given the current execution state, can the field be written?

def can: Box[Long]

def is: Long

Get the value.