Module swim.streamlet

Package swim.streamlet

Class AbstractStreamlet<I,O>

java.lang.Object

swim.streamlet.AbstractStreamlet<I,O>

All Implemented Interfaces:

GenericStreamlet<I,O>, Streamlet<I,O>, StreamletScope<O>

public abstract class AbstractStreamlet<I,O>
extends Object
implements GenericStreamlet<I,O>

Field Summary

Fields

Modifier and Type	Field	Description
protected StreamletContext	context
protected StreamletScope<? extends O>	scope
protected int	version

Constructor Summary

Constructors

Constructor	Description
AbstractStreamlet()
AbstractStreamlet(StreamletScope<? extends O> scope)

Method Summary

Modifier and Type	Method	Description
void	bindInput(String key, Outlet<? extends I> input)	Connects the Inlet of this Streamlet, identified by the given key, to the input from which the Inlet should acquire its state.
protected void	didInvalidate()
void	didInvalidateInlet(Inlet<? extends I> inlet)
void	didInvalidateOutlet(Outlet<? super O> outlet)
protected void	didReconcile(int version)
void	didReconcileInlet(Inlet<? extends I> inlet, int version)
void	didReconcileOutlet(Outlet<? super O> outlet, int version)
void	disconnectInputs()	Disconnects all Inlets dominated by this Streamlet in the dataflow dependency graph.
static <I,O> void	disconnectInputs(Streamlet<I,O> streamlet, Class<?> streamletClass)
void	disconnectOutputs()	Disconnects all Inletss dominated by this Streamlet in the dataflow graph.
static <I,O> void	disconnectOutputs(Streamlet<I,O> streamlet, Class<?> streamletClass)
<I2 extends I> I2	getInput(String key)
<I2 extends I> I2	getInput(String key, I2 orElse)
<I2 extends I> I2	getInput(Inlet<I2> inlet)
<I2 extends I> I2	getInput(Inlet<I2> inlet, I2 orElse)
O	getOutput(String key)
O	getOutput(Outlet<? super O> outlet)
protected <I2 extends I> Inlet<I2>	inlet()
Inlet<I>	inlet(String key)	Returns the Inlet to this Streamlet identified by the given key; returns null if this Streamlet has no such Inlet.
protected <I2 extends I,O2> Inoutlet<I2,O2>	inoutlet()
void	invalidate()	Marks this Streamlet—and all of its outlets—as having stale state.
static <I,O> void	invalidateOutlets(Streamlet<I,O> streamlet, Class<?> streamletClass)
protected void	onInvalidate()
protected void	onInvalidateOutlets()
protected void	onReconcile(int version)
protected void	onReconcileInlets(int version)
protected void	onReconcileOutlets(int version)
protected <O2> Outlet<O2>	outlet()
Outlet<O>	outlet(String key)	Returns the Outlet of this Streamlet identified by the given key; returns null if this Streamlet has no such Outlet.
void	reconcile(int version)	Reconciles the state of this Streamlet, if the version of this Streamlet's state differs from the target version.
static <I,O> void	reconcileInlets(int version, Streamlet<I,O> streamlet, Class<?> streamletClass)
static <I,O> void	reconcileOutlets(int version, Streamlet<I,O> streamlet, Class<?> streamletClass)
static <I,O> int	reflectInletCount(Class<?> streamletClass)
static <I,O> Inlet<I>	reflectInletField(Streamlet<I,O> streamlet, Field field)
static <I,O> Map.Entry<String,Inlet<I>>	reflectInletIndex(int index, Streamlet<I,O> streamlet, Class<?> streamletClass)
static <I,O> Inlet<I>	reflectInletKey(String key, Streamlet<I,O> streamlet, Class<?> streamletClass)
static <I,O> Inoutlet<I,O>	reflectInoutletField(Streamlet<I,O> streamlet, Field field)
static <I,O> int	reflectOutletCount(Class<?> streamletClass)
static <I,O> Outlet<O>	reflectOutletField(Streamlet<I,O> streamlet, Field field)
static <I,O> Map.Entry<String,Outlet<O>>	reflectOutletIndex(int index, Streamlet<I,O> streamlet, Class<?> streamletClass)
static <I,O> Outlet<O>	reflectOutletKey(String key, Streamlet<I,O> streamlet, Class<?> streamletClass)
void	setStreamletContext(StreamletContext context)	Sets the environment in which this Streamlet operates.
void	setStreamletScope(StreamletScope<? extends O> scope)	Sets the lexically scoped parent of this Streamlet.
StreamletContext	streamletContext()	Returns the environment in which this Streamlet operates.
StreamletScope<? extends O>	streamletScope()	Returns the lexically scoped parent of this Streamlet.
void	unbindInput(String key)	Disconnects the Inlet of this Streamlet, identified by the given key, from its input Outlet, if connected.
protected void	willInvalidate()
void	willInvalidateInlet(Inlet<? extends I> inlet)
void	willInvalidateOutlet(Outlet<? super O> outlet)
protected void	willReconcile(int version)
void	willReconcileInlet(Inlet<? extends I> inlet, int version)
void	willReconcileOutlet(Outlet<? super O> outlet, int version)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

