Uses of Interface
adams.flow.core.ActorHandler

Packages that use ActorHandler

Package	Description
adams.flow.control
adams.flow.core
adams.flow.processor
adams.flow.sink
adams.flow.source
adams.flow.standalone
adams.flow.transformer
adams.gui.flow.tree
adams.gui.flow.tree.record.enclose

Uses of ActorHandler in adams.flow.control

Subinterfaces of ActorHandler in adams.flow.control

Modifier and Type	Interface	Description
interface	LocalScopeHandler	Interface for actor handlers that provide a local scope for their sub-actors.
interface	ScopeHandler	For actors that define a scope like the Flow or LocalScopeTrigger actor.

Classes in adams.flow.control that implement ActorHandler

Modifier and Type	Class	Description
class	AbstractConnectedControlActor	Ancestor for all actors that control (connected) sub-actors in some way.
class	AbstractContainerUpdater	Ancestor for control actors that update a specific value of a container using the defined sub-actors.
class	AbstractControlActor	Ancestor for all actors that control sub-actors in some way.
class	AbstractDataContainerFileChecker<T extends DataContainer>	Abstract ancestor for transformers that check data container files whether they are consistents before passing on the file/file arrays.
class	AbstractDirectedControlActor	Ancestor for all actors that control sub-actors in some way.
class	AbstractTee	Abstract ancestor for actors that tee-off tokens.
class	ArrayGenerate	Applies all sub-actors to the input token and generates an array from the collected output. Each of the branches is expected to produce at most one output token (ideally one per branch, otherwise there will be null elements in the output array).
class	ArrayProcess	Applies all sub-actors to each of the array elements.
class	Branch	Branches off the flow into several sub-branches, each being supplied with a copy of the same object being passed into this meta-actor.
class	CollectionProcess	Applies all sub-actors to each of the collection elements.
class	ConditionalSequence	The sequence gets only executed if the condition holds true.
class	ConditionalSubProcess	Encapsulates a sequence of flow items.
class	ConditionalTee	Tees off the tokens if the condition evaluates to 'true'.
class	ConditionalTrigger	Executes the tee-actor whenever a token gets passed through.
class	ContainerValuePicker	Picks a named value from any container object and tees it off. With the 'switch-outputs' option it is possible to forward the named value and teeing off the container instead. If 'ignore missing' is turned off, any value that cannot be found will generate an error logging message and, in case of switched outputs, an actual error.
class	Count	Counts the number of tokens that pass through and meet the condition and tees off the current count every n-th token.
class	FileProcessor
class	Flow	Container object for actors, used for executing a flow.
class	IfStorageValue	An If-Then-Else source actor for storage values.
class	IfThenElse	Emulates an If-Then-Else construct.
class	InputOutputListener	Listens to the input/output tokens of the sub-actors, sending them to callable actors.
class	JMap	Runs jmap whenever a token gets passed through.
class	LaunchTee	Launches the sub-flow in a separate thread each time a token arrives. Internally, a adams.flow.control.LocalScopeTee is used to manage the scope and forward the token. However, when imposing thread limits, a job gets created with the sub-actors and placed into a job runner for execution.
class	LaunchTrigger	Launches the sub-flow in a separate thread each time a token arrives. Internally, a adams.flow.control.LocalScopeTrigger is used to manage the scope. However, when imposing thread limits, a job gets created with the sub-actors and placed into a job runner for execution.
class	LoadBalancer	Runs the specified 'load actor' in as many separate threads as specified with the 'num-threads' parameter. Always uses a copy of the variables. NB: no callable transformer or sink allowed.
class	LocalScopeSubProcess	Provides a local scope for the sub-actors. It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.
class	LocalScopeTee	Executes the sub-actors whenever a token gets passed through, just like the adams.flow.control.Tee actor, but also provides its own scope for variables and internal storage. It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.
class	LocalScopeTransformer	Provides a local scope for the sub-actors. It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.
class	LocalScopeTrigger	Executes the sub-actors whenever a token gets passed through, just like the adams.flow.control.Trigger actor, but also provides its own scope for variables and internal storage. It is possible to 'propagate' or 'leak' variables and storage items from within the local scope back to the output scope.
class	MutableConnectedControlActor	Abstract superclass for actors that allow their sub-actors to modified (adding, removing, editing).
class	MutableControlActor	Abstract superclass for actors that allow their sub-actors to modified (adding, removing, editing).
class	Once	Tees off a token only once to its sub-actors. However, this can be reset when the monitored variable changes.
class	PlotContainerUpdater	Applies all sub-actors to process either the selected value of the plot container.
class	Rejector	Rejects data containers with errors attached.
class	RemoteExecutionTrigger	Transfers the actors below itself, the specified storage items and variables using the specified connection for remote execution. Uses the adams.scripting.command.flow.RemoteFlowExecution remote command behind the scenes.
class	Sequence	Encapsulates a sequence of flow items.
class	SinkReset	Resets all sub-actors in case the monitored variable changed since the last execution.
class	SourceReset	Resets all sub-actors in case the monitored variable changed since the last execution.
class	StorageValueSequence	After executing a sequence of actors, the stored item is forwarded in the flow.
class	SubProcess	Encapsulates a sequence of flow items.
class	Switch	Emulates a Switch control statement.
class	Tee	Allows to tap into the flow and tee-off tokens.
class	TimedSubProcess	Encapsulates a sequence of flow items.
class	TimedTee	Allows to tap into the flow and tee-off tokens. Times how long the sub-flow execution takes and sends the time in milli-seconds (as double) in a adams.flow.container.TimingContainer container to the specified callable actor.
class	TimedTrigger	Executes the subs-actors whenever a token gets passed through.
class	TransformerReset	Resets all sub-actors in case the monitored variable changed since the last execution.
class	Trigger	Executes the tee-actor whenever a token gets passed through.
class	TriggerOnce	Triggers the sub-flow only once. However, this can be reset when the monitored variable changes.
class	TryCatch	Safe-guards the execution of the 'try' sequence of actors.
class	UpdateContainerValue	Applies all sub-actors to process the specified value of the container passing through.
class	UpdateProperties	Updates the properties of the sub-actor using the values associated with the specfiied variables.
class	WhileLoop	Emulates a while-loop.

