MetaProtoStateMachine

def getSingleton : Meta

Implement a method that returns the singleton

def globalTransitions : List[ATransition]

Any transitions that are applied to all states can be listed here

def initialState : StV

The default initial state

def instantiate : MyType

def stateEnumeration : StateType

The enumeration of states

def states : List[State]

This method must be implemented.

def ! (event: Event): Unit

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

object Event extends AnyRef

object State extends AnyRef

def _dbTableNameLC : String

def addEndStuffs (in: String, params: List[QueryParam[MyType]], conn: SuperConnection): (String, Box[Long], Box[Long])

def addSnippet (xhtml: NodeSeq): NodeSeq

def addSnippetCallback (obj: MyType): Unit

def addSnippetSetup : MyType

def afterCommit : List[(MyType) ⇒ Unit]

def afterCreate : List[(MyType) ⇒ Unit]

def afterDelete : List[(MyType) ⇒ Unit]

def afterSave : List[(MyType) ⇒ Unit]

def afterSchemifier : Unit

def afterUpdate : List[(MyType) ⇒ Unit]

def afterValidation : List[(MyType) ⇒ Unit]

def afterValidationOnCreate : List[(MyType) ⇒ Unit]

def afterValidationOnUpdate : List[(MyType) ⇒ Unit]

def allFields : Seq[BaseField]

def appendField (pf: FieldPF): Unit

def appendFieldToStrings (in: MyType): String

def asHtml (toLine: MyType): NodeSeq

def asHtml : NodeSeq

def asInstanceOf [T0] : T0

def asJs (actual: MyType): JsExp

def asJs : JsExp

def asSafeJs (actual: MyType, f: KeyObfuscator): JsExp

def asSafeJs (f: KeyObfuscator): JsExp

def asValid : Box[MyType]

def beforeCreate : List[(MyType) ⇒ Unit]

def beforeDelete : List[(MyType) ⇒ Unit]

def beforeSave : List[(MyType) ⇒ Unit]

def beforeSchemifier : Unit

def beforeUpdate : List[(MyType) ⇒ Unit]

def beforeValidation : List[(MyType) ⇒ Unit]

def beforeValidationOnCreate : List[(MyType) ⇒ Unit]

def beforeValidationOnUpdate : List[(MyType) ⇒ Unit]

implicit def boundedFieldToItem (in: (MappedField[String, MyType], Int)): BoundedIndexField[MyType]

def buildMapper (rs: ResultSet): List[Box[(ResultSet, Int, MyType) ⇒ Unit]]

def buildSelectString (fields: Seq[SelectableField], conn: SuperConnection, by: QueryParam[MyType]*): (String, Box[Long], Box[Long], List[QueryParam[MyType]])

def bulkDelete_!! (dbId: ConnectionIdentifier, by: QueryParam[MyType]*): Boolean

def bulkDelete_!! (by: QueryParam[MyType]*): Boolean

def checkNames : Unit

def clean_? (toCheck: MyType): Boolean

def clone (): AnyRef

val columnNamesForInsert : String

def columnPrimaryKey_? (name: String): Boolean

val columnQueriesForInsert : String

def comparePrimaryKeys (other: MyType): Boolean

def connectionIdentifier : ConnectionIdentifier

def connectionIdentifier (id: ConnectionIdentifier): MyType

def count (by: QueryParam[MyType]*): Long

def count : Long

def countByInsecureSql (query: String, checkedBy: IHaveValidatedThisSQL): Long

def countByInsecureSqlDb (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): Long

def countDb (dbId: ConnectionIdentifier, by: QueryParam[MyType]*): Long

def countryField : Box[MappedCountry[MyType]]

def create : MyType

def createInstance : MyType

def createInstance (dbId: ConnectionIdentifier, rs: ResultSet, mapFuncs: List[Box[(ResultSet, Int, MyType) ⇒ Unit]]): MyType

def createInstances [T] (dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long], f: (MyType) ⇒ Box[T]): List[T]

def createInstances (dbId: ConnectionIdentifier, rs: ResultSet, start: Box[Long], omax: Box[Long]): List[MyType]

def createNewInstance (firstEvent: Event)(setup: (MyType) ⇒ Unit): MyType

def createNewInstance (firstEvent: Event, setup: Box[(MyType) ⇒ Unit]): MyType

def crudSnippets : SnippetPF

def crudSnippets_? : Boolean

object currentState extends MappedInt[MyType]

The column in the database that stores the current state

def dbAddTable : Box[() ⇒ Unit]

def dbCalculateConnectionIdentifier : PartialFunction[MyType, ConnectionIdentifier]

def dbDefaultConnectionIdentifier : ConnectionIdentifier

def dbIndexes : List[BaseIndex[MyType]]

