Module org.refcodes.component
Package org.refcodes.component
-
Interface Summary Interface Description BidirectionalConnectionAccessor<INPUT,OUTPUT> Provides an accessor for a connection property for e.g. anInputStream
or anOutputStream
.BidirectionalConnectionAccessor.BidirectionalConnectionMutator<INPUT,OUTPUT> Provides a mutator for a connection property for e.g. anInputStream
or anOutputStream
.BidirectionalConnectionAccessor.BidirectionalConnectionProperty<INPUT,OUTPUT> Provides a connection property for e.g. anInputStream
or anOutputStream
.BidirectionalConnectionComponent<INPUT,OUTPUT> A component implementing theBidirectionalConnectionComponent
interface supports a connection.BidirectionalConnectionComponent.BidirectionalConnectionAutomaton<INPUT,OUTPUT> A system implementing theBidirectionalConnectionComponent.BidirectionalConnectionAutomaton
interface supports managingBidirectionalConnectionComponent
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> TheBidirectionalConnectionOpenable.BidirectionalConnectionOpenAutomaton
interface defines those methods related to the opening of connection(s) life-cycle.BidirectionalConnectionOpenableHandle<H,INPUT,OUTPUT> TheBidirectionalConnectionOpenableHandle
interface defines those methods related to the handle based open/connect life-cycle.BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle<H,INPUT,OUTPUT> TheBidirectionalConnectionOpenableHandle.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 TheCeasable.CeaseAutomaton
interface defines those methods related to the cease life-cycle.Ceasable.CeaseBuilder<B extends Ceasable.CeaseBuilder<B>> To enable theCeasable
functionality to be invoked in a builder chain.Ceasable.UncheckedCeasable SeeCeasable
without any checked exception being declared.CeasableHandle<H> TheCeasableHandle
interface defines those methods related to the handle based cease life-cycle.CeasableHandle.CeaseAutomatonHandle<H> TheCeasableHandle.CeaseAutomatonHandle
interface defines those methods related to the handle based cease life-cycle.Closable This mixin might be implemented by a component in order to provide closing connection(s) facilities.Closable.CloseAutomaton TheClosable.CloseAutomaton
interface defines those methods related to the closing of connection(s) life-cycle.Closable.CloseBuilder<B extends Closable.CloseBuilder<B>> To enable theClosable
functionality to be invoked in a builder chain.ClosableHandle<H> TheClosableHandle
interface defines those methods related to the handle based close life-cycle.ClosableHandle.CloseAutomatonHandle<H> TheClosableHandle.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.Component Per definition anyComponent
at least must provide aDestroyable.destroy()
method.CompositeComponent Any composite implementation of the refcodes frameworks should implement thisCompositeComponent
interface so that any therein containedComponent
instances' state change methods are supported by theCompositeComponent
as well and forwarded to theComponent
contained in theCompositeComponent
instance.CompositeComponent.ExtendedCompositeComponent<CTX,CON> TheCompositeComponent.ExtendedCompositeComponent
provides extended functionality to theCompositeComponent
's functionality by including extendedOpenable
functionality (ConnectionOpenable
) and extendsInitializable
functionality (Configurable
).CompositeComponentHandle<H,REF> Similar to theCompositeComponent
, theCompositeComponentHandle
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.Configurable<CTX> This mixin might be implemented by a component in order to provide initialize facilities wit a configuration provided viaConfigurable.initialize(Object)
.Configurable.ConfigureAutomaton<CTX> TheConfigurable.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 theInitializable
functionality to be invoked in a builder chain.ConfigurableComponent<CTX> AConfigurableComponent
can be configured invoking the methodConfigurable.initialize(Object)
.ConfigurableHandle<H,CTX> TheConfigurableHandle
interface defines those methods related to the handle based initialize/configure life-cycle.ConfigurableHandle.ConfigureAutomatonHandle<H,CTX> TheConfigurableHandle.ConfigureAutomatonHandle
interface defines those methods related to the handle based initialize/configure life-cycle.ConfigurableLifeCycleComponent<CTX> A component implementing theConfigurableLifeCycleComponent
interface supports a life-cycle.ConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton<CTX> A system implementing theConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton
interface supports managingConfigurableLifeCycleComponent
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> TheConfigurableLifeCycleComponentHandle
manages variousLifeCycleStatus
states forConfigurableLifeCycleComponent
instances each related to a handle.ConfigurableLifeCycleComponentHandle.ConfigurableLifeCycleAutomatonHandle<H,CTX> TheConfigurableLifeCycleComponentHandle.ConfigurableLifeCycleAutomatonHandle
is an automaton managing variousLifeCycleStatus
states forComponent
instances each related to a handle.ConnectableComponent AnyComponent
which operates established connections may implement theConnectableComponent
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 TheConnectableComponent.ConnectableAutomaton
extends theConnectableComponent
with automaton functionality to get detailed status information regarding connections.ConnectionAccessor<CON> Provides an accessor for a connection property for e.g. anInputStream
or anOutputStream
.ConnectionAccessor.ConnectionMutator<CON> Provides a mutator for a connection property for e.g. anInputStream
or anOutputStream
.ConnectionAccessor.ConnectionProperty<CON> Provides a connection property for e.g. anInputStream
or anOutputStream
.ConnectionComponent<CON> A component implementing theConnectionComponent
interface supports a connection.ConnectionComponent.ConnectionAutomaton<CON> A system implementing theConnectionComponent.ConnectionAutomaton
interface supports managingConnectionComponent
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 theConnectionComponent
with additional according builder methods.ConnectionComponentHandle<H,CON> TheConnectionComponentHandle
manages variousConnectionStatus
states forConnectionComponent
instances each related to a handle.ConnectionComponentHandle.ConnectionAutomatonHandle<H,CON> TheConnectionComponentHandle.ConnectionAutomatonHandle
is an automaton managing variousConnectionStatus
states forConnectionComponent
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> TheConnectionOpenable.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 theStartable
functionality to be invoked in a builder chain.ConnectionOpenableHandle<H,CON> TheConnectionOpenableHandle
interface defines those methods related to the handle based open/connect life-cycle.ConnectionOpenableHandle.ConnectionOpenAutomatonHandle<H,CON> TheConnectionOpenableHandle.ConnectionOpenAutomatonHandle
interface defines those methods related to the handle based open/connect life-cycle.ConnectionStatusAccessor Provides an accessor for aConnectionStatus
property.ConnectionStatusAccessor.ConnectionStatusMutator Provides a mutator for aConnectionStatus
property.ConnectionStatusAccessor.ConnectionStatusProperty Provides aConnectionStatus
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.Decomposeable This mixin might be implemented by a component in order to provide decomposition facilities.Decomposeable.DecomposeAutomaton TheDecomposeable.DecomposeAutomaton
interface defines those methods related to the decompose life-cycle.DecomposeableHandle<H> TheDecomposeableHandle
interface defines those methods related to the handle based decompose life-cycle.DecomposeableHandle.DecomposeAutomatonHandle<H> TheDecomposeableHandle.DecomposeAutomatonHandle
interface defines those methods related to the handle based decompose life-cycle.Destroyable This mixin might be implemented by aComponent
in order to provide destroy facilities.Destroyable.DestroyAutomaton TheDestroyable.DestroyAutomaton
interface defines those methods related to the destroy life-cycle.DestroyableHandle<H> TheDestroyableHandle
interface defines those methods related to the handle based destroy life-cycle.DestroyableHandle.DestroyAutomatonHandle<H> TheDestroyableHandle.DestroyAutomatonHandle
interface defines those methods related to the handle based destroy life-cycle.Digester<J> ADigester
provides the functionality to consume a job (which is pushed from the outside) for further processing.DigesterComponent<J> DisposableHandle<H> TheDisposableHandle
interface defines those methods related to the handle based dispose life-cycle.DisposableHandle.DisposeAutomatonHandle<H> TheDisposableHandle.DisposeAutomatonHandle
interface defines those methods related to the handle based dispose life-cycle.DisposeAutomaton TheDisposeAutomaton
interface defines those methods related to the dispose life-cycle.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> TheFlushHandle
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.HandleLookup<H,REF> Any system in this framework being able to work with handles provides an implementation of the handle lookup interface.HealthChecker Initializable This mixin might be implemented by a component in order to provide initializing facilities.Initializable.InitializeAutomaton TheInitializable.InitializeAutomaton
interface defines those methods related to the initialize life-cycle.Initializable.InitializeBuilder<B extends Initializable.InitializeBuilder<B>> To enable theInitializable
functionality to be invoked in a builder chain.Initializable.UncheckedInitializable SeeInitializable
without any checked exception being declared.InitializableComponent AInitializableComponent
can be initialized invoking the methodInitializable.initialize()
.InitializableHandle<H> TheInitializableHandle
interface defines those methods related to the handle based initialize life-cycle.InitializableHandle.InitializeAutomatonHandle<H> TheInitializableHandle.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.LifeCycleComponent A component implementing theLifeCycleComponent
interface supports a life-cycle.LifeCycleComponent.LifeCycleAutomaton A system implementing theLifeCycleComponent.LifeCycleAutomaton
interface supports managingLifeCycleComponent
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 theLifeCycleComponent
though without the need to try-catch any exceptions on the various life-cycle stages.LifeCycleComponentHandle<H> TheLifeCycleComponentHandle
manages variousLifeCycleStatus
states forLifeCycleComponent
instances each related to a handle.LifeCycleComponentHandle.LifeCycleAutomatonHandle<H> TheLifeCycleComponentHandle.LifeCycleAutomatonHandle
is an automaton managing variousLifeCycleStatus
states forComponent
instances each related to a handle.LifeCycleRequestAccessor Provides an accessor for aLifeCycleRequest
property.LifeCycleRequestAccessor.LifeCycleRequestMutator Provides a mutator for aLifeCycleRequest
property.LifeCycleRequestAccessor.LifeCycleRequestProperty Provides aLifeCycleRequest
property.LifeCycleStatusAccessor Provides an accessor for aLifeCycleStatus
property.LifeCycleStatusAccessor.LifeCycleStatusBuilder<B extends LifeCycleStatusAccessor.LifeCycleStatusBuilder<B>> Provides a builder method for aLifeCycleStatus
property returning the builder for applying multiple build operations.LifeCycleStatusAccessor.LifeCycleStatusMutator Provides a mutator for aLifeCycleStatus
property.LifeCycleStatusAccessor.LifeCycleStatusProperty Provides aLifeCycleStatus
property.LifeCycleStatusHandle<H> The Interface LifeCycleStatusHandle.LinkComponent A component implementing theLinkComponent
interface supports establishing a connection (not necessarily a network connection).LinkComponent.LinkAutomaton A system implementing theLinkComponent.LinkAutomaton
interface supports managingLinkComponent
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 theLinkComponent
with additional according builder methods.LinkComponentHandle<H> TheLinkComponentHandle
manages variousConnectionStatus
states forLinkComponent
instances each related to a handle.LinkComponentHandle.LinkAutomatonHandle<H> TheLinkComponentHandle.LinkAutomatonHandle
is an automaton managing variousConnectionStatus
states forComponent
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 TheOpenable.OpenAutomaton
interface defines those methods related to the opening of connection(s) life-cycle.Openable.OpenBuilder<B extends Openable.OpenBuilder<B>> To enable theStartable
functionality to be invoked in a builder chain.OpenableHandle<H> TheOpenableHandle
interface defines those methods related to the handle based open/connect life-cycle.OpenableHandle.OpenAutomatonHandle<H> TheOpenableHandle.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 ThePausable.PauseAutomaton
interface defines those methods related to the pause life-cycle.Pausable.PauseBuilder<B extends Pausable.PauseBuilder<B>> To enable thePausable
functionality to be invoked in a builder chain.Pausable.UncheckedPausable SeePausable
without any checked exception being declared.PausableHandle<H> ThePausableHandle
interface defines those methods related to the handle based pause life-cycle.PausableHandle.PauseAutomatonHandle<H> ThePausableHandle.PauseAutomatonHandle
interface defines those methods related to the handle based pause life-cycle.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> TheReloadHandle
interface defines those methods related to the handle based reload operation.Resetable This mixin might be implemented by a component in order to provide reset facilities.ResetHandle<H> TheResetHandle
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 TheResumable.ResumeAutomaton
interface defines those methods related to the resume life-cycle.Resumable.ResumeBuilder<B extends Resumable.ResumeBuilder<B>> To enable theResumable
functionality to be invoked in a builder chain.Resumable.UncheckedResumable SeeResumable
without any checked exception being declared.ResumableHandle<H> TheResumableHandle
interface defines those methods related to the handle based resume life-cycle.ResumableHandle.ResumeAutomatonHandle<H> TheResumableHandle.ResumeAutomatonHandle
interface defines those methods related to the handle based resume life-cycle.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 TheStartable.StartAutomaton
interface defines those methods related to the start life-cycle.Startable.StartBuilder<B extends Startable.StartBuilder<B>> To enable theStartable
functionality to be invoked in a builder chain.Startable.UncheckedStartable SeeStartable
without any checked exception being declared.StartableHandle<H> TheStartableHandle
interface defines those methods related to the handle based start life-cycle.StartableHandle.StartAutomatonHandle<H> TheStartableHandle.StartAutomatonHandle
interface defines those methods related to the handle based start life-cycle.Stoppable This mixin might be implemented by a component in order to provide stop facilities.Stoppable.StopAutomaton TheStoppable.StopAutomaton
interface defines those methods related to the stop life-cycle.Stoppable.StopBuilder<B extends Stoppable.StopBuilder<B>> To enable theStoppable
functionality to be invoked in a builder chain.Stoppable.UncheckedStoppable SeeStoppable
without any checked exception being declared.StoppableHandle<H> TheStoppableHandle
interface defines those methods related to the handle based stop life-cycle.StoppableHandle.StopAutomatonHandle<H> TheStoppableHandle.StopAutomatonHandle
interface defines those methods related to the handle based stop life-cycle. -
-
Enum Summary Enum Description ConnectionRequest An enumeration describing the connection requests.ConnectionStatus The Enum ConnectionStatus.ExecutionStatus LifeCycleRequest An enumeration describing the lifecycle requests regarding a component..LifeCycleStatus The Enum LifeCycleStatus. -
Exception Summary Exception Description CeaseException Thrown in case ceasing a component caused problems.CeaseException.CeaseRuntimeException Unchecked exception with the same semantics as theCeaseException
.ComponentException This exception is the base exception for the component package.ComponentRuntimeException This exception is the base runtime exception for the component package.ConfigureException Thrown in case initializing a component caused problems.DigestException Thrown in case digesting (processing) a job by aDigester.digest(Object)
caused problems; the cause is usually wrapped by thisException
.HandleTimeoutRuntimeException This exception is thrown in case a handle was provided which was unknown to the invoked component.IllegalHandleStateChangeRuntimeException This exception is thrown in case a handle was provided whose reference does not support a given operation.InitializeException Thrown in case initializing a component caused problems.InitializeException.InitializeRuntimeException Unchecked exception with the same semantics as theIOException
.PauseException Thrown in case pausing a component caused problems.PauseException.PauseRuntimeException Unchecked exception with the same semantics as thePauseException
.ResumeException Thrown in case resuming a component caused problems.ResumeException.ResumeRuntimeException Unchecked exception with the same semantics as theResumeException
.StartException Thrown in case starting a component caused problems.StartException.StartRuntimeException Unchecked exception with the same semantics as theStartException
.StopException Thrown in case stopping a component caused problems.StopException.StopRuntimeException Unchecked exception with the same semantics as theStopException
.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.