SimActor

abstract def act(): Unit

The abstract method, act, is defined in each subclass to provide specific behavior.

def !(msg: Any): Unit

def !!(msg: Any): Future[Any]

def !: Future[A]

final def !=(arg0: Any): Boolean

def !?(msec: Long, msg: Any): Option[Any]

def !?(msg: Any): Any

final def ##(): Int

def <(that: SimActor): Boolean

def <=(that: SimActor): Boolean

final def ==(arg0: Any): Boolean

def >(that: SimActor): Boolean

def >=(that: SimActor): Boolean

def ?: Any

var actTime: Double

The activation time for the item in the time-ordered priority queue

val arrivalT: Double

The time at which the entity/sim-actor arrived

final def asInstanceOf[T0]: T0

def at: Array[Double]

Return where this object is at (its location).

def clone(): AnyRef

def compare(actor2: SimActor): Int

Compare the activation times of the two actors, 'this' and 'actror2'.

def compare(other: PQItem): Int

Compare two items (PQItems) based on their actTime.

def compareTo(that: SimActor): Int

def continue(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exceptionHandler: PartialFunction[Exception, Unit]

def exit(): Nothing

def exit(reason: AnyRef): Nothing

def finalize(): Unit

def flaw(method: String, message: String): Unit

Show the flaw by printing the error message.

def forward(msg: Any): Unit

final def getClass(): Class[_]

def getState: scala.actors.Actor.State.Value

def hashCode(): Int

def id: Int

Get the id (unique identifier).

def internalSender: OutputChannel[Any]

final def isInstanceOf[T0]: Boolean

def link(body: ⇒ Unit): Actor

def link(to: ActorRef): ActorRef

def link(to: AbstractActor): AbstractActor

def loop(body: ⇒ Unit): Unit

def loopWhile(cond: ⇒ Boolean)(body: ⇒ Unit): Unit

def mailboxSize: Int

def me: String

Return the full identity.

implicit def mkBody[A](body: ⇒ A): Body[A]

def name: String

Get the name.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def react(handler: PartialFunction[Any, Unit]): Nothing

def reactWithin(msec: Long)(handler: PartialFunction[Any, Unit]): Nothing

def receive[R](f: PartialFunction[Any, R]): R

def receiveWithin[R](msec: Long)(f: PartialFunction[Any, R]): R

def receiver: Actor

def reply(msg: Any): Unit

def restart(): Unit

def schedule(delay: Double): Unit

Schedule a reactivation of this SimActor delay time units in the future.

def scheduler: IScheduler

def send(msg: Any, replyTo: OutputChannel[Any]): Unit

def sender: OutputChannel[Any]

def setAt(loc: Array[Double]): Unit

Set the location of this object.

def setName(label: String): Unit

Set the name.

def setSubtype(subtype: Int): Unit

Set the sim-actor's subtype.

def setTrajectory(t: Double): Unit

Set the value of the trajectory along the curve for this SimActor.

def simType: String

Get the type of the simulation object.

def start(): Coroutine

Start this coroutine, i.

def subtype: Int

Return the sim-actor's subtype.

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

def toString(): String

Show the SimActor's full name and activation time.

def trajectory: Double

Return the current trajectory (along the Qcurve) of this SimActor.

def trapExit: Boolean

def trapExit_=(value: Boolean): Unit

def unlink(from: ActorRef): Unit

def unlink(from: AbstractActor): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def yieldToDirector(quit: Boolean = false): Unit

Yield control to the director so the director can take the next action.

def yyield(other: Coroutine, quit: Boolean = false): Unit

Yield control to the 'other' coroutine.