scope

protected StreamletScope<? extends O> scope

context

protected StreamletContext context

version

protected int version

Constructor Detail

AbstractStreamlet

public AbstractStreamlet(StreamletScope<? extends O> scope)

AbstractStreamlet

public AbstractStreamlet()

Method Detail

streamletScope

public StreamletScope<? extends O> streamletScope()

Description copied from interface: Streamlet

Returns the lexically scoped parent of this Streamlet. Returns null if this Streamlet has no lexical parent.

Specified by:

streamletScope in interface Streamlet<I,O>

Specified by:

streamletScope in interface StreamletScope<I>

setStreamletScope

public void setStreamletScope(StreamletScope<? extends O> scope)

Description copied from interface: Streamlet

Sets the lexically scoped parent of this Streamlet.

Specified by:

setStreamletScope in interface Streamlet<I,O>

streamletContext

public StreamletContext streamletContext()

Description copied from interface: Streamlet

Returns the environment in which this Streamlet operates.

Specified by:

streamletContext in interface Streamlet<I,O>

Specified by:

streamletContext in interface StreamletScope<I>

setStreamletContext

public void setStreamletContext(StreamletContext context)

Description copied from interface: Streamlet

Sets the environment in which this Streamlet operates.

Specified by:

setStreamletContext in interface Streamlet<I,O>

inlet

public Inlet<I> inlet(String key)

Description copied from interface: Streamlet

Returns the Inlet to this Streamlet identified by the given key; returns null if this Streamlet has no such Inlet.

Specified by:

inlet in interface Streamlet<I,O>

inlet

protected <I2 extends I> Inlet<I2> inlet()

bindInput

public void bindInput(String key,
                      Outlet<? extends I> input)

Description copied from interface: Streamlet

Connects the Inlet of this Streamlet, identified by the given key, to the input from which the Inlet should acquire its state. Delegates to Inlet.bindInput(Outlet) on the identified Inlet.

Specified by:

bindInput in interface Streamlet<I,O>

unbindInput

public void unbindInput(String key)

Description copied from interface: Streamlet

Disconnects the Inlet of this Streamlet, identified by the given key, from its input Outlet, if connected. Delegates to Inlet.unbindInput() on the identified Inlet.

Specified by:

unbindInput in interface Streamlet<I,O>

outlet

public Outlet<O> outlet(String key)

Description copied from interface: Streamlet

Returns the Outlet of this Streamlet identified by the given key; returns null if this Streamlet has no such Outlet.

Specified by:

outlet in interface Streamlet<I,O>

Specified by:

outlet in interface StreamletScope<I>

outlet

protected <O2> Outlet<O2> outlet()

inoutlet

protected <I2 extends I,O2> Inoutlet<I2,O2> inoutlet()

invalidate

public void invalidate()

Description copied from interface: Streamlet

Marks this Streamlet—and all of its outlets—as having stale state. Invalidating a Streamlet will recursively invalidate all streamlets that transitively depend on the state of this Streamlet. Invalidating a Streamlet does not cause its state to be recomputed. A subsequent Streamlet.reconcile(int) call will reconcile the state of the Streamlet.

Specified by:

invalidate in interface Streamlet<I,O>

reconcile

public void reconcile(int version)

Description copied from interface: Streamlet

Reconciles the state of this Streamlet, if the version of this Streamlet's state differs from the target version. To reconcile its state, the Streamlet first invokes Inlet.reconcileOutput(int) on each of its inlets, to ensure that its input states are up-to-date. It then recomputes its own state, in an implementation defined manner. Finally, it invokes Outlet.reconcileInput(int) on its outlets, causing all transitively dependent streamlets to reconcile their own state.

Specified by:

reconcile in interface Streamlet<I,O>

getInput

public <I2 extends I> I2 getInput(Inlet<I2> inlet)

getInput

public <I2 extends I> I2 getInput(String key)

getInput

public <I2 extends I> I2 getInput(Inlet<I2> inlet,
                                  I2 orElse)

getInput

public <I2 extends I> I2 getInput(String key,
                                  I2 orElse)

getOutput

public O getOutput(Outlet<? super O> outlet)

Specified by:

getOutput in interface GenericStreamlet<I,O>

