Uses of Interface
adams.core.Pausable

Packages that use Pausable

Package	Description
adams.flow
adams.flow.control
adams.flow.setup
adams.flow.sink
adams.flow.source
adams.flow.standalone
adams.flow.transformer
adams.gui.flow
adams.multiprocess
adams.opt.genetic
adams.scripting.engine

Uses of Pausable in adams.flow

Classes in adams.flow that implement Pausable

Modifier and Type	Class	Description
class	FlowRunner	Executes flows from command-line. It is also possible to traverse a directory and execute all flows within that match a regular expression. Using the 'no-execute' option, you can suppress the flow execution, but still test whether the flow loads and can be fully set up and wrapped up.

Uses of Pausable in adams.flow.control

Classes in adams.flow.control that implement Pausable

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

Uses of Pausable in adams.flow.setup

Classes in adams.flow.setup that implement Pausable

Modifier and Type	Class	Description
class	FlowSetup	Container object for a flow file with name and information about it.
class	FlowSetupWorker	A specialized SwingWorker class for executing FlowSetups.

Uses of Pausable in adams.flow.sink

Classes in adams.flow.sink that implement Pausable

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

Classes in adams.flow.source that implement Pausable

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	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 Pausable in adams.flow.standalone

Classes in adams.flow.standalone that implement Pausable

Modifier and Type	Class	Description
class	AbstractMutableStandaloneGroupItem<T extends Actor>	Ancestor for group items that can contain other actors.
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	Events	Container for event actors.
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	Standalones	Container for standalone actors.
class	SubProcessEvent	Executes its sub-flow after a predefined number of milli-seconds.

Uses of Pausable in adams.flow.transformer

Classes in adams.flow.transformer that implement Pausable

Modifier and Type	Class	Description
class	AutogeneratedTransformer	Encapsulates a sequence of auto-generated actors.
class	ExecuteJobs	Executes the incoming jobs.
class	ExecuteRemoteCommand	Executes the incoming commands.
class	InactiveTransformer	Encapsulates a sequence of inactive actors.
class	WekaClassifierRanker	Performs a quick evaluation using cross-validation on a single dataset (or evaluation on a separate test set if the number of folds is less than 2) to rank the classifiers received on the input and forwarding the x best ones.
class	WekaGeneticAlgorithm	Applies the genetic algorithm to the incoming dataset. Forwards the best setup(s) after the algorithm finishes. A callable sink can be specified for receiving intermediate performance results.

Uses of Pausable in adams.gui.flow

Classes in adams.gui.flow that implement Pausable

Modifier and Type	Class	Description
class	FlowWorker	Specialized worker class for executing a flow.

Uses of Pausable in adams.multiprocess

Subinterfaces of Pausable in adams.multiprocess

Modifier and Type	Interface	Description
interface	JobRunner<T extends Job>	Interface for runners that execute jobs.

Classes in adams.multiprocess that implement Pausable

Modifier and Type	Class	Description
class	AbstractJobRunner<T extends Job>	Ancestor for jobrunner classes.
class	AbstractMetaJobRunner	Ancestor for meta-jobrunners, that wrap around a base jobrunner.
class	LocalJobRunner<T extends Job>	Executes the jobs on the local machine.
class	PausableFixedThreadPoolExecutor	The thread pool executor for the LocalJobRunner class.
class	RemoteCommandJobRunner	Utilizes the remote command framework for sending jobs to a remote machine.
class	ScpJobRunner	Wraps another jobrunner and serializes it, scp's it to the specified remote file and then waits for the specified import file (containing the serialized, executed jobs) to appear. Requires a adams.flow.standalone.SSHConnection standalone for defining the SSH connection.
protected static class	ScpJobRunner.RemoteJobRunner
class	SerializingJobRunner	Wraps another jobrunner and serializes it to the specified export file and then waits for the specified import file (containing the serialized, executed jobs) to appear.

Uses of Pausable in adams.opt.genetic

Classes in adams.opt.genetic that implement Pausable

Modifier and Type	Class	Description
class	AbstractClassifierBasedGeneticAlgorithm	Ancestor for genetic algorithms that evaluate classifiers.
class	AbstractClassifierBasedGeneticAlgorithmWithSecondEvaluation	Ancestor for genetic algorithms that offer a second evaluation using a different seed value.
class	AbstractGeneticAlgorithm	Base class for genetic algorithms.
class	DarkLord
class	Hermione	Hermione.
class	PackDataGeneticAlgorithm	???

Uses of Pausable in adams.scripting.engine

Subinterfaces of Pausable in adams.scripting.engine

Modifier and Type	Interface	Description
interface	JobQueueHandler	Interface for scripting engines that manage a job queue.
interface	MainScriptingEngine	Interface for scripting engines that manage worker scripting engines and sending them jobs for execution.
interface	RemoteScriptingEngine	Scripting engine for remote commands.

Classes in adams.scripting.engine that implement Pausable

Modifier and Type	Class	Description
class	AbstractScriptingEngine	Ancestor of scripting engine for remote commands.
class	AbstractScriptingEngineEnhancer	Ancestor for scripting engines that enhance a base one.
class	AbstractScriptingEngineWithJobQueue	Ancestor for scripting engines that manage a job queue to restrict executions.
class	DefaultMainScriptingEngine	Manages worker scripting engines and sends them jobs for execution.
class	DefaultScriptingEngine	Default implementation of scripting engine for remote commands.
class	DefaultWorkerScriptingEngine	Registers itself with a main engine for executing jobs.
class	FileBasedScriptingEngine	Scripting engine that reads remote commands from disk.
class	ForwardingScriptingEngine	Simply forwards incoming commands to the specified connection.
class	ManualFeedScriptingEngine	Scripting engine that gets commands fed programmatically.
class	MultiScriptingEngine	Manages multiple scripting engines.