MetaProtoStateMachine

abstract def getSingleton: (MetaProtoStateMachine.this)#Meta

Implement a method that returns the singleton

abstract def globalTransitions: List[ATransition]

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

abstract def initialState: (MetaProtoStateMachine.this)#StV

The default initial state

abstract def instantiate: MyType

abstract def stateEnumeration: StateType

The enumeration of states

abstract def states: List[State]

This method must be implemented.

def !(event: Event): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Event

object State

final def _dbTableNameLC: String

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

def addFormSnippet(html: 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 allFieldNames(): Seq[(String, SourceFieldMetadata)]

def allFields: Seq[BaseField]

def appendFieldToStrings(in: MyType): String

def appendFieldTransform(transform: CssSel): Unit

def asHtml(toLine: MyType): NodeSeq

def asHtml: NodeSeq

final 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

lazy val doAllFieldNames: Seq[(String, SourceFieldMetadata)]

def doHtmlLine(toLine: MyType): NodeSeq

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

def editFormSnippet(html: NodeSeq): NodeSeq

def editSnippetCallback(obj: MyType): Unit

def editSnippetSetup: MyType

val elemName: String

def encodeAsJSON_!(toEncode: MyType): JObject

final 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 fieldMapperTransforms(fieldHtml: (BaseOwnedMappedField[MyType]) ⇒ NodeSeq, mappedObject: MyType): Seq[CssSel]

def fieldMapperTransforms(fieldTransform: (BaseOwnedMappedField[MyType]) ⇒ NodeSeq): Seq[CssSel]

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

lazy val fieldNamesAsMap: Map[String, SourceFieldMetadata]

def fieldOrder: List[BaseOwnedMappedField[MyType]]

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

def fieldTransforms: Seq[CssSel]

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 findSourceField(name: String): Box[SourceFieldInfo]

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, MappedField[_, MyType], NodeSeq) ⇒ Seq[T]): List[T]

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

def formFields(toMap: MyType): List[MappedField[_, MyType]]

def formFields: List[MappedField[_, MyType]]

def formSnippet(html: NodeSeq, obj: MyType, cleanup: (MyType) ⇒ Unit): NodeSeq

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]

final def getClass(): 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]]

final 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[MappedField[_, MyType]]

final def ne(arg0: AnyRef): Boolean

def newInstance(firstEvent: Event): MyType

object nextTransitionAt extends MappedLong[MyType] with LifecycleCallbacks

final def notify(): Unit

final def notifyAll(): Unit

def objFromIndexedParam: Box[MyType]

def prependFieldTransform(transform: CssSel): 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: Class[?0] forSome {type ?0 >: ?0, type ?0 <: MetaMapper[MyType] with MyType}

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

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

final 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: liftweb.util.Helpers.TimeSpan): Unit

def state: StateType.Value

Get the current state

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

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

def terminate(what: MyType, from: (MetaProtoStateMachine.this)#StV, to: (MetaProtoStateMachine.this)#StV, event: Event): Unit

Terminate an instance

def terminate(from: (MetaProtoStateMachine.this)#StV, to: (MetaProtoStateMachine.this)#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: (MetaProtoStateMachine.this)#StV, to: (MetaProtoStateMachine.this)#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

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

def validate: List[FieldError]

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

def viewSnippetSetup: MyType

def viewTransform(html: NodeSeq): NodeSeq

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whatToSet(toSave: MyType): String