Methods in adams.flow.control with parameters of type ActorHandler

Modifier and Type	Method	Description
String	Flow.addCallableName(ActorHandler handler, Actor actor)	Adds the callable name to the list of used ones.
String	LocalScopeSubProcess.addCallableName(ActorHandler handler, Actor actor)	Adds the callable name to the list of used ones.
String	LocalScopeTee.addCallableName(ActorHandler handler, Actor actor)	Adds the callable name to the list of used ones.
String	LocalScopeTrigger.addCallableName(ActorHandler handler, Actor actor)	Adds the callable name to the list of used ones.
String	ScopeHandler.addCallableName(ActorHandler handler, Actor actor)	Adds the callable name to the list of used ones.
boolean	Flow.isCallableNameUsed(ActorHandler handler, Actor actor)	Checks whether a callable name is already in use.
boolean	LocalScopeSubProcess.isCallableNameUsed(ActorHandler handler, Actor actor)	Checks whether a callable name is already in use.
boolean	LocalScopeTee.isCallableNameUsed(ActorHandler handler, Actor actor)	Checks whether a callable name is already in use.
boolean	LocalScopeTrigger.isCallableNameUsed(ActorHandler handler, Actor actor)	Checks whether a callable name is already in use.
boolean	ScopeHandler.isCallableNameUsed(ActorHandler handler, Actor actor)	Checks whether a callable name is already in use.

Uses of ActorHandler in adams.flow.core

Subinterfaces of ActorHandler in adams.flow.core

Modifier and Type	Interface	Description
interface	ActorReferenceHandler	Interface for actors that manage callable actors.
interface	FixedNameActorHandler	Interface for actor handlers that use fixed names for their sub-actors, e.g., IfThenElse.
interface	MutableActorHandler	Interface for actors that allow to add/remove sub-actors as well.
interface	SortableActorHandler	Interface for actor handlers that can sort their child actors.

Methods in adams.flow.core that return types with arguments of type ActorHandler

