| OVERVIEW | PACKAGE | CONSTR | FIELDS | METHODS | FRAMES NO FRAMES | INHERITED |
class MappedStringIndex[T <: Mapper[T]](val override fieldOwner : T, val override maxLen : Int)
extends
MappedUniqueId[T] with IndexedField[String]
def this(fieldOwner : T, maxLen : Int)
|
| _toForm |
override def _toForm
Create an input field for the item
|
Box[NodeSeq] | MappedString |
| asHtml |
override def asHtml
|
Node | MappedField |
| asJsExp |
def asJsExp
|
JsExp | MappedString |
| asString |
def asString
Return the field name and field value, delimited by an '='
|
String | MappedField |
| calcFieldName |
def calcFieldName
|
String | MappedField |
| dbColumnCount |
def dbColumnCount
The number of database columns that this field represents
|
Int | MappedField |
| dbColumnName |
def dbColumnName
|
String | MappedField |
| dbDisplay_? |
override def dbDisplay_?
|
Boolean | |
| dbFieldClass |
def dbFieldClass
What is the real class that corresponds to FieldType
|
Class[String] | MappedString |
| dbForeignKey_? |
def dbForeignKey_?
Is the field a foreign key reference
|
Boolean | MappedField |
| dbIndexFieldIndicatesSaved_? |
def dbIndexFieldIndicatesSaved_?
override this method in indexed fields to indicate that the field has been saved
|
Boolean | MappedField |
| dbIndexed_? |
override def dbIndexed_?
Should the field be indexed?
|
Boolean | |
| dbPrimaryKey_? |
override def dbPrimaryKey_?
Is the field the table's primary key
|
Boolean | |
| dbSelectString |
lazy val dbSelectString
|
String | MappedField |
| defaultValue |
override lazy val defaultValue
The default value for the field
|
String | MappedUniqueId |
| defined_? |
def defined_?
|
Boolean | |
| dirty_? |
def dirty_?
Is the field dirty (has it been changed since the record was loaded from the database
|
Boolean | MappedField |
| displayHtml |
def displayHtml
|
NodeSeq | BaseMappedField |
| displayName |
override def displayName
The display name of this field (e
[details]
g., "First Name")
|
String | MappedField |
| displayNameHtml |
def displayNameHtml
|
Box[NodeSeq] | BaseMappedField |
| fieldId |
def fieldId
A unique 'id' for the field for form generation
|
Option[NodeSeq] | BaseMappedField |
| i_is_! |
protected def i_is_!
The actual value of the field
|
String | MappedString |
| i_was_! |
protected def i_was_!
The value of the field when it was pulled from the DB
|
String | MappedString |
| ignoreField_? |
def ignoreField_?
Should the field be ignored by the OR Mapper?
|
Boolean | MappedField |
| is |
def is
Convert the field to its "context free" type (e
[details]
g., String, Int, Long, etc.)
If there are no read permissions, the value will be obscured
|
FieldType | MappedField |
| jdbcFriendly |
def jdbcFriendly
Get a JDBC friendly object for the part of this field that maps to the first
column in the database
|
Object | MappedField |
| name |
final def name
The name of this field
|
String | MappedField |
| readPermission_? |
override def readPermission_?
Given the current execution state, can the field be read?
|
Boolean | MappedString |
| renderJs_? |
def renderJs_?
|
Boolean | BaseMappedField |
| safe_? |
final def safe_?
Are we in "safe" mode (i
[details]
e., the value of the field can be read or written without any security checks.)
|
Boolean | MappedField |
| targetSQLType |
def targetSQLType
Get the JDBC SQL Type for this field
|
Int | MappedString |
| toForm |
final def toForm
Create an input field for the item
|
Box[NodeSeq] | MappedField |
| toFormAppendedAttributes |
def toFormAppendedAttributes
|
MetaData | MappedField |
| uniqueFieldId |
def uniqueFieldId
|
Box[String] | FieldIdentifier |
| validate |
def validate
Validate this field and return a list of Validation Issues
|
List[FieldError] | MappedField |
| was |
def was
What value was the field's value when it was pulled from the DB?
|
FieldType | MappedField |
| writePermission_? |
override def writePermission_?
Given the current execution state, can the field be written?
|
Boolean |
| != |
final def !=(arg0 : Any)
|
Boolean | Any |
| != |
final def !=(arg0 : Object)
|
Boolean | AnyRef |
| == |
final def ==(arg0 : Object)
|
Boolean | AnyRef |
| == |
final def ==(arg0 : Any)
|
Boolean | Any |
| actualField |
def actualField(actual : OwnerType)
Get the field that this prototypical field represents
[details]
|
MappedField[FieldType, OwnerType] | MappedField |
| apply |
def apply(ov : String)
|
T | MappedString |
| apply |
def apply[Q](v : Q)(implicit view$2 : (Q) => FieldType)
|
OwnerType | MappedField |
| apply |
def apply(ov : Box[String])
|
T | MappedString |
| asInstanceOf |
final def asInstanceOf[T0]
|
T0 | Any |
| asJs |
def asJs
|
List[(String, JsExp)] | BaseMappedField |
| buildSetActualValue |
def buildSetActualValue(accessor : Method, inst : Object, columnName : String)
|
(T, Object) => Unit | MappedString |
| buildSetBooleanValue |
def buildSetBooleanValue(accessor : Method, columnName : String)
|
(T, Boolean, Boolean) => Unit | MappedString |
| buildSetDateValue |
def buildSetDateValue(accessor : Method, columnName : String)
|
(T, Date) => Unit | MappedString |
| buildSetLongValue |
def buildSetLongValue(accessor : Method, columnName : String)
|
(T, Long, Boolean) => Unit | MappedString |
| buildSetStringValue |
def buildSetStringValue(accessor : Method, columnName : String)
|
(T, String) => Unit | MappedString |
| clone |
protected def clone
|
Object | AnyRef |
| convertKey |
def convertKey(in : Long)
|
Box[String] | |
| convertKey |
def convertKey(in : String)
|
Box[String] | |
| convertKey |
def convertKey(in : Int)
|
Box[String] | |
| convertKey |
def convertKey(in : Object)
|
Box[String] | |
| convertToJDBCFriendly |
final def convertToJDBCFriendly(value : FieldType)
|
Object | MappedField |
| crop |
final def crop(in : String)
|
String | MappedString |
| dbAddedColumn |
def dbAddedColumn
Called when a column has been added to the database via Schemifier
|
Box[() => Unit] | MappedField |
| dbAddedIndex |
def dbAddedIndex
Called when a column has indexed via Schemifier
|
Box[() => Unit] | MappedField |
| dbColumnNames |
def dbColumnNames(in : String)
|
List[String] | MappedField |
| dirty_? |
protected def dirty_?(b : Boolean)
Make the field dirty
|
Unit | MappedField |
| doField |
protected def doField(inst : OwnerType, meth : Method, func : PartialFunction[MappedField[FieldType, OwnerType], Unit])
|
Unit | MappedField |
| doneWithSave |
protected[mapper] override def doneWithSave
Called after the field is saved to the database
|
Unit | MappedString |
| eq |
final def eq(arg0 : Object)
|
Boolean | AnyRef |
| equals |
override def equals(other : Any)
Does the "right thing" comparing mapped fields
|
Boolean | MappedField |
| fieldCreatorString |
def fieldCreatorString(dbType : DriverType)
Given the driver type, return a list of SQL creation strings for the columns represented by this field
|
List[String] | MappedField |
| fieldCreatorString |
def fieldCreatorString(dbType : DriverType, colName : String)
Given the driver type, return the string required to create the column in the database
|
String | MappedString |
| finalize |
protected def finalize
|
Unit | AnyRef |
| getClass |
final def getClass
|
Class[Any] | AnyRef |
| getField |
protected def getField(inst : OwnerType, meth : Method)
|
MappedField[FieldType, OwnerType] | MappedField |
| hashCode |
def hashCode
|
Int | AnyRef |
| i_obscure_! |
protected def i_obscure_!(in : String)
Obscure the incoming value to a "safe" value (e
[details]
g., if there are
not enough rights to view the entire social security number 123-45-5678, this
method might return ***-**-*678
|
String | MappedString |
| i_set_! |
protected final def i_set_!(value : FieldType)
|
FieldType | MappedField |
| isInstanceOf |
final def isInstanceOf[T0]
|
Boolean | Any |
| jdbcFriendly |
def jdbcFriendly(field : 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
[details]
)
|
String | MappedString |
| makeKeyJDBCFriendly |
def makeKeyJDBCFriendly(in : String)
|
String | |
| ne |
final def ne(arg0 : Object)
|
Boolean | AnyRef |
| notNull |
final def notNull(in : String)
|
String | MappedString |
| notify |
final def notify
|
Unit | AnyRef |
| notifyAll |
final def notifyAll
|
Unit | AnyRef |
| real_convertToJDBCFriendly |
def real_convertToJDBCFriendly(value : String)
|
Object | MappedString |
| real_i_set_! |
protected def real_i_set_!(value : String)
Must be implemented to store the value of the field
|
String | MappedString |
| removeRegExChars |
final def removeRegExChars(regEx : String)(in : String)
|
String | MappedString |
| reset |
def reset
|
T | MappedUniqueId |
| resetDirty |
def resetDirty
|
Unit | MappedField |
| runFilters |
def runFilters(in : FieldType, filter : List[(FieldType) => FieldType])
|
FieldType | MappedField |
| set |
def set(value : FieldType)
Set the field to the value
|
FieldType | MappedField |
| setFilter |
protected def setFilter
A list of functions that transform the value before it is set
[details]
The transformations
are also applied before the value is used in a query. Typical applications
of this are trimming and/or toLowerCase-ing strings
|
List[(FieldType) => FieldType] | MappedField |
| setFromAny |
override def setFromAny(in : Any)
Attempt to figure out what the incoming value is and set the field to that value
[details]
Return true if
the value could be assigned
|
String | MappedString |
| set_? |
def set_?(value : Box[FieldType])
Set the field to the Box value if the Box is Full
|
Box[FieldType] | MappedField |
| synchronized |
final def synchronized[T0](arg0 : T0)
|
T0 | AnyRef |
| targetSQLType |
def targetSQLType(field : String)
Get the JDBC SQL Type for this field
|
Int | MappedField |
| toLower |
final def toLower(in : String)
|
String | MappedString |
| toString |
override def toString
|
String | MappedField |
| toUpper |
final def toUpper(in : String)
|
String | MappedString |
| trim |
final def trim(in : String)
|
String | MappedString |
| update |
def update[Q](v : Q)(implicit view$1 : (Q) => FieldType)
Assignment from the underlying type
[details]
It's ugly, but:
field() = new_value field := new_value field set new_value field.set(new_value) are all the same |
Unit | MappedField |
| valMaxLen |
def valMaxLen(len : Int, msg : => String)(value : String)
A validation helper
[details]
Make sure the string is no more than a particular
length and generate a validation issue if not
|
List[FieldError] | MappedString |
| valMinLen |
def valMinLen(len : Int, msg : => String)(value : String)
A validation helper
[details]
Make sure the string is at least a particular
length and generate a validation issue if not
|
List[FieldError] | MappedString |
| valRegex |
def valRegex(pat : Pattern, msg : => String)(value : String)
Make sure the field matches a regular expression
|
List[FieldError] | MappedString |
| valUnique |
def valUnique(msg : => String)(value : String)
Make sure that the field is unique in the database
|
List[FieldError] | MappedString |
| validations |
def validations
|
List[(FieldType) => List[FieldError]] | MappedField |
| wait |
final def wait
|
Unit | AnyRef |
| wait |
final def wait(arg0 : Long)
|
Unit | AnyRef |
| wait |
final def wait(arg0 : Long, arg1 : Int)
|
Unit | AnyRef |
| OVERVIEW | PACKAGE | CONSTR | FIELDS | METHODS | FRAMES NO FRAMES | INHERITED |