OptionalJodaTimeField

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def _1: Box[MyType]

def allFields: Seq[util.BaseField]

def apply(in: Box[MyType]): OwnerType

def apply(in: MyType): OwnerType

def asHtml: NodeSeq

final def asInstanceOf[T0]: T0

def asJInt(encode: (MyType) ⇒ BigInt): JValue

def asJString(encode: (MyType) ⇒ String): JValue

Helper for implementing asJValue for a conversion to an encoded JString

def asJValue: JValue

Encode the field value into a JValue

def asJs: JsExp with Product with Serializable

Returns the field's value as a valid JavaScript expression

def asString: String

Convert the field to a String...

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

implicit def boxNodeFuncToFieldError(in: (Box[MyType]) ⇒ Box[Node]): (Box[MyType]) ⇒ List[FieldError]

implicit def boxNodeToFieldError(in: Box[Node]): List[FieldError]

def canEqual(a: Any): Boolean

def canRead_?: Boolean

Can the value of this field be read without obscuring the result?

def canWrite_?: Boolean

Can the value of this field be written?

def checkCanRead_?: Boolean

If the owner is not in "safe" mode, check the current environment to see if the field can be read

def checkCanWrite_?: Boolean

If the owner is not in "safe" mode, check the current environment to see if the field can be written

def clear: Unit

Clear the value of this field

def clone(): AnyRef

def dateTimeFormatter: DateTimeFormatter

def defaultValueBox: Box[MyType]

The default value of the field when no value is set.

def dirty_?: Boolean

def dirty_?(b: Boolean): Unit

def displayHtml: NodeSeq

def displayName: String

The display name of this field (e.g., "First Name")

def displayNameHtml: Box[NodeSeq]

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def fieldId: Option[NodeSeq]

def forceDirty_?: Boolean

Should the dirty flag always be set when setBox is called

def formElemAttrs: Seq[http.SHtml.ElemAttr]

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

def formInputType: String

Form field's type.

final def genericSetFromAny(in: Any)(implicit m: Manifest[MyType]): Box[MyType]

Generic implementation of setFromAny that implements exactly what the doc for setFromAny specifies, using a Manifest to check types

def get: Option[MyType]

final def getClass(): Class[_]

def hashCode(): Int

def helpAsHtml: Box[NodeSeq]

def ignoreField_?: Boolean

Should the field be ignored by the OR Mapper?

final def isInstanceOf[T0]: Boolean

def label: NodeSeq

def liftSetFilterToBox(in: Box[MyType]): Box[MyType]

OptionalTypedField and MandatoryTypedField implement this to do the appropriate lifting of Box[MyType] to ValueType

def name: String

The text name of this field

final def ne(arg0: AnyRef): Boolean

def noValueErrorMessage: String

The error message used when the field value could not be set

implicit def nodeToFieldError(node: Node): List[FieldError]

def notOptionalErrorMessage: String

The error message used when the field value must be set

final def notify(): Unit

final def notifyAll(): Unit

def obscure(in: MyType): Box[MyType]

final def optional_?: Boolean

Is the value of this field optional (e.g.

val owner: OwnerType

Return the owner of this field

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

def productArity: Int

def productElement(n: Int): Any

def productIterator: Iterator[Any]

def productPrefix: String

def required_?: Boolean

def resetDirty: Unit

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

def runValidation(in: Box[MyType]): List[FieldError]

Helper function that does validation of a value by using the validators specified for the field

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(in: Option[MyType]): Option[MyType]

Set the value of the field to the given value.

def setBox(in: Box[MyType]): Box[MyType]

def setFilter: List[(ValueType) ⇒ ValueType]

def setFilterBox: List[(Box[MyType]) ⇒ Box[MyType]]

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

def setFromAny(in: Any): Box[DateTime]

Set the value of the field from anything.

def setFromJInt(jvalue: JValue)(decode: (BigInt) ⇒ Box[MyType]): Box[MyType]

def setFromJString(jvalue: JValue)(decode: (String) ⇒ Box[MyType]): Box[MyType]

Helper for implementing setFromJValue for a conversion from an encoded JString

def setFromJValue(jvalue: JValue): Box[MyType]

Decode the JValue and set the field to the decoded value.

def setFromString(s: String): Box[DateTime]

Set the value of the field using some kind of type-specific conversion from a String.

def set_!(in: Box[MyType]): Box[MyType]

def shouldDisplay_?: Boolean

def show_?: Boolean

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

def tabIndex: Int

def toBoxMyType(in: ValueType): Box[DateTime]

def toDateTime(in: Any): Box[DateTime]

def toForm: Box[NodeSeq]

Generate a form control for the field

def toString(): String

def toValueType(in: Box[MyType]): Option[MyType]

def toXHtml: NodeSeq

Convert the field value to an XHTML representation

def uniqueFieldId: Box[String]

def uploadField_?: Boolean

def validate: List[FieldError]

Validate this field's setting, returning any errors found

def validations: List[ValidationFunction]

def value: Option[MyType]

def valueBox: Box[MyType]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit