Fire the actor. This may be invoked several times between
invocations of prefire() and postfire(). Output data may
(and normally will) be produced.
Typically, the fire() method performs the computation associated
with an actor. This method is not required to have bounded
execution. However, after endFire() is called, this method should
return in bounded time.
Begin execution of the actor. This is invoked exactly once
after the preinitialization phase. Since type resolution is done
in the preinitialization phase, along with topology changes that
may be requested by higher-order function actors, an actor
can produce output data and schedule events in the initialize()
This method should be invoked once per iteration, after the last
invocation of fire() in that iteration. The postfire() method should
not produce output data on output ports of the actor.
It returns true if the execution can proceed into the next iteration,
false if the actor does not wish to be fired again.
This method typically wraps up an iteration, which may involve
updating local state or updating displays.
This method should be invoked prior to each invocation of fire().
It returns true if the fire() method can be invoked, given the
current status of the inputs and parameters of the actor. Thus
this method will typically check preconditions for a firing, if
there are any. In an opaque, non-atomic entity,
it may move data into an inner subsystem.
This method should be invoked exactly once per execution
of a model, before any of these other methods are invoked.
For actors, this is invoked prior to type resolution and
may trigger changes in the topology, changes in the