Uses of Interface
adams.flow.core.MutableActorHandler

Packages that use MutableActorHandler

Package	Description
adams.flow.control
adams.flow.core
adams.flow.sink
adams.flow.source
adams.flow.standalone
adams.flow.template
adams.flow.transformer
adams.gui.flow.tree

Uses of MutableActorHandler in adams.flow.control

Classes in adams.flow.control that implement MutableActorHandler

Modifier and Type	Class	Description
class	AbstractContainerUpdater	Ancestor for control actors that update a specific value of a container using the defined sub-actors.
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	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	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.
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.
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	UpdateContainerValue	Applies all sub-actors to process the specified value of the container passing through.
class	WhileLoop	Emulates a while-loop.

Uses of MutableActorHandler in adams.flow.core

Subinterfaces of MutableActorHandler in adams.flow.core

Modifier and Type	Interface	Description
interface	ActorReferenceHandler	Interface for actors that manage callable actors.
interface	SortableActorHandler	Interface for actor handlers that can sort their child actors.

Uses of MutableActorHandler in adams.flow.sink

Classes in adams.flow.sink that implement MutableActorHandler

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 MutableActorHandler in adams.flow.source

Classes in adams.flow.source that implement MutableActorHandler

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

Uses of MutableActorHandler in adams.flow.standalone

Subinterfaces of MutableActorHandler in adams.flow.standalone

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

Classes in adams.flow.standalone that implement MutableActorHandler

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	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	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	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.

Fields in adams.flow.standalone declared as MutableActorHandler

Modifier and Type	Field	Description
protected MutableActorHandler	AbstractMutableStandaloneGroupItem.m_Actors	the flow items.

Methods in adams.flow.standalone that return MutableActorHandler

Modifier and Type	Method	Description
protected MutableActorHandler	AbstractMutableStandaloneGroupItem.getInternalActors()	Returns the internal representation of the actors.
protected abstract MutableActorHandler	AbstractMutableStandaloneGroupItem.newActorHandler()	Creates an instance of the actor handler taking care of the sub-actors.

Uses of MutableActorHandler in adams.flow.template

Methods in adams.flow.template with parameters of type MutableActorHandler

Modifier and Type	Method	Description
protected void	OptionTraverser.addDisplay(MutableActorHandler handler)	Adds the display actors.
protected void	OptionTraverserWithSpreadSheetDisplay.addDisplay(MutableActorHandler handler)	Adds the display actors.

Uses of MutableActorHandler in adams.flow.transformer

Classes in adams.flow.transformer that implement MutableActorHandler

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

Uses of MutableActorHandler in adams.gui.flow.tree

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

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