Process (BandM signal & music)

All Superinterfaces:

CompilableControlFlow, Component

All Known Subinterfaces:

AbstractClockedSignalSource, BooleanClockedSignalSource, BooleanClockedSignalSourceVector, ClockedSignalSource<A>, ClockedSignalSourceVector<A>, DoubleADSR, DoubleClockedSignalSource, DoubleClockedSignalSourceVector, EnumClockedSignalSource<E>, FloatADSR, FloatClockedSignalSource, FloatClockedSignalSourceVector, IntClockedSignalSource, IntClockedSignalSourceVector, LongClockedSignalSource, LongClockedSignalSourceVector

All Known Implementing Classes:

BooleanDelay, BooleanDelayVector, BooleanMultiDelay, BooleanStoredSignalSource, CompilableBooleanStoredSignalSource, CompilableDoubleStoredSignalSource, CompilableEnumStoredSignalSource, CompilableFloatStoredSignalSource, CompilableIntStoredSignalSource, CompilableLongStoredSignalSource, CompilableStoredSignalSource, Delay, DelayVector, DoubleClockedSignalSource.AbstractRandom, DoubleDelay, DoubleDelayVector, DoubleLinearMap, DoubleMultiDelay, DoubleStoredSignalSource, DoubleUpsamplingSignalSource, DoubleVectorMap, EnumDelay, EnumStoredSignalSource, FloatClockedSignalSource.AbstractRandom, FloatDelay, FloatDelayVector, FloatLinearMap, FloatMultiDelay, FloatStoredSignalSource, FloatUpsamplingSignalSource, FloatVectorMap, IntClockedSignalSource.AbstractRandom, IntDelay, IntDelayVector, IntMultiDelay, IntStoredSignalSource, LongClockedSignalSource.AbstractRandom, LongDelay, LongDelayVector, LongMultiDelay, LongStoredSignalSource, MultiDelay, Process.Proxy, StoredSignalSource

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
```
@FunctionalInterface
public interface Process
extends Component, CompilableControlFlow
```
Interface of computational processes that cause observable state changes at specified events in real or symbolic time.
Successive invocations of step(RealtimeContext) enumerate the sequence of observable states of this process.
Before step(RealtimeContext) may be invoked, init() should be invoked once. The state between the invocations of init() and step(RealtimeContext) should not be observed. At any time between invocations of step(RealtimeContext), init() may be invoked again to reset the process.
Every entity that implements this interface is assumed to have internal state that conceptually represents a clock index:
- The index is set to -1 by invocation of init().
- Every invocation of step(RealtimeContext) increases the clock index by one.
- Specifications that refer to the clock index are only valid for nonnegative values; in particular the behavior between invocations of init() and step(RealtimeContext) is undefined.
The clock index is possibly, but not necessarily, proportional to the amount of model time that has elapsed since initialization. The details are specified by the objects passed to the step(RealtimeContext) method.
State transitions are not assumed to be thread-safe. Invocations of init() and/or step(RealtimeContext) should not occur concurrently or reentrantly.
There is no explicit termination of the lifetime of a process. The process itself is not entitled to terminate on its own initiative. On the client side it suffices to cease invoking step(RealtimeContext).
See Also:

RealtimeComponent

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class Process.Proxy

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Process.Proxy`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default Process`	`afterEvery(int delay, int slowdown, ConstantRealtimeContext rc)`
`default Process`	`andThen(Process other)` Composes the state dynamics of this process sequentially with those of another.
`default Process`	`compile()`
`default void`	`compileAsMainProcess(CompilationContext context)`
`default Consumer<CompilationContext>`	`compileControlFlow()` Compiles the state transition of this process.
`default Consumer<CompilationContext>`	`compileInitialization()` Compiles the initialization of this process.
`default Process`	`every(int slowdown, ConstantRealtimeContext rc)`
`default Process`	`getProcess()` Deprecated.
`default boolean`	`hasControlFlowIO(CompilationContext context)` Checks whether a compilation context has input/output variables set up for the compilation of a `step(RealtimeContext)` method.
`default boolean`	`hasInitializationIO(CompilationContext context)` Checks whether a compilation context has input/output variables set up for the compilation of an initialization.
`default void`	`init()` Initializes the state of this process.
`static Process`	`probe(Object key)`
`static Process`	`sequence(List<? extends Process> elems)` Composes the state dynamics of zero or more processes sequentially.
`static Process`	`sequence(Process... elems)` Composes the state dynamics of zero or more processes sequentially.
`void`	`step(RealtimeContext context)` Signals a time event, executing a transition step for this process to the next observable state.

- Method Detail
  - getProcess
```
@Deprecated
default Process getProcess()
```
    Deprecated.
    
    Description copied from interface: Component
    
    Returns the delegate object that effects changes of observable state.
    
    Specified by:
    
    getProcess in interface Component
  - init
```
default void init()
```
    Initializes the state of this process. The state is initialized such that the first subsequent call to step(RealtimeContext) transitions to the first specified observable state.
    The default implementation does nothing.
  - step
