MappedForeignKey

abstract def asJsExp: JsExp

abstract def asJsonValue: Box[JValue]

abstract def buildSetActualValue(accessor: Method, inst: AnyRef, columnName: String): (MyOwner, AnyRef) ⇒ Unit

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

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

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

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

abstract def dbFieldClass: Class[KeyType]

What is the real class that corresponds to FieldType

abstract def dbKeyToTable: KeyedMetaMapper[KeyType, Other]

abstract def defaultValue: KeyType

The default value for the field

abstract def defined_?: Boolean

Is the key defined

abstract def doneWithSave(): Unit

Called after the field is saved to the database

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

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

abstract def fieldOwner: MyOwner

Return the owner of this field

abstract def foreignMeta: KeyedMetaMapper[KeyType, Other]

What's the MetaMapper for the foreign key

abstract def i_is_!: KeyType

The actual value of the field

abstract def i_obscure_!(in: KeyType): KeyType

Obscure the incoming value to a "safe" value (e.g., if there are not enough rights to view the entire social security number 123-45-5678, this method might return ***-**-*678

abstract def i_was_!: KeyType

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

abstract def jdbcFriendly(field: String): AnyRef

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

abstract def manifest: scala.reflect.api.JavaUniverse.TypeTag[KeyType]

abstract def real_convertToJDBCFriendly(value: KeyType): AnyRef

abstract def real_i_set_!(value: KeyType): KeyType

Must be implemented to store the value of the field

abstract def setFromAny(value: Any): KeyType

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

abstract def sourceInfoMetadata(): SourceFieldMetadata { type ST = KeyType }

Get the source field metadata for the field

abstract def targetSQLType: Int

Get the JDBC SQL Type for this field

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(v: KeyType): KeyType

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

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: MyOwner): MappedField[KeyType, MyOwner]

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: Other): MyOwner

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

def apply(v: Box[Other]): MyOwner

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

def apply(v: KeyType): MyOwner

def apply[Q](v: Q)(implicit arg0: (Q) ⇒ KeyType): MyOwner

def asHtml: Node

Default read-only rendering of field

final def asInstanceOf[T0]: T0

def asJs: List[(String, JsExp)]

def asJsonField: Box[JField]

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 cached_?: Boolean

Is the obj field cached

def calcFieldName: String

def canEqual(that: Any): Boolean

def clone(): AnyRef

final def convertToJDBCFriendly(value: KeyType): AnyRef

def dbAddedColumn: Box[() ⇒ Unit]

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

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 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 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 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.g., "First Name")

def displayNameHtml: Box[NodeSeq]

def doField(inst: MyOwner, meth: Method, func: PartialFunction[MappedField[KeyType, MyOwner], Unit]): Unit

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

Does the "right thing" comparing mapped fields

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

def finalize(): Unit

def foreign: Box[Other]

Some people prefer the name foreign to materialize the foreign reference.

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: KeyType

Convert the field to its "context free" type (e.g., String, Int, Long, etc.) If there are no read permissions, the value will be obscured

final def getClass(): Class[_]

def getField(inst: MyOwner, meth: Method): MappedField[KeyType, MyOwner]

def hashCode(): Int

def helpAsHtml: Box[NodeSeq]

final def i_set_!(value: KeyType): KeyType

def ignoreField_?: Boolean

Should the field be ignored by the OR Mapper?

def immutableMsg: NodeSeq

final def isInstanceOf[T0]: Boolean

def jdbcFriendly: AnyRef

Get a JDBC friendly object for the part of this field that maps to the first 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[Other]

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[Other]): Unit

Prime the reference of this FK reference

def readPermission_?: Boolean

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

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: KeyType, filter: List[(KeyType) ⇒ KeyType]): KeyType

final def safe_?: Boolean

Are we in "safe" mode (i.e., the value of the field can be read or written without any security checks.)

def set(value: KeyType): KeyType

Set the field to the value

def setFilter: List[(KeyType) ⇒ KeyType]

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

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

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

def sourceFieldInfo(): SourceFieldInfo { type T = KeyType }

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

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) ⇒ KeyType): 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[(KeyType, String)]]

def validate: List[FieldError]

Validate this field and return a list of Validation Issues

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def was: KeyType

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?