AbstractConnectableAutomaton
implements the very basic
AbstractConnectableAutomaton
functionality.AbstractDeviceAutomaton
implements the very basic
AbstractDeviceAutomaton
functionality.InputStream
or an OutputStream
.InputStream
or an OutputStream
.InputStream
or an
OutputStream
.BidirectionalConnectionComponent
interface supports a connection.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.BidirectionalConnectionOpenAutomaton
interface defines those
methods related to the opening of connection(s) life-cycle.BidirectionalConnectionOpenableHandle
interface defines those
methods related to the handle based open/connect life-cycle.BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle
interface defines
those methods related to the handle based open/connect life-cycle.Ceasable.CeaseAutomaton
interface defines those methods related to the
cease life-cycle.Ceasable
functionality to be invoked in a builder
chain.Ceasable
without any checked exception being declared.CeasableHandle
interface defines those methods related to the
handle based cease life-cycle.CeasableHandle.CeaseAutomatonHandle
interface defines those methods related
to the handle based cease life-cycle.Ceasable.cease()
without any checked exception being
declared.CeaseException
.Ceasable.cease()
without you to require
catching an CeaseException
.Closable.CloseAutomaton
interface defines those methods related to the
closing of connection(s) life-cycle.Closable
functionality to be invoked in a builder
chain.ClosableHandle
interface defines those methods related to the
handle based close life-cycle.ClosableHandle.CloseAutomatonHandle
interface defines those methods related
to the handle based close life-cycle.Closable.close()
without you to require
catching an IOException
.ClosableHandle.close(Object)
without you to
require catching an IOException
.Component
at least must provide a
Destroyable.destroy()
method.CompositeComponent
interface so that any therein contained
Component
instances' state change methods are supported by the
CompositeComponent
as well and forwarded to the Component
contained in the CompositeComponent
instance.CompositeComponent.ExtendedCompositeComponent
provides extended functionality to
the CompositeComponent
's functionality by including extended
Openable
functionality (ConnectionOpenable
) and extends
Initializable
functionality (Configurable
).CompositeComponent
, the
CompositeComponentHandle
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.CompositeComponentImpl
is an implementation of the
CompositeComponent
.CompositeComponentImpl
containing the provided
components.CompositeComponentImpl
containing the provided
components.CompositeComponentImpl
containing the provided
components.CompositeComponentImpl
containing the provided
components.CompositeComponentImpl.ExtendedCompositeComponentImpl
is an implementation of the
CompositeComponent.ExtendedCompositeComponent
.Configurable.initialize(Object)
.Configurable.ConfigureAutomaton
interface defines those methods related to
the initialize life-cycle with a provided context.Initializable
functionality to be invoked in a
builder chain.ConfigurableComponent
can be configured invoking the method
Configurable.initialize(Object)
.ConfigurableHandle
interface defines those methods related to the
handle based initialize/configure life-cycle.ConfigurableHandle.ConfigureAutomatonHandle
interface defines those methods
related to the handle based initialize/configure life-cycle.ConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton
.LifeCycleComponent.LifeCycleAutomaton
cannot do much more
than decline the various LifeCycleStatus
states for you.LifeCycleStatus
for wrapping it inside
the ConfigurableLifeCycleAutomatonImpl
, making sure of obeying
and guarding the correct LifeCycleStatus
's order of
LifeCycleStatus
states for you.ConfigurableLifeCycleComponent
interface
supports a life-cycle.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
manages various
LifeCycleStatus
states for ConfigurableLifeCycleComponent
instances each related to a handle.ConfigurableLifeCycleComponentHandle.ConfigurableLifeCycleAutomatonHandle
is an automaton managing
various LifeCycleStatus
states for Component
instances
each related to a handle.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
extends the ConnectableComponent
with automaton functionality to get detailed status information regarding
connections.InputStream
or an OutputStream
.InputStream
or an OutputStream
.InputStream
or an
OutputStream
.ConnectionComponent.ConnectionAutomaton
.LifeCycleComponent.LifeCycleAutomaton
cannot do much more
than decline the various LifeCycleStatus
states for you.LifeCycleStatus
for wrapping it inside
the ConnectionAutomatonImpl
, making sure of obeying and guarding
the correct LifeCycleStatus
's order of LifeCycleStatus
states for you.ConnectionComponent
interface supports a
connection.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
with additional according
builder methods.ConnectionComponentHandle
manages various
ConnectionStatus
states for ConnectionComponent
instances
each related to a handle.ConnectionComponentHandle.ConnectionAutomatonHandle
is an automaton managing various
ConnectionStatus
states for ConnectionComponent
instances
each related to a handle.ConnectionOpenable.ConnectionOpenAutomaton
interface defines those methods
related to the opening of connection(s) life-cycle.Startable
functionality to be invoked in a builder
chain.ConnectionOpenableHandle
interface defines those methods related
to the handle based open/connect life-cycle.ConnectionOpenableHandle.ConnectionOpenAutomatonHandle
interface defines those methods
related to the handle based open/connect life-cycle.ConnectionStatus
property.ConnectionStatus
property.ConnectionStatus
property.Component
in case it is
Decomposeable
.Decomposeable
Component
instances found in the provided Collection
.Decomposeable
Component
instances found in the provided Collection
.Decomposeable
Component
instances found in the provided Collection
.Decomposeable
Component
instances found in the provided Collection
.Decomposeable.DecomposeAutomaton
interface defines those methods related to
the decompose life-cycle.DecomposeableHandle
interface defines those methods related to
the handle based decompose life-cycle.DecomposeableHandle.DecomposeAutomatonHandle
interface defines those methods
related to the handle based decompose life-cycle.Component
in case it is
Destroyable
.Component
in order to provide
destroy facilities.Destroyable.DestroyAutomaton
interface defines those methods related to
the destroy life-cycle.DestroyableHandle
interface defines those methods related to the
handle based destroy life-cycle.DestroyableHandle.DestroyAutomatonHandle
interface defines those methods
related to the handle based destroy life-cycle.Digester.digest(Object)
method is invoked in order to trigger
processing of the provided job, e.g. start execution depending on the job
instance being provided from the outside.Digester
provides the functionality to consume a job (which is
pushed from the outside) for further processing.Digester.digest(Object)
caused problems; the cause is usually wrapped
by this Exception
.Digester.digest(Object)
without you to require
catching a DigestException
.DisposableHandle
interface defines those methods related to the
handle based dispose life-cycle.DisposableHandle.DisposeAutomatonHandle
interface defines those methods
related to the handle based dispose life-cycle.Component
in case it is
Disposable.Disposedable
.Disposable.Disposedable
Component
instances found in the provided Collection
.Disposable.Disposedable
Component
instances found in the provided Collection
.Disposable.Disposedable
Component
instances found in the provided Collection
.Disposable.Disposedable
Component
instances found in the provided Collection
.DisposeAutomaton
interface defines those methods related to the
dispose life-cycle.Initializable
Component
instances found in the provided Collection
.FlushHandle
interface defines those methods related to the handle
based flush operation.Flushable.flush()
without you to require
catching a IOException
.FlushHandle.flush(Object)
without you to
require catching a IOException
.Component
instances.ConnectionStatus
property from the property.ConnectionStatus
property from the property.ConnectionStatus
property from the property.ConnectionStatus
property from the property.ConnectionStatus
related to the given handle.ExecutionStrategy
.LifeCycleComponent
instance.LifeCycleComponent
instance.LifeCycleRequest
property from the property.LifeCycleStatus
property from the property.LifeCycleStatus
property from the property.LifeCycleStatus
property from the property.LifeCycleStatus
related to the given handle.String
instances generating
HandleGenerator
basically being a plain good old
UniqueIdGenerator
.BidirectionalConnectionOpenable
by implementing the
BidirectionalConnectionOpenable
interface.ConnectionOpenable.ConnectionOpenAutomaton
interface.Ceasable
interface.Ceasable.CeaseAutomaton
interface.Closable
interface.ConnectionOpenable.ConnectionOpenAutomaton
interface.Configurable
interface.Configurable.ConfigureAutomaton
interface.ConnectionOpenable
by
implementing the ConnectionOpenable
interface.ConnectionOpenable.ConnectionOpenAutomaton
interface.ConnectionStatus
by implementing the
ConnectionStatusAccessor
interface.Decomposeable
interface.Decomposeable.DecomposeAutomaton
interface.Destroyable
interface.Destroyable.DestroyAutomaton
interface.Disposable.Disposedable
interface.DisposeAutomaton
interface.Flushable
interface.Initializable
interface.Initializable.InitializeAutomaton
interface.LifeCycleStatus
by implementing the
LifeCycleStatusAccessor
interface.Openable
interface.ConnectionOpenable.ConnectionOpenAutomaton
interface.Pausable
interface.Pausable.PauseAutomaton
interface.ProgressAccessor
interface.Reloadable
interface.Resetable
interface.Resumable
interface.Resumable.ResumeAutomaton
interface.Startable
interface.Startable.StartAutomaton
interface.Stoppable.StopAutomaton
interface.Stoppable
interface.Initializable.InitializeAutomaton
interface defines those methods related
to the initialize life-cycle.Initializable
functionality to be invoked in a
builder chain.Initializable
without any checked exception being declared.InitializableComponent
can be initialized invoking the method
Initializable.initialize()
.InitializableHandle
interface defines those methods related to
the handle based initialize life-cycle.InitializableHandle.InitializeAutomatonHandle
interface defines those methods
related to the handle based initialize life-cycle.Component
in case it is
Initializable
.Component
in case it is
Configurable
.ConfigureException
Component
instances found in the provided Collection
.Configurable
Component
instances found in the provided Collection
.Initializable
Component
instances found in the provided Collection
.Initializable
Component
instances found in the provided Collection
.ConfigureException
Component
instances found in the provided Collection
.Configurable
Component
instances found in the provided Collection
.Initializable
Component
instances found in the provided Collection
.Initializable
Component
instances found in the provided Collection
.IOException
.Initializable.initialize()
without you to
require catching an InitializeException
.Configurable.initialize(Object)
without
you to require catching an ConfigureException
.InitializableHandle.initialize(Object)
without
you to require catching an InitializeException
.ConfigurableHandle.initialize(Object, Object)
without you to require catching an ConfigureException
.ConnectionOpenable.open(Object)
method.ConnectionOpenable.open(Object)
method.BidirectionalConnectionOpenable.open(Object, Object)
method.ClosedAccessor.ClosedMutator.setClosed(boolean)
and returns the very same value (getter).ConnectionAccessor.ConnectionMutator.setConnection(Object)
and returns the very same value
(getter).ConnectionStatus
(setter) as of ConnectionStatusAccessor.ConnectionStatusMutator.setConnectionStatus(ConnectionStatus)
and
returns the very same value (getter).ContextAccessor.ContextMutator.setContext(Object)
and returns the very same value (getter).HandleAccessor.HandleMutator.setHandle(Object)
and returns the very same value (getter).InitializedAccessor.InitializedMutator.setInitialized(boolean)
and returns the very same value
(getter).BidirectionalConnectionAccessor.BidirectionalConnectionMutator.setInputConnection(Object)
and returns the
very same value (getter).LifeCycleRequest
(setter) as of LifeCycleRequestAccessor.LifeCycleRequestMutator.setLifeCycleRequest(LifeCycleRequest)
and
returns the very same value (getter).LifeCycleStatus
(setter) as of LifeCycleStatusAccessor.LifeCycleStatusMutator.setLifeCycleStatus(LifeCycleStatus)
and
returns the very same value (getter).OpenedAccessor.OpenedMutator.setOpened(boolean)
and returns the very same value (getter).BidirectionalConnectionAccessor.BidirectionalConnectionMutator.setOutputConnection(Object)
and returns the
very same value (getter).ProgressAccessor.ProgressMutator.setProgress(float)
and returns the very same value (getter).RunningAccessor.RunningMutator.setRunning(boolean)
and returns the very same value
(getter).LifeCycleComponent.LifeCycleAutomaton
.LifeCycleComponent.LifeCycleAutomaton
cannot do much more
than decline the various LifeCycleStatus
states for you.LifeCycleStatus
for wrapping it inside
the LifeCycleAutomatonImpl
, making sure of obeying and guarding
the correct LifeCycleStatus
's order of LifeCycleStatus
states for you.LifeCycleAutomatonImpl.ManualLifeCycleAutomatonImpl.setLifeCycleStatus(LifeCycleStatus)
to be public in order to
force any lifecycle status to be set.LifeCycleComponent
interface supports a
life-cycle.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
though without the need to
try-catch any exceptions on the various life-cycle stages.LifeCycleComponentHandle
manages various LifeCycleStatus
states for LifeCycleComponent
instances each related to a handle.LifeCycleComponentHandle.LifeCycleAutomatonHandle
is an automaton managing various
LifeCycleStatus
states for Component
instances each
related to a handle.LifeCycleRequest
property.LifeCycleRequest
property.LifeCycleRequest
property.LifeCycleStatus
property.LifeCycleStatus
property
returning the builder for applying multiple build operations.LifeCycleStatus
property.LifeCycleStatus
property.LifeCycleComponent.LifeCycleAutomaton
.LifeCycleComponent.LifeCycleAutomaton
cannot do much more
than decline the various LifeCycleStatus
states for you.LifeCycleStatus
for wrapping it inside
the LinkAutomatonImpl
, making sure of obeying and guarding the
correct LifeCycleStatus
's order of LifeCycleStatus
states
for you.LinkComponent
interface supports
establishing a connection (not necessarily a network connection).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
with additional according builder
methods.LinkComponentHandle
manages various ConnectionStatus
states for LinkComponent
instances each related to a handle.LinkComponentHandle.LinkAutomatonHandle
is an automaton managing various
ConnectionStatus
states for Component
instances each
related to a handle.LifeCycleAutomatonImpl.ManualLifeCycleAutomatonImpl
cannot
do much more than decline the various LifeCycleStatus
states
for you.LifeCycleAutomatonImpl.ManualLifeCycleAutomatonImpl
for
wrapping it inside the LifeCycleAutomatonImpl
, making sure of
obeying and guarding the correct LifeCycleStatus
's order of
LifeCycleStatus
states for you.Component
in case it is
ConnectionOpenable
.Component
in case it is
BidirectionalConnectionOpenable
.ConfigureException
Component
instances found in the provided Collection
.ConnectionOpenable
Component
instances found in the provided Collection
.ConfigureException
Component
instances found in the provided Collection
.BidirectionalConnectionOpenable
Component
instances found in the provided Collection
.ConfigureException
Component
instances found in the provided Collection
.ConnectionOpenable
Component
instances found in the provided Collection
.ConfigureException
Component
instances found in the provided Collection
.BidirectionalConnectionOpenable
Component
instances found in the provided Collection
.Openable.OpenAutomaton
interface defines those methods related to the
opening of connection(s) life-cycle.Startable
functionality to be invoked in a builder
chain.OpenableHandle
interface defines those methods related to the
handle based open/connect life-cycle.OpenableHandle.OpenAutomatonHandle
interface defines those methods related
to the handle based open/connect life-cycle.Openable.open()
without you to require
catching an IOException
.ConnectionOpenable.open(Object)
without you to
require catching an IOException
.OpenableHandle.open(Object)
without you to
require catching an IOException
.ConnectionOpenableHandle.open(Object, Object)
without you
to require catching an IOException
.Pausable.PauseAutomaton
interface defines those methods related to the
pause life-cycle.Pausable
functionality to be invoked in a builder
chain.Pausable
without any checked exception being declared.PausableHandle
interface defines those methods related to the
handle based pause life-cycle.PausableHandle.PauseAutomatonHandle
interface defines those methods related
to the handle based pause life-cycle.PauseException
.Pausable.PauseBuilder.withPause()
without you to
require catching an PauseException
.Pausable.pause()
without you to require
catching an PauseException
.PausableHandle.pause(Object)
without you to
require catching an PauseException
.ReloadHandle
interface defines those methods related to the
handle based reload operation.Reloadable.reload()
without you to require
catching a IOException
.ReloadHandle.reload(Object)
without you to require catching a IOException
.ResetHandle
interface defines those methods related to the handle
based reset operation.Resumable.ResumeAutomaton
interface defines those methods related to
the resume life-cycle.Resumable
functionality to be invoked in a builder
chain.Resumable
without any checked exception being declared.ResumableHandle
interface defines those methods related to the
handle based resume life-cycle.ResumableHandle.ResumeAutomatonHandle
interface defines those methods related
to the handle based resume life-cycle.ResumeException
.Resumable.resume()
without you to require
catching an ResumeException
.ResumableHandle.resume(Object)
without you to
require catching an ResumeException
.ConnectionStatus
property for the property.ConnectionStatus
property for the property.LifeCycleRequest
property for the property.LifeCycleStatus
to be set with no rules
being applied.LifeCycleStatus
manually.LifeCycleStatus
property for the property.Startable.StartAutomaton
interface defines those methods related to the
start life-cycle.Startable
functionality to be invoked in a builder
chain.Startable
without any checked exception being declared.StartableHandle
interface defines those methods related to the
handle based start life-cycle.StartableHandle.StartAutomatonHandle
interface defines those methods related
to the handle based start life-cycle.StartException
.Startable.start()
without you to require
catching an StartException
.StartableHandle.start(Object)
without you to
require catching an StartException
.StopException
.Stoppable.StopAutomaton
interface defines those methods related to the
stop life-cycle.Stoppable
functionality to be invoked in a builder
chain.Stoppable
without any checked exception being declared.StoppableHandle
interface defines those methods related to the
handle based stop life-cycle.StoppableHandle.StopAutomatonHandle
interface defines those methods related
to the handle based stop life-cycle.Stoppable.stop()
without you to require
catching an StopException
.StoppableHandle.stop(Object)
without you to
require catching an StopException
.Ceasable.cease()
method.Ceasable.CeaseBuilder.withCease()
without you to
require catching an CeaseException
.Closable.close()
method.Closable.closeIn( int )
method.Closable.closeQuietly()
method.Closable.CloseBuilder.withClose()
without you to
require catching an IOException
.Flushable.flush()
.Flushable.FlushBuilder.withFlush()
without you to
require catching a IOException
.Initializable.initialize()
method.Configurable.initialize(Object)
method.Initializable.InitializeBuilder.withInitialize()
without
you to require catching an InitializeException
.Configurable.ConfigureBuilder.withInitialize(Object)
without you to require catching an ConfigureException
.LifeCycleStatus
for the property.Openable.open()
method.ConnectionOpenable.open(Object)
method.Openable.OpenBuilder.withOpen()
without you to
require catching an IOException
.ConnectionOpenable.ConnectionOpenBuilder.withOpen(Object)
without you
to require catching an IOException
.Pausable.pause()
method.Reloadable.reload()
.Reloadable.ReloadBuilder.withReload()
without you to
require catching a IOException
.Resumable.resume()
method.Resumable.ResumeBuilder.withResume()
without you to
require catching an ResumeException
.Startable.start()
method.Startable.StartBuilder.withStart()
without you to
require catching an StartException
.Stoppable.stop()
method.Stoppable.StopBuilder.withStop()
without you to
require catching an StopException
.Copyright © 2021. All rights reserved.