Modifier and Type	Method	Description
static List<ActorHandler>	ActorUtils.findActorHandlers(Actor actor)	Returns a list of actor handlers, starting from the current note (excluded).
static List<ActorHandler>	ActorUtils.findActorHandlers(Actor actor, boolean mustAllowStandalones)	Returns a list of actor handlers, starting from the current note (excluded).
static List<ActorHandler>	ActorUtils.findActorHandlers(Actor actor, boolean mustAllowStandalones, boolean includeSameLevel)	Returns a list of actor handlers, starting from the current note (excluded).

Methods in adams.flow.core with parameters of type ActorHandler

Modifier and Type	Method	Description
void	CallableNamesRecorder.add(ActorHandler handler, Actor actor)	Adds the name to the recorded ones.
boolean	CallableNamesRecorder.contains(ActorHandler handler, Actor actor)	Checks whether the name of the actor is already in use.
static Actor	ActorUtils.createExternalActor(Actor[] actors, ActorHandler suggestion)	Ensures that the actors are enclosed in an "instantiable" wrapper.
Actor	CallableActorHelper.findCallableActor(ActorHandler handler, CallableActorReference name)	Checks a control actor's children whether they contain the callable actor that we're looking for.
protected void	CallableActorHelper.findCallableActors(ActorHandler handler, List<Actor> collected)	Locates callable actors.
protected static Actor	ActorUtils.findClosestType(ActorHandler handler, Class type)	Checks an actor handler's children whether they contain the actor type we're looking for.
protected static List<Actor>	ActorUtils.findClosestTypes(ActorHandler handler, Class type)	Checks an actor handler's children whether they contain the actor type we're looking for.
Actor	EventHelper.findEvent(ActorHandler group, EventReference name)	Checks a control actor's children whether they contain the event that we're looking for.
Actor	CallableActorHelper.findMultiView(ActorHandler handler, CallableActorReference name)	Checks a control actor's children whether they contain the multi-view actor that we're looking for.
protected String	CallableNamesRecorder.generateKey(ActorHandler handler)	Generates the key for the handler.
protected static String	ActorUtils.setActors(ActorHandler handler, Actor[] actors)	Sets the actors in the handler.
static boolean	ActorUtils.uniqueName(Actor actor, ActorHandler handler, int index)	Updates the name of the actor to make it unique among all the other actors of the given handler.

Uses of ActorHandler in adams.flow.processor

Methods in adams.flow.processor with parameters of type ActorHandler

Modifier and Type	Method	Description
protected void	ReactivateActors.activate(ActorHandler handler, int index)	Reactivates the specified actor.

Uses of ActorHandler in adams.flow.sink

Classes in adams.flow.sink that implement ActorHandler

Modifier and Type	Class	Description
class	AutogeneratedSink	Encapsulates a sequence of auto-generated actors. Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.
class	InactiveSink	Encapsulates a sequence of inactive actors. Can be removed with the adams.flow.processor.ReactivateActors processor.

Uses of ActorHandler in adams.flow.source

Classes in adams.flow.source that implement ActorHandler

Modifier and Type	Class	Description
class	AutogeneratedSource	Encapsulates a sequence of auto-generated actors, with the last one generating the output for this meta-source. Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.
class	InactiveSource	Encapsulates a sequence of flow items, with the last one generating the output for this meta-source. Can be removed with the adams.flow.processor.ReactivateActors processor.
class	SequenceSource	Encapsulates a sequence of flow items, with the last one generating the output for this meta-source.
class	SwitchedSource
class	TimedSource	Encapsulates a sequence of flow items, with the last one generating the output for this meta-source. Times how long the sub-source execution takes and sends the time in milli-seconds (as double) in a adams.flow.container.TimingContainer container to the specified callable actor.

Uses of ActorHandler in adams.flow.standalone

Subinterfaces of ActorHandler in adams.flow.standalone

Modifier and Type	Interface	Description
interface	StandaloneGroup<T extends Actor>	Interface for a group of standalones.
interface	StandaloneMutableGroup<T extends Actor>	Interface for a mutable group of standalones.