def dbName : String

def dbSelectDBConnectionForFind : PartialFunction[Long, ConnectionIdentifier]

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

def dbTableName : String

def db_can_delete_? : Boolean

def decodeFromJSON_! (json: JObject, markFieldsAsDirty: Boolean): MyType

def delete_! (toDelete: MyType): Boolean

def delete_! : Boolean

def dirty_? (toTest: MyType): Boolean

def dirty_? : Boolean

var displayFieldAsLineElement : (NodeSeq) ⇒ NodeSeq

var displayNameToHeaderElement : (String) ⇒ NodeSeq

def doHtmlLine (toLine: MyType): NodeSeq

def doPostCommit (func: () ⇒ Unit): MyType

def editSnippet (xhtml: NodeSeq): NodeSeq

def editSnippetCallback (obj: MyType): Unit

def editSnippetSetup : MyType

val elemName : String

def encodeAsJSON_! (toEncode: MyType): JObject

def eq (arg0: AnyRef): Boolean

def equals (other: Any): Boolean

def fieldByName [T] (fieldName: String, actual: MyType): Box[MappedField[T, MyType]]

def fieldByName [T] (fieldName: String): Box[MappedField[T, MyType]]

def fieldMapperPF (transform: (BaseOwnedMappedField[MyType]) ⇒ NodeSeq, actual: MyType): PartialFunction[String, (NodeSeq) ⇒ NodeSeq]

def fieldMapperPF (transform: (BaseOwnedMappedField[MyType]) ⇒ NodeSeq): FieldPF

lazy val fieldMatcher : PartialFunction[(MyType, String), MappedField[Any, MyType]]

def fieldOrder : List[BaseOwnedMappedField[MyType]]

def fieldPF : FieldPF

implicit def fieldToItem [T] (in: MappedField[T, MyType]): IndexItem[MyType]

def finalize (): Unit

def find (by: QueryParam[MyType]*): Box[MyType]

def find (dbId: ConnectionIdentifier, key: String): Box[MyType]

def find (key: String): Box[MyType]

def find (key: List[String]): Box[MyType]

def find (key: Any): Box[MyType]

def findAll (by: QueryParam[MyType]*): List[MyType]

def findAll (): List[MyType]

def findAllByInsecureSql (query: String, checkedBy: IHaveValidatedThisSQL): List[MyType]

def findAllByInsecureSqlDb (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL): List[MyType]

def findAllByPreparedStatement (dbId: ConnectionIdentifier, stmt: PreparedStatement): List[MyType]

def findAllByPreparedStatement (f: (SuperConnection) ⇒ PreparedStatement): List[MyType]

def findAllByPreparedStatementDb [T] (dbId: ConnectionIdentifier, stmt: PreparedStatement)(f: (MyType) ⇒ Box[T]): List[T]

def findAllDb (dbId: ConnectionIdentifier, by: QueryParam[MyType]*): List[MyType]

def findAllDb (dbId: ConnectionIdentifier): List[MyType]

def findAllFields (fields: Seq[SelectableField], by: QueryParam[MyType]*): List[MyType]

def findAllFieldsDb (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[MyType]*): List[MyType]

def findApplier (name: String, inst: AnyRef): Box[(MyType, AnyRef) ⇒ Unit]

def findByKey (key: Long): Box[MyType]

def findDb (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[MyType]*): Box[MyType]

def findDb (dbId: ConnectionIdentifier, by: QueryParam[MyType]*): Box[MyType]

def findDb (dbId: ConnectionIdentifier, key: Any): Box[MyType]

def findDbByKey (dbId: ConnectionIdentifier, fields: Seq[SelectableField], key: Long): Box[MyType]

def findDbByKey (dbId: ConnectionIdentifier, key: Long): Box[MyType]

def findMap [T] (by: QueryParam[MyType]*)(f: (MyType) ⇒ Box[T]): List[T]

def findMapByInsecureSql [T] (query: String, checkedBy: IHaveValidatedThisSQL)(f: (MyType) ⇒ Box[T]): List[T]

def findMapByInsecureSqlDb [T] (dbId: ConnectionIdentifier, query: String, checkedBy: IHaveValidatedThisSQL)(f: (MyType) ⇒ Box[T]): List[T]

def findMapDb [T] (dbId: ConnectionIdentifier, by: QueryParam[MyType]*)(f: (MyType) ⇒ Box[T]): List[T]

def findMapFieldDb [T] (dbId: ConnectionIdentifier, fields: Seq[SelectableField], by: QueryParam[MyType]*)(f: (MyType) ⇒ Box[T]): List[T]

def findOrCreate (key: List[String]): MyType

def findOrCreate (key: Any): MyType