```
void step(RealtimeContext context)
```
    Signals a time event, executing a transition step for this process to the next observable state.
    The state of the process after successful completion of this method should be the n-th observable state, if step(eu.bandm.sig.adlib2.RealtimeContext) has been invoked n times since the last initialization via init(). The behavior of this method is unspecified if init() has not been invoked before.
    If this method completes abruptly by throwing an error or unchecked exception, the process state should be considered invalid.
    
    Parameters:
    
    context - the realtime context information for this step
  - compileInitialization
```
default Consumer<CompilationContext> compileInitialization()
```
    Compiles the initialization of this process.
    This method emits code equivalent to the init() method of this component. The compilation context should be set up to specify no input or output variables.
    The default implementation emits code that simply invokes init() for this process.
    This method should be overridden together with compileControlFlow(), in order to ensure that both operate on the same state variables.
    
    Specified by:
    
    compileInitialization in interface CompilableControlFlow
    
    See Also:
    
    hasInitializationIO(eu.bandm.sig.adlib2.compile.CompilationContext)
  - compileControlFlow
```
default Consumer<CompilationContext> compileControlFlow()
```
    Compiles the state transition of this process.
    This method emits code equivalent to the step(RealtimeContext) method of this process. The compilation context should be set up to specify a single input variable of type RealtimeContext and no output variables.
    The default implementation emits code that simply invokes step(RealtimeContext) for this process.
    This method should be overridden together with compileInitialization(), in order to ensure that both operate on the same state variables.
    
    Specified by:
    
    compileControlFlow in interface CompilableControlFlow
    
    See Also:
    
    hasControlFlowIO(eu.bandm.sig.adlib2.compile.CompilationContext)
  - hasInitializationIO
```
default boolean hasInitializationIO(CompilationContext context)
```
    Checks whether a compilation context has input/output variables set up for the compilation of an initialization.
    
    Parameters:
    
    context - the compilation context to be checked
    This method is suitable for use in an assert statement, to be run at the beginning of the compileInitialization() method.
    
    See Also:
    
    compileInitialization()
  - hasControlFlowIO
```
default boolean hasControlFlowIO(CompilationContext context)
```
    Checks whether a compilation context has input/output variables set up for the compilation of a step(RealtimeContext) method.
    
    Parameters:
    
    context - the compilation context to be checked
    This method is suitable for use in an assert statement, to be run at the beginning of the compileControlFlow() method.
    
    See Also:
    
    compileControlFlow()
  - compileAsMainProcess
```
default void compileAsMainProcess(CompilationContext context)
```
  - andThen
```
default Process andThen(Process other)
```
    Composes the state dynamics of this process sequentially with those of another.
    Sequential composition means that both processes will be initialized and make transitions at each of the incoming time events together, but at each step this process will observe the non-updated state of the other, whereas conversely the other will already observe the updated state of this process.
    
    Parameters:
    
    other - the other process
    
    Returns:
    
    a process that, at initialization or each time event, will execute the state initialization or transition of this process, respectively, followed by the corresponding operation of the other.
  - sequence
```
static Process sequence(Process... elems)
```
    Composes the state dynamics of zero or more processes sequentially.
    Sequential composition means that all processes will be initialized and make transitions at each of the incoming time events together, but at each step each process will observe the non-updated state of processes occurring later in the sequence, whereas conversely it will already observe the updated state of processes occurring earlier in the sequence.
    Behavior is undefined if a process occurs more than once in the sequence.
    
    Parameters:
    
    elems - the array of processes
    
    Returns:
    
    a process that, at initialization or each time event, will execute the state initialization or transition of each process in the sequence in order.
  - sequence
```
static Process sequence(List<? extends Process> elems)
```
    Composes the state dynamics of zero or more processes sequentially.
    Sequential composition means that all processes will be initialized and make transitions at each of the incoming time events together, but at each step each process will observe the non-updated state of processes occurring later in the sequence, whereas conversely it will already observe the updated state of processes occurring earlier in the sequence.
    Behavior is undefined if a process occurs more than once in the sequence.
    
    Parameters:
    
    elems - the list of processes
    
    Returns:
    
    a process that, at initialization or each time event, will execute the state initialization or transition of each process in the sequence in order.
  - probe
```
@Undocumented
static Process probe(Object key)
```
  - every
```
@Undocumented
default Process every(int slowdown,
                                    ConstantRealtimeContext rc)
```
  - afterEvery
```
@Undocumented
default Process afterEvery(int delay,
                                         int slowdown,
                                         ConstantRealtimeContext rc)
```
  - compile
```
@Undocumented
default Process compile()
```

Interface Process

Nested Class Summary

Method Summary

Method Detail

getProcess

init

step

compileInitialization

compileControlFlow

hasInitializationIO

hasControlFlowIO

compileAsMainProcess

andThen

sequence

sequence

probe

every

afterEvery

compile