getOutput

public O getOutput(String key)

disconnectInputs

public void disconnectInputs()

Description copied from interface: Streamlet

Disconnects all Inlets dominated by this Streamlet in the dataflow dependency graph. Used to recursively clean up chains of combinators terminating at this Streamlet.

Specified by:

disconnectInputs in interface Streamlet<I,O>

disconnectInputs

public static <I,O> void disconnectInputs(Streamlet<I,O> streamlet,
                                                Class<?> streamletClass)

disconnectOutputs

public void disconnectOutputs()

Description copied from interface: Streamlet

Disconnects all Inletss dominated by this Streamlet in the dataflow graph. Used to recursively clean up chains of combinators originating from this Streamlet.

Specified by:

disconnectOutputs in interface Streamlet<I,O>

disconnectOutputs

public static <I,O> void disconnectOutputs(Streamlet<I,O> streamlet,
                                                 Class<?> streamletClass)

willInvalidateInlet

public void willInvalidateInlet(Inlet<? extends I> inlet)

Specified by:

willInvalidateInlet in interface GenericStreamlet<I,O>

didInvalidateInlet

public void didInvalidateInlet(Inlet<? extends I> inlet)

Specified by:

didInvalidateInlet in interface GenericStreamlet<I,O>

willReconcileInlet

public void willReconcileInlet(Inlet<? extends I> inlet,
                               int version)

Specified by:

willReconcileInlet in interface GenericStreamlet<I,O>

didReconcileInlet

public void didReconcileInlet(Inlet<? extends I> inlet,
                              int version)

Specified by:

didReconcileInlet in interface GenericStreamlet<I,O>

willInvalidateOutlet

public void willInvalidateOutlet(Outlet<? super O> outlet)

Specified by:

willInvalidateOutlet in interface GenericStreamlet<I,O>

didInvalidateOutlet

public void didInvalidateOutlet(Outlet<? super O> outlet)

Specified by:

didInvalidateOutlet in interface GenericStreamlet<I,O>

willReconcileOutlet

public void willReconcileOutlet(Outlet<? super O> outlet,
                                int version)

Specified by:

willReconcileOutlet in interface GenericStreamlet<I,O>

didReconcileOutlet

public void didReconcileOutlet(Outlet<? super O> outlet,
                               int version)

Specified by:

didReconcileOutlet in interface GenericStreamlet<I,O>

willInvalidate

protected void willInvalidate()

onInvalidate

protected void onInvalidate()

onInvalidateOutlets

protected void onInvalidateOutlets()

invalidateOutlets

public static <I,O> void invalidateOutlets(Streamlet<I,O> streamlet,
                                                 Class<?> streamletClass)

didInvalidate

protected void didInvalidate()

willReconcile

protected void willReconcile(int version)

onReconcileInlets

protected void onReconcileInlets(int version)

reconcileInlets

public static <I,O> void reconcileInlets(int version,
                                               Streamlet<I,O> streamlet,
                                               Class<?> streamletClass)

onReconcile

protected void onReconcile(int version)

onReconcileOutlets

protected void onReconcileOutlets(int version)

reconcileOutlets

public static <I,O> void reconcileOutlets(int version,
                                                Streamlet<I,O> streamlet,
                                                Class<?> streamletClass)

didReconcile

protected void didReconcile(int version)

reflectInletCount

public static <I,O> int reflectInletCount(Class<?> streamletClass)

reflectOutletCount

public static <I,O> int reflectOutletCount(Class<?> streamletClass)

reflectInletIndex

public static <I,O> Map.Entry<String,Inlet<I>> reflectInletIndex(int index,
                                                                             Streamlet<I,O> streamlet,
                                                                             Class<?> streamletClass)

reflectOutletIndex

public static <I,O> Map.Entry<String,Outlet<O>> reflectOutletIndex(int index,
                                                                               Streamlet<I,O> streamlet,
                                                                               Class<?> streamletClass)

reflectInletKey

public static <I,O> Inlet<I> reflectInletKey(String key,
                                                   Streamlet<I,O> streamlet,
                                                   Class<?> streamletClass)

reflectOutletKey

public static <I,O> Outlet<O> reflectOutletKey(String key,
                                                     Streamlet<I,O> streamlet,
                                                     Class<?> streamletClass)

reflectInletField

public static <I,O> Inlet<I> reflectInletField(Streamlet<I,O> streamlet,
                                                     Field field)

reflectOutletField

public static <I,O> Outlet<O> reflectOutletField(Streamlet<I,O> streamlet,
                                                       Field field)

reflectInoutletField

public static <I,O> Inoutlet<I,O> reflectInoutletField(Streamlet<I,O> streamlet,
                                                                   Field field)