MyCreatedAt

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(v: Date): Date

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def _dbColumnNameLC: String

The forced lower case column names

def _toForm: Box[NodeSeq]

Create an input field for the item

def actualField(actual: (CreatedTrait.this)#MapperType): MappedField[Date, (CreatedTrait.this)#MapperType]

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: Date): (CreatedTrait.this)#MapperType

def apply[Q](v: Q)(implicit arg0: (Q) ⇒ Date): (CreatedTrait.this)#MapperType

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 buildSetActualValue(accessor: Method, v: AnyRef, columnName: String): ((CreatedTrait.this)#MapperType, AnyRef) ⇒ Unit

def buildSetBooleanValue(accessor: Method, columnName: String): ((CreatedTrait.this)#MapperType, Boolean, Boolean) ⇒ Unit

def buildSetDateValue(accessor: Method, columnName: String): ((CreatedTrait.this)#MapperType, Date) ⇒ Unit

def buildSetLongValue(accessor: Method, columnName: String): ((CreatedTrait.this)#MapperType, Long, Boolean) ⇒ Unit

def buildSetStringValue(accessor: Method, columnName: String): ((CreatedTrait.this)#MapperType, String) ⇒ Unit

def calcFieldName: String

def canEqual(that: Any): Boolean

def clone(): AnyRef

final def convertToJDBCFriendly(value: Date): 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 dbFieldClass: Class[Date]

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

def defaultValue: Date

The default value for the field

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: (CreatedTrait.this)#MapperType, meth: Method, func: PartialFunction[MappedField[Date, (CreatedTrait.this)#MapperType], 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: (CreatedTrait.this)#MapperType

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 format(d: Date): String

This method defines the string parsing semantics of this field.

def get: Date

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

final def getClass(): Class[_]

def getField(inst: (CreatedTrait.this)#MapperType, meth: Method): MappedField[Date, (CreatedTrait.this)#MapperType]

def hashCode(): Int

def helpAsHtml: Box[NodeSeq]

def i_is_!: Date

The actual value of the field

def i_obscure_!(in: Date): Date

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

final def i_set_!(value: Date): Date

def i_was_!: Date

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

def inPast_?: Boolean

final def isInstanceOf[T0]: Boolean

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.

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 parse(s: String): Box[Date]

This method defines the string parsing semantics of this field.

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: Date): AnyRef

def real_i_set_!(value: Date): Date

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

final def safe_?: Boolean

Are we in "safe" mode (i.

def set(value: Date): Date

Set the field to the value

def setFilter: List[(Date) ⇒ Date]

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

def setFromAny(f: Any): Date

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

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

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 toLong: Long

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) ⇒ Date): 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 validate: List[FieldError]

Validate this field and return a list of Validation Issues

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def was: Date

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 is: Date

Get the value.