Interface | Description |
---|---|
Component |
Per definition any
Component at least must provide a
Destroyable.destroy() method. |
CompositeComponent |
Any composite implementation of the refcodes frameworks should implement this
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<CTX,CON> |
The
CompositeComponent.ExtendedCompositeComponent provides extended functionality to
the CompositeComponent 's functionality by including extended
Openable functionality (ConnectionOpenable ) and extends
Initializeable functionality (Configurable ). |
CompositeComponentHandle<H,REF> |
Similar to the
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. |
ConfigurableComponent<CTX> |
A
ConfigurableComponent can be configured invoking the method
Configurable.initialize(Object) . |
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. |
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. |
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. |
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. |
DeviceComponent |
A component implementing the
DeviceComponent interface supports a
connecting. |
DeviceComponent.DeviceAutomaton |
A system implementing the
DeviceComponent.DeviceAutomaton interface supports
managing DeviceComponent 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. |
DeviceComponentHandle<H> |
The
DeviceComponentHandle manages various ConnectionStatus
states for DeviceComponent instances each related to a handle. |
DeviceComponentHandle.DeviceAutomatonHandle<H> |
The
DeviceComponentHandle.DeviceAutomatonHandle is an automaton managing various
ConnectionStatus states for Component instances each
related to a handle. |
DigesterComponent<J> | |
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.
|
InitializeableComponent |
A
InitializeableComponent can be initialized invoking the method
Initializeable.initialize() . |
InputOutputComponent<INPUT,OUTPUT> |
A component implementing the
InputOutputComponent interface supports
a connection. |
InputOutputComponent.InputOutputAutomaton<INPUT,OUTPUT> |
A system implementing the
InputOutputComponent.InputOutputAutomaton interface supports
managing InputOutputComponent 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. |
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. |
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. |
Copyright © 2015. All rights reserved.