Classes in adams.flow.standalone that implement ActorHandler

Modifier and Type	Class	Description
class	AbstractMultiView	Ancestor for graphical actors that display multiple views.
class	AbstractMutableActorDaemonEvent<E,P>	Ancestor for daemon events that handle sub-actors.
class	AbstractMutableStandaloneGroupItem<T extends Actor>	Ancestor for group items that can contain other actors.
class	AbstractStandaloneGroup<T extends Actor>	Ancestor for fixed-sized groups.
class	AbstractStandaloneGroupItemGroup<S extends Actor,E extends Actor>	Ancestor for group items that form a group themselves.
class	AbstractStandaloneGroupItemMutableGroup<S extends Actor,E extends Actor>	Ancestor for group items that form a group themselves.
class	AbstractStandaloneMutableGroup<T extends Actor>	Ancestor for mutable groups of standalones.
class	AutogeneratedStandalone	Container for auto-generated standalone actors. Can be removed with the adams.flow.processor.RemoveAutogeneratedActors processor.
class	CallableActors	Container for actors that need to be accessed via their name.
class	ConditionalStandalones	Executes the sub-actors only when the boolean condition evaluates to 'true'.
class	Cron	Executes an actor according to a pre-defined schedule. Note: since the actor merely starts the cron scheduler in the background, the actor finishes the execution pretty much immediately.
class	DelayedEvent	Executes its sub-flow after a predefined number of milli-seconds.
class	DirWatch
class	Events	Container for event actors.
class	GridView	Displays multiple graphical actors in a grid.
class	InactiveStandalone	Container for inactive standalone actors. Can be activated with the adams.flow.processor.ReactivateActors processor.
class	JavaExec	Forks off a new JVM with the same classpath by default.
class	LogEvent	Listens to the global log record handler and processes records that passed the specified filter(s). This allows, for instance, the output of log messages into a log file. By default, log records are only processed if the sub-actors are not currently being executed.
class	QueueEvent	Executes its sub-flow after a predefined number of milli-seconds.
class	Standalones	Container for standalone actors.
class	StandaloneSubFlow
class	SubProcessEvent	Executes its sub-flow after a predefined number of milli-seconds.
class	TabView	Displays multiple graphical actors in a tabbed pane.
class	VariableChangedEvent	Listens to a any changes to the specified variable. This allows, for instance, the monitoring of a variable. Enable the 'noDiscard' property to process all change events - NB: this can slow down the system significantly.

Uses of ActorHandler in adams.flow.transformer

Classes in adams.flow.transformer that implement ActorHandler

Modifier and Type	Class	Description
class	AutogeneratedTransformer	Encapsulates a sequence of auto-generated actors.
class	InactiveTransformer	Encapsulates a sequence of inactive actors.

Uses of ActorHandler in adams.gui.flow.tree

Classes in adams.gui.flow.tree that implement ActorHandler

Modifier and Type	Class	Description
class	ClipboardActorContainer	A simple container for multiple actors, for easy copying to and retrieving from the clipboard.

Methods in adams.gui.flow.tree with parameters of type ActorHandler

Modifier and Type	Method	Description
void	TreeOperations.encloseActor(TreePath[] paths, ActorHandler handler)	Encloses the selected actors in the specified actor handler.

Uses of ActorHandler in adams.gui.flow.tree.record.enclose

Methods in adams.gui.flow.tree.record.enclose with parameters of type ActorHandler

Modifier and Type	Method	Description
protected abstract void	AbstractRecordActorEnclosed.doRecord(Tree tree, TreePath[] paths, ActorHandler handler)	Records the enclosing action.
protected void	MostCommon.doRecord(Tree tree, TreePath[] paths, ActorHandler handler)	Records the enclosing action.
protected void	SimpleLog.doRecord(Tree tree, TreePath[] paths, ActorHandler handler)	Records the enclosing action.
void	AbstractRecordActorEnclosed.record(Tree tree, TreePath[] paths, ActorHandler handler)	Records the enclosing action.
static void	AbstractRecordActorEnclosed.recordAll(Tree tree, TreePath[] paths, ActorHandler handler)	Records the actor that was added.