Module org.refcodes.component

Package org.refcodes.component

package org.refcodes.component

Class	Description
AbstractComponentComposite<C extends Component>	The AbstractComponentComposite is an implementation of the ComponentComposite.
AbstractComponentComposite.ExtendedCompositeComponentImpl<C extends Component,CTX,CON>	The AbstractComponentComposite.ExtendedCompositeComponentImpl is an implementation of the ComponentComposite.ExtendedComponentComposite.
AbstractConnectable	The AbstractConnectable provides base functionality required by connection related components.
AbstractConnectableAutomaton	The AbstractConnectableAutomaton implements the very basic AbstractConnectableAutomaton functionality.
AbstractDeviceAutomaton	The AbstractDeviceAutomaton implements the very basic AbstractDeviceAutomaton functionality.
BidirectionalConnectionAccessor<INPUT,OUTPUT>	Provides an accessor for a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionAccessor.BidirectionalConnectionMutator<INPUT,OUTPUT>	Provides a mutator for a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionAccessor.BidirectionalConnectionProperty<INPUT,OUTPUT>	Provides a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionComponent<INPUT,OUTPUT>	A component implementing the BidirectionalConnectionComponent interface supports a connection.
BidirectionalConnectionComponent.BidirectionalConnectionAutomaton<INPUT,OUTPUT>	A system implementing the BidirectionalConnectionComponent.BidirectionalConnectionAutomaton interface supports managing BidirectionalConnectionComponent instances and takes care that the open/close statuses are invoked in the correct order by throwing according exceptions in case the open/close-cycle is invoked in the wrong order.
BidirectionalConnectionOpenable<INPUT,OUTPUT>	This mixin might be implemented by a component in order to provide opening connection(s) facilities.
BidirectionalConnectionOpenable.BidirectionalConnectionOpenAutomaton<INPUT,OUTPUT>	The BidirectionalConnectionOpenable.BidirectionalConnectionOpenAutomaton interface defines those methods related to the opening of connection(s) life-cycle.
BidirectionalConnectionOpenableHandle<H,INPUT,OUTPUT>	The BidirectionalConnectionOpenableHandle interface defines those methods related to the handle based open/connect life-cycle.
BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle<H,INPUT,OUTPUT>	The BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle interface defines those methods related to the handle based open/connect life-cycle.
Ceasable	This mixin might be implemented by a component in order to provide cease facilities.
Ceasable.CeaseAutomaton	The Ceasable.CeaseAutomaton interface defines those methods related to the cease life-cycle.
Ceasable.CeaseBuilder<B extends Ceasable.CeaseBuilder<B>>	To enable the Ceasable functionality to be invoked in a builder chain.
Ceasable.UncheckedCeasable	See Ceasable without any checked exception being declared.
CeasableHandle<H>	The CeasableHandle interface defines those methods related to the handle based cease life-cycle.
CeasableHandle.CeaseAutomatonHandle<H>	The CeasableHandle.CeaseAutomatonHandle interface defines those methods related to the handle based cease life-cycle.
CeaseException	Thrown in case ceasing a component caused problems.
CeaseException.CeaseRuntimeException	Unchecked exception with the same semantics as the CeaseException.
Closable	This mixin might be implemented by a component in order to provide closing connection(s) facilities.
Closable.CloseAutomaton	The Closable.CloseAutomaton interface defines those methods related to the closing of connection(s) life-cycle.
Closable.CloseBuilder<B extends Closable.CloseBuilder<B>>	To enable the Closable functionality to be invoked in a builder chain.
ClosableHandle<H>	The ClosableHandle interface defines those methods related to the handle based close life-cycle.
ClosableHandle.CloseAutomatonHandle<H>	The ClosableHandle.CloseAutomatonHandle interface defines those methods related to the handle based close life-cycle.
ClosedAccessor	Provides an accessor for a closed property.
ClosedAccessor.ClosedMutator	Provides a mutator for a closed property.
ClosedAccessor.ClosedProperty	Provides a closed property.
CloseException	Thrown in case closing a component caused problems.
CloseException.CloseRuntimeException	Unchecked exception with the same semantics as the CloseException.
Component	Per definition any Component at least must provide a Destroyable.destroy() method.
ComponentComposite	Any composite implementation of the refcodes frameworks should implement this ComponentComposite interface so that any therein contained Component instances' state change methods are supported by the ComponentComposite as well and forwarded to the Component contained in the ComponentComposite instance.
ComponentComposite.ExtendedComponentComposite<CTX,CON>	The ComponentComposite.ExtendedComponentComposite provides extended functionality to the ComponentComposite's functionality by including extended Openable functionality (ConnectionOpenable) and extends Initializable functionality (Configurable).
ComponentException	This exception is the base exception for the component package.
ComponentHandleComposite<H,REF>	Similar to the ComponentComposite, the ComponentHandleComposite provides all the defined handle based functionality, implementing classes provide the means to invoke those methods in case them are supported by the referenced components.
ComponentRuntimeException	This exception is the base runtime exception for the component package.
ComponentRuntimeException.ComponentHandleRuntimeException	This exception is the base exception for handle related runtime exceptions.
ComponentUtility	The Class ComponentUtility.
Configurable<CTX>	This mixin might be implemented by a component in order to provide initialize facilities wit a configuration provided via Configurable.initialize(Object).
Configurable.ConfigureAutomaton<CTX>	The Configurable.ConfigureAutomaton interface defines those methods related to the initialize life-cycle with a provided context.
Configurable.ConfigureBuilder<CTX,B extends Configurable.ConfigureBuilder<CTX,B>>	To enable the Initializable functionality to be invoked in a builder chain.
ConfigurableComponent<CTX>	A ConfigurableComponent can be configured invoking the method Configurable.initialize(Object).
ConfigurableHandle<H,CTX>	The ConfigurableHandle interface defines those methods related to the handle based initialize/configure life-cycle.
ConfigurableHandle.ConfigureAutomatonHandle<H,CTX>	The ConfigurableHandle.ConfigureAutomatonHandle interface defines those methods related to the handle based initialize/configure life-cycle.
ConfigurableLifecycleAutomatonImpl<CTX>	This class implements a ConfigurableLifecycleComponent.ConfigurableLifecycleAutomaton.
ConfigurableLifecycleComponent<CTX>	A component implementing the ConfigurableLifecycleComponent interface supports a life-cycle.
ConfigurableLifecycleComponent.ConfigurableLifecycleAutomaton<CTX>	A system implementing the ConfigurableLifecycleComponent.ConfigurableLifecycleAutomaton interface supports managing ConfigurableLifecycleComponent instances and takes care that the open/close statuses are invoked in the correct order by throwing according exceptions in case the open/close-cycle is invoked in the wrong order.
ConfigurableLifecycleComponentHandle<H,CTX>	The ConfigurableLifecycleComponentHandle manages various LifecycleStatus states for ConfigurableLifecycleComponent instances each related to a handle.
ConfigurableLifecycleComponentHandle.ConfigurableLifecycleAutomatonHandle<H,CTX>	The ConfigurableLifecycleComponentHandle.ConfigurableLifecycleAutomatonHandle is an automaton managing various LifecycleStatus states for Component instances each related to a handle.
ConfigureException	Thrown in case initializing a component caused problems.
ConfigureException.ConfigureRuntimeException	Thrown in case initializing a component caused problems.
ConnectableComponent	Any Component which operates established connections may implement the ConnectableComponent interface providing a minimal set of functionality to work with connections; to test whether a connection is open and to close an open connection.
ConnectableComponent.ConnectableAutomaton	The ConnectableComponent.ConnectableAutomaton extends the ConnectableComponent with automaton functionality to get detailed status information regarding connections.
ConnectionAccessor<CON>	Provides an accessor for a connection property for e.g. an InputStream or an OutputStream.
ConnectionAccessor.ConnectionMutator<CON>	Provides a mutator for a connection property for e.g. an InputStream or an OutputStream.
ConnectionAccessor.ConnectionProperty<CON>	Provides a connection property for e.g. an InputStream or an OutputStream.
ConnectionAutomatonImpl<CON>	This class implements a ConnectionComponent.ConnectionAutomaton.
ConnectionComponent<CON>	A component implementing the ConnectionComponent interface supports a connection.
ConnectionComponent.ConnectionAutomaton<CON>	A system implementing the ConnectionComponent.ConnectionAutomaton interface supports managing ConnectionComponent instances and takes care that the open/close statuses are invoked in the correct order by throwing according exceptions in case the open/close-cycle is invoked in the wrong order.
ConnectionComponent.ConnectionComponentBuilder<CON,B extends ConnectionComponent.ConnectionComponentBuilder<CON,B>>	Similar to the ConnectionComponent with additional according builder methods.
ConnectionComponentHandle<H,CON>	The ConnectionComponentHandle manages various ConnectionStatus states for ConnectionComponent instances each related to a handle.
ConnectionComponentHandle.ConnectionAutomatonHandle<H,CON>	The ConnectionComponentHandle.ConnectionAutomatonHandle is an automaton managing various ConnectionStatus states for ConnectionComponent instances each related to a handle.
ConnectionOpenable<CON>	This mixin might be implemented by a component in order to provide opening connection(s) facilities.
ConnectionOpenable.ConnectionOpenAutomaton<CON>	The ConnectionOpenable.ConnectionOpenAutomaton interface defines those methods related to the opening of connection(s) life-cycle.
ConnectionOpenable.ConnectionOpenBuilder<CON,B extends ConnectionOpenable.ConnectionOpenBuilder<CON,B>>	To enable the Startable functionality to be invoked in a builder chain.
ConnectionOpenableHandle<H,CON>	The ConnectionOpenableHandle interface defines those methods related to the handle based open/connect life-cycle.
ConnectionOpenableHandle.ConnectionOpenAutomatonHandle<H,CON>	The ConnectionOpenableHandle.ConnectionOpenAutomatonHandle interface defines those methods related to the handle based open/connect life-cycle.
ConnectionRequest	An enumeration describing the connection requests.
ConnectionStatus	The Enum ConnectionStatus.
ConnectionStatusAccessor	Provides an accessor for a ConnectionStatus property.
ConnectionStatusAccessor.ConnectionStatusMutator	Provides a mutator for a ConnectionStatus property.
ConnectionStatusAccessor.ConnectionStatusProperty	Provides a ConnectionStatus property.
ConnectionStatusHandle<H>	The Interface ConnectionStatusHandle.
ContextAccessor<CTX>	Provides an accessor for a context property for e.g. a service or a component.
ContextAccessor.ContextBuilder<CTX,B extends ContextAccessor.ContextBuilder<CTX,B>>	Provides a builder method for a context property returning the builder for applying multiple build operations.
ContextAccessor.ContextMutator<CTX>	Provides a mutator for a context property for e.g. a service or a component.
ContextAccessor.ContextProperty<CTX>	Provides a context property for e.g. a service or a component.
Decomposable	This mixin might be implemented by a component in order to provide decomposition facilities.
Decomposable.DecomposeAutomaton	The Decomposable.DecomposeAutomaton interface defines those methods related to the decompose life-cycle.
DecomposableHandle<H>	The DecomposableHandle interface defines those methods related to the handle based decompose life-cycle.
DecomposableHandle.DecomposeAutomatonHandle<H>	The DecomposableHandle.DecomposeAutomatonHandle interface defines those methods related to the handle based decompose life-cycle.
DecomposeException	Thrown in case decomposing a component caused problems.
DecomposeException.DecomposeRuntimeException	Unchecked exception with the same semantics as the DecomposeException.
Destroyable	This mixin might be implemented by a Component in order to provide destroy facilities.
Destroyable.DestroyAutomaton	The Destroyable.DestroyAutomaton interface defines those methods related to the destroy life-cycle.
DestroyableHandle<H>	The DestroyableHandle interface defines those methods related to the handle based destroy life-cycle.
DestroyableHandle.DestroyAutomatonHandle<H>	The DestroyableHandle.DestroyAutomatonHandle interface defines those methods related to the handle based destroy life-cycle.
DestroyException	Thrown in case destroying a component caused problems.
DestroyException.DestroyRuntimeException	Unchecked exception with the same semantics as the DestroyException.
Digester<J>	A Digester provides the functionality to consume a job (which is pushed from the outside) for further processing.
DigesterComponent<J>	Lifts the Digester mixin to the level of a Component.
DigestException	Thrown in case digesting (processing) a job by a Digester.digest(Object) caused problems; the aCause is usually wrapped by this Exception.
DigestException.DigestRuntimeException	Thrown in case digesting (processing) a job by a Digester.digest(Object) caused problems; the aCause is usually wrapped by this Exception.
DisposeException	Thrown in case disposing a component caused problems.
DisposeException.DisposeRuntimeException	Unchecked exception with the same semantics as the DisposeException.
ExecutionStatus
Flushable	This mixin might be implemented by a component in order to provide flush facilities.
Flushable.FlushBuilder<B extends Flushable.FlushBuilder<B>>	The Interface FlushBuilder.
FlushHandle<H>	The FlushHandle interface defines those methods related to the handle based flush operation.
HandleAccessor<H>	Provides an accessor for a handle property for e.g. key / handle pair.
HandleAccessor.HandleMutator<H>	Provides a mutator for a handle property for e.g. key / handle pair.
HandleAccessor.HandleProperty<H>	Provides a handle property for e.g. key / handle pair.
HandleDirectory<H,REF>	The handle directory enables listing of all known data managed by the implementing component.
HandleGenerator<H>	Generates handles of the generic type.
HandleGeneratorImpl	Plain straight forward String instances generating HandleGenerator basically being a plain good old UniqueIdGenerator.
HandleLookup<H,REF>	Any system in this framework being able to work with handles provides an implementation of the handle lookup interface.
HandleTimeoutRuntimeException	This exception is thrown in case a handle was provided which was unknown to the invoked component.
HealthChecker
IllegalHandleStateChangeRuntimeException	This exception is thrown in case a handle was provided whose reference does not support a given operation.
Initializable	This mixin might be implemented by a component in order to provide initializing facilities.
Initializable.InitializeAutomaton	The Initializable.InitializeAutomaton interface defines those methods related to the initialize life-cycle.
Initializable.InitializeBuilder<B extends Initializable.InitializeBuilder<B>>	To enable the Initializable functionality to be invoked in a builder chain.
Initializable.UncheckedInitializable	See Initializable without any checked exception being declared.
InitializableComponent	A InitializableComponent can be initialized invoking the method Initializable.initialize().
InitializableHandle<H>	The InitializableHandle interface defines those methods related to the handle based initialize life-cycle.
InitializableHandle.InitializeAutomatonHandle<H>	The InitializableHandle.InitializeAutomatonHandle interface defines those methods related to the handle based initialize life-cycle.
InitializedAccessor	Provides an accessor for a initialized property.
InitializedAccessor.InitializedMutator	Provides a mutator for a initialized property.
InitializedAccessor.InitializedProperty	Provides a initialized property.
InitializedHandle<H>	Provides access to the initialized handle reference.
InitializeException	Thrown in case initializing a component caused problems.
InitializeException.InitializeRuntimeException	Unchecked exception with the same semantics as the IOException.
LifecycleComponent	A component implementing the LifecycleComponent interface supports a life-cycle.
LifecycleComponent.LifecycleAutomaton	A system implementing the LifecycleComponent.LifecycleAutomaton interface supports managing LifecycleComponent instances and takes care that the life-cycle stages are invoked in the correct order by throwing according exceptions in case the life-cycle is invoked in the wrong order.
LifecycleComponent.UncheckedLifecycleComponent	Same as the LifecycleComponent though without the need to try-catch any exceptions on the various life-cycle stages.
LifecycleComponentHandle<H>	The LifecycleComponentHandle manages various LifecycleStatus states for LifecycleComponent instances each related to a handle.
LifecycleComponentHandle.LifecycleAutomatonHandle<H>	The LifecycleComponentHandle.LifecycleAutomatonHandle is an automaton managing various LifecycleStatus states for Component instances each related to a handle.
LifecycleException	This exception is the base lifecycle exception .
LifecycleException.LifecycleRuntimeException	This exception is the base lifecycle exception .
LifecycleMachine	The LifecycleMachine implements a LifecycleComponent.LifecycleAutomaton.
LifecycleMachine.ManualLifecycleMachine	Opens the otherwise protected LifecycleMachine.ManualLifecycleMachine.setLifecycleStatus(LifecycleStatus) to be public in order to force any lifecycle status to be set.
LifecycleRequest	An enumeration describing the lifecycle requests regarding a component..
LifecycleRequestAccessor	Provides an accessor for a LifecycleRequest property.
LifecycleRequestAccessor.LifecycleRequestMutator	Provides a mutator for a LifecycleRequest property.
LifecycleRequestAccessor.LifecycleRequestProperty	Provides a LifecycleRequest property.
LifecycleStatus	The Enum LifecycleStatus.
LifecycleStatusAccessor	Provides an accessor for a LifecycleStatus property.
LifecycleStatusAccessor.LifecycleStatusBuilder<B extends LifecycleStatusAccessor.LifecycleStatusBuilder<B>>	Provides a builder method for a LifecycleStatus property returning the builder for applying multiple build operations.
LifecycleStatusAccessor.LifecycleStatusMutator	Provides a mutator for a LifecycleStatus property.
LifecycleStatusAccessor.LifecycleStatusProperty	Provides a LifecycleStatus property.
LifecycleStatusHandle<H>	The Interface LifecycleStatusHandle.
LinkAutomatonImpl	This class implements a LifecycleComponent.LifecycleAutomaton.
LinkComponent	A component implementing the LinkComponent interface supports establishing a connection (not necessarily a network connection).
LinkComponent.LinkAutomaton	A system implementing the LinkComponent.LinkAutomaton interface supports managing LinkComponent instances and takes care that the open/close statuses are invoked in the correct order by throwing according exceptions in case the open/close-cycle is invoked in the wrong order.
LinkComponent.LinkComponentBuilder<B extends LinkComponent.LinkComponentBuilder<B>>	Similar to the LinkComponent with additional according builder methods.
LinkComponentHandle<H>	The LinkComponentHandle manages various ConnectionStatus states for LinkComponent instances each related to a handle.
LinkComponentHandle.LinkAutomatonHandle<H>	The LinkComponentHandle.LinkAutomatonHandle is an automaton managing various ConnectionStatus states for Component instances each related to a handle.
Openable	This mixin might be implemented by a component in order to provide opening connection(s) facilities.
Openable.OpenAutomaton	The Openable.OpenAutomaton interface defines those methods related to the opening of connection(s) life-cycle.
Openable.OpenBuilder<B extends Openable.OpenBuilder<B>>	To enable the Startable functionality to be invoked in a builder chain.
OpenableHandle<H>	The OpenableHandle interface defines those methods related to the handle based open/connect life-cycle.
OpenableHandle.OpenAutomatonHandle<H>	The OpenableHandle.OpenAutomatonHandle interface defines those methods related to the handle based open/connect life-cycle.
OpenedAccessor	Provides an accessor for a opened property.
OpenedAccessor.OpenedMutator	Provides a mutator for a opened property.
OpenedAccessor.OpenedProperty	Provides a opened property.
OpenedHandle<H>	Provides access to the opened (connected) handle reference.
Pausable	This mixin might be implemented by a component in order to provide pause facilities.
Pausable.PauseAutomaton	The Pausable.PauseAutomaton interface defines those methods related to the pause life-cycle.
Pausable.PauseBuilder<B extends Pausable.PauseBuilder<B>>	To enable the Pausable functionality to be invoked in a builder chain.
Pausable.UncheckedPausable	See Pausable without any checked exception being declared.
PausableHandle<H>	The PausableHandle interface defines those methods related to the handle based pause life-cycle.
PausableHandle.PauseAutomatonHandle<H>	The PausableHandle.PauseAutomatonHandle interface defines those methods related to the handle based pause life-cycle.
PauseException	Thrown in case pausing a component caused problems.
PauseException.PauseRuntimeException	Unchecked exception with the same semantics as the PauseException.
ProgressAccessor	Provides an accessor for a progress property.
ProgressAccessor.ProgressMutator	Provides a mutator for a progress property.
ProgressAccessor.ProgressProperty	Provides a progress property.
ProgressHandle<H>	Whenever a handle is associated with a progress, then a component providing such handles should implement this interface.
Reloadable	This mixin might be implemented by a component in order to provide reload facilities.
Reloadable.ReloadBuilder<B extends Reloadable.ReloadBuilder<B>>	The Interface ReloadBuilder.
ReloadHandle<H>	The ReloadHandle interface defines those methods related to the handle based reload operation.
ResetException	Thrown in case resetting a component caused problems.
ResetException.ResetRuntimeException	Unchecked exception with the same semantics as the ResetException.
ResetHandle<H>	The ResetHandle interface defines those methods related to the handle based reset operation.
Resumable	This mixin might be implemented by a component in order to provide resume facilities.
Resumable.ResumeAutomaton	The Resumable.ResumeAutomaton interface defines those methods related to the resume life-cycle.
Resumable.ResumeBuilder<B extends Resumable.ResumeBuilder<B>>	To enable the Resumable functionality to be invoked in a builder chain.
Resumable.UncheckedResumable	See Resumable without any checked exception being declared.
ResumableHandle<H>	The ResumableHandle interface defines those methods related to the handle based resume life-cycle.
ResumableHandle.ResumeAutomatonHandle<H>	The ResumableHandle.ResumeAutomatonHandle interface defines those methods related to the handle based resume life-cycle.
ResumeException	Thrown in case resuming a component caused problems.
ResumeException.ResumeRuntimeException	Unchecked exception with the same semantics as the ResumeException.
RunningAccessor	Provides an accessor for a running property.
RunningAccessor.RunningMutator	Provides a mutator for a running property.
RunningAccessor.RunningProperty	Provides a running property.
RunningHandle<H>	Provides access to the running handle reference.
Startable	This mixin might be implemented by a component in order to provide start facilities.
Startable.StartAutomaton	The Startable.StartAutomaton interface defines those methods related to the start life-cycle.
Startable.StartBuilder<B extends Startable.StartBuilder<B>>	To enable the Startable functionality to be invoked in a builder chain.
Startable.UncheckedStartable	See Startable without any checked exception being declared.
StartableHandle<H>	The StartableHandle interface defines those methods related to the handle based start life-cycle.
StartableHandle.StartAutomatonHandle<H>	The StartableHandle.StartAutomatonHandle interface defines those methods related to the handle based start life-cycle.
StartException	Thrown in case starting a component caused problems.
StartException.StartRuntimeException	Unchecked exception with the same semantics as the StartException.
StopException	Thrown in case stopping a component caused problems.
StopException.StopRuntimeException	Unchecked exception with the same semantics as the StopException.
Stoppable	This mixin might be implemented by a component in order to provide stop facilities.
Stoppable.StopAutomaton	The Stoppable.StopAutomaton interface defines those methods related to the stop life-cycle.
Stoppable.StopBuilder<B extends Stoppable.StopBuilder<B>>	To enable the Stoppable functionality to be invoked in a builder chain.
Stoppable.UncheckedStoppable	See Stoppable without any checked exception being declared.
StoppableHandle<H>	The StoppableHandle interface defines those methods related to the handle based stop life-cycle.
StoppableHandle.StopAutomatonHandle<H>	The StoppableHandle.StopAutomatonHandle interface defines those methods related to the handle based stop life-cycle.
UnknownHandleRuntimeException	This exception is thrown in case a handle was provided which was unknown to the invoked component.
UnsupportedHandleOperationRuntimeException	This exception is thrown in case a handle was provided whose reference does not support a given operation.