def flatMapFieldTitleForm [T] (toMap: MyType, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

def flatMapFieldTitleForm [T] (func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ Seq[T]): List[T]

def flatMapFieldTitleForm2 [T] (toMap: MyType, func: (NodeSeq, net.liftweb.mapper.MappedField[_, MyType], NodeSeq) ⇒ Seq[T]): List[T]

def flatMapFieldTitleForm2 [T] (func: (NodeSeq, net.liftweb.mapper.MappedField[_, MyType], NodeSeq) ⇒ Seq[T]): List[T]

def formFields (toMap: MyType): List[net.liftweb.mapper.MappedField[_, MyType]]

def formFields : List[net.liftweb.mapper.MappedField[_, MyType]]

var formatFormElement : (NodeSeq, NodeSeq) ⇒ NodeSeq

def formatFormLine (displayName: NodeSeq, form: NodeSeq): NodeSeq

def getActualBaseField (actual: MyType, protoField: BaseOwnedMappedField[MyType]): BaseOwnedMappedField[MyType]

def getActualField [T] (actual: MyType, protoField: MappedField[T, MyType]): MappedField[T, MyType]

def getClass (): java.lang.Class[_]

def hashCode (): Int

def htmlHeaders : NodeSeq

def htmlLine : NodeSeq

object id extends MappedLongIndex[MyType]

the primary key for the database

object inProcess extends MappedBoolean[MyType]

def indexedField (toSave: MyType): Box[MappedField[Any, MyType]]

def isInstanceOf [T0] : Boolean

def localeField : Box[MappedLocale[MyType]]

def mapFieldTitleForm [T] (toMap: MyType, func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

def mapFieldTitleForm [T] (func: (NodeSeq, Box[NodeSeq], NodeSeq) ⇒ T): List[T]

lazy val mappedFields : Seq[BaseMappedField]

lazy val mappedFieldsForModel : List[net.liftweb.mapper.MappedField[_, MyType]]

def modSnippet (xhtml: NodeSeq, obj: MyType, cleanup: (MyType) ⇒ Unit): NodeSeq

def ne (arg0: AnyRef): Boolean

def newInstance (firstEvent: Event): MyType

object nextTransitionAt extends MappedLong[MyType] with LifecycleCallbacks

def notify (): Unit

def notifyAll (): Unit

def objFromIndexedParam : Box[MyType]

def prependField (pf: FieldPF): Unit

def primaryKeyField : MetaProtoStateMachine.this.id.type

get the primary key field

def processEvent (event: Event): Unit

Process an event

def reload : MyType

val rootClass : java.lang.Class[_ >: ?0]

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

def runValidationList (toValidate: MyType): List[FieldError]

def safe_? : Boolean

def save (toSave: MyType): Boolean

def save (): Boolean

def saveMe (): MyType

def saved_? (toSave: MyType): Boolean

def saved_? : Boolean

def setupTime (when: TimeSpan): Unit

def state : Value

Get the current state

def suplementalJs (ob: Box[KeyObfuscator]): List[(String, JsExp)]

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

def terminate (what: MyType, from: StV, to: StV, event: Event): Unit

Terminate an instance

def terminate (from: StV, to: StV, event: Event): Unit

This item has reached a terminating state.

implicit def thisToMappee (in: Mapper[MyType]): MyType

def timeZoneField : Box[MappedTimeZone[MyType]]

object timedEventAt extends MappedLong[MyType]

The column in the database that stores the next time an event should go off

val timedEventHandler : LiftActor

def timedEventInitialWait : Long

How long to wait to start looking for timed events.

val timedEventManager : LiftActor

def timedEventPeriodicWait : Long

After the initial test, how long do we wait

def toForm (toMap: MyType): NodeSeq

def toForm (button: Box[String], redoSnippet: (NodeSeq) ⇒ NodeSeq, onSuccess: (MyType) ⇒ Unit): NodeSeq

def toForm (button: Box[String], f: (MyType) ⇒ Any): NodeSeq

def toForm (button: Box[String], onSuccess: String): NodeSeq

def toHtml (toMap: MyType): NodeSeq

def toHtml : NodeSeq

def toString (): String

def toXml (what: MyType): Elem

def toXml : Elem

def transition (from: StV, to: StV, why: Event): Unit

This method is called on a transition from one state to another.

def unapply (key: Any): Option[MyType]

def updateFromJSON_! (toUpdate: MyType, json: JObject): MyType

def validate (toValidate: MyType): List[FieldError]

def validate : List[FieldError]

def validation : List[(MyType) ⇒ List[FieldError]]

def viewSnippet (xhtml: NodeSeq): NodeSeq

def viewSnippetSetup : MyType

def wait (): Unit

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

def wait (arg0: Long): Unit

def whatToSet (toSave: MyType): String