MappedStringIndex

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(v: String): String

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

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[String, T]

Get the field that this prototypical field represents

def allFields: Seq[BaseField]

def appendFieldId(in: Elem): Elem

If the field has a defined fieldId, append it

def apply(v: String): T

def apply[Q](v: Q)(implicit arg0: (Q) ⇒ String): 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 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 boxStrToValType(in: Box[String]): String

def buildSetActualValue(accessor: Method, inst: 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 calcFieldName: String

def canEqual(that: Any): Boolean

def clone(): AnyRef

def convertKey(in: AnyRef): Box[String]

def convertKey(in: Long): Box[String]

def convertKey(in: Int): Box[String]

def convertKey(in: String): Box[String]

final def convertToJDBCFriendly(value: String): AnyRef

def crop(in: ValueType): ValueType

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 dbFieldClass: Class[String]

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

lazy val defaultValue: String

def defined_?: Boolean

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[String, 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 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: String

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

final def getClass(): Class[_]

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

def hashCode(): Int

def helpAsHtml: Box[NodeSeq]

def i_is_!: String

The actual value of the field

def i_obscure_!(in: String): String

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

final def i_set_!(value: String): String

def i_was_!: String

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

def ignoreField_?: Boolean

Should the field be ignored by the OR Mapper?

final def isInstanceOf[T0]: Boolean

def jdbcFriendly(field: String): String

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

def jdbcFriendly: AnyRef

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

def makeKeyJDBCFriendly(in: String): String

val maxLen: Int

final def name: String

The name of this field

final def ne(arg0: AnyRef): Boolean

def notNull(in: ValueType): ValueType

def notNullAppender(): String

final def notify(): Unit

final def notifyAll(): Unit

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

Perform an atomic operation on the Settable.

def readPermission_?: Boolean

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

def real_convertToJDBCFriendly(value: String): AnyRef

def real_i_set_!(value: String): String

Must be implemented to store the value of the field

def removeRegExChars(regEx: String)(in: ValueType): ValueType

def renderJs_?: Boolean

def required_?: Boolean

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

def reset(): T

def resetDirty: Unit

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

final def safe_?: Boolean

Are we in "safe" mode (i.

def set(value: String): String

Set the field to the value

def setFilter: List[(String) ⇒ String]

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

def setFromAny(in: Any): String

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

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

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[Elem]

Create an input field for the item

def toFormAppendedAttributes: MetaData

def toLower(in: ValueType): ValueType

def toString(): String

def toUpper(in: ValueType): ValueType

def trim(in: ValueType): ValueType

def uniqueFieldId: Box[String]

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

def update[Q](v: Q)(implicit arg0: (Q) ⇒ String): 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

def valMaxLen(len: Int, msg: ⇒ String)(value: ValueType): List[FieldError]

A validation helper.

def valMinLen(len: Int, msg: ⇒ String)(value: ValueType): List[FieldError]

A validation helper.

def valRegex(pat: Pattern, msg: ⇒ String)(value: ValueType): List[FieldError]

Make sure the field matches a regular expression

def valUnique(msg: ⇒ String)(value: String): List[FieldError]

Make sure that the field is unique in the database

def validate: List[FieldError]

Validate this field and return a list of Validation Issues

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

def valueTypeToBoxString(in: String): Box[String]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def was: String

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 apply(ov: Box[String])(implicit disambiguateFromApplyBoxedForeign: BoxedStringToken): T

def is: String

Get the value.