SignalSource (BandM signal & music)

Type Parameters:

A - the type of values produced by this signal source

All Superinterfaces:

AbstractSignalSource, CompilableDataFlow, Supplier<A>

All Known Subinterfaces:

ClockedSignalSource<A>

All Known Implementing Classes:

CompilableStoredSignalSource, Delay, MultiDelay, SignalPort, SignalSourceChooser, SignalSourceChooser.OfEnum, SignalSourceChooser.OfEnumInt, SignalSourceChooser.OfInt, 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 SignalSource<A>
extends AbstractSignalSource, Supplier<A>
```
Interface of a signal (time-dependent value) source of a fixed object type.
This basic interface is neutral with respect to whether values may change at arbitrary times or synchronously with respect to a clock, and to whether values are computed on the fly when demanded, or stored when available and then just retrieved.

See Also:

ClockedSignalSource

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static <A> SignalSource<A>`	`choose(BooleanSignalSource condition, SignalSource<A> inTrue, SignalSource<A> inFalse)` Returns a new signal source whose value is that of either of two given type-compatible signal sources, depending on the current value of a condition signal source.
`static <E extends Enum<E>,A> SignalSource<A>`	`choose(EnumSignalSource<E> selector, EnumMap<E,? extends SignalSource<A>> cases)` Returns a new signal source whose value is selected dynamically from a range of cases indexed by `enum` values.
`static <E extends Enum<E>,A> SignalSource<A>`	`choose(EnumSignalSource<E> selector, SignalSource<A>... cases)` Returns a new signal source whose value is selected dynamically from a range of cases indexed by `enum` values.
`static <E extends Enum<E>,A> SignalSource<A>`	`choose(SignalSource<E> selector, EnumMap<E,? extends SignalSource<A>> cases)` Returns a new signal source whose value is selected dynamically from a range of cases indexed by `enum` values.
`static <A> ClockedSignalSource<A>`	`clock(SignalSource<A> output, Process... processes)`
`default Consumer<CompilationContext>`	`compileDataFlow()` Returns a code generator for outputting the value of this entity.
`default void`	`compileMainSignalSource(CompilationContext context)`
`static <A> SignalSource<A>`	`constant(A value)` Deprecated.
`static <A> SignalSource<A>`	`constant(Class<? super A> valueClass, A value)` Returns a signal source whose value is constant (never changes).
`default ClockedSignalSource<A>`	`delayed(A... initialValues)` Returns a new signal source that mirror the values of this signal source delayed by a given number of clock ticks.
`default ClockedSignalSource<A>`	`delayed(A initialValue)` Returns a new signal source that mirrors the values of this signal source delayed by one clock tick.
`static <A> ClockedSignalSource<A>`	`delayedFeedback(Function<? super ClockedSignalSource<A>,? extends SignalSource<A>> loop, Class<? super A> valueClass, A... initialValues)`
`static <A> ClockedSignalSource<A>`	`delayedFeedback(Function<? super ClockedSignalSource<A>,? extends SignalSource<A>> loop, Class<? super A> valueClass, A initialValue)` Returns a new signal source that receives its own delayed output as input.
`default BooleanSignalSource`	`eq(SignalSource<A> other)` Returns a new signal source whose value is `true` iff the value of this signal source is identically equal to the simultaneous value of another signal source.
`A`	`get()` Returns the current value of this signal source.
`default Optional<A>`	`getConstant()` Returns the constant value of this signal source, if applicable.
`default Class<? super A>`	`getValueClass()` Returns the type of values produced by this entity.
`default BooleanSignalSource`	`guard(Predicate<? super A> pred)` Returns a boolean signal source whose values are derived from the values of this signal source by applying a unary predicate.
`default boolean`	`hasConstant()` Checks whether this signal source has a constant value.
`default ClockedSignalSource<A>`	`invariant()`
`default <B> SignalSource<B>`	`map(Function<? super A,? extends B> op, Class<B> valueClass)` Returns a signal source whose values are derived from the values of this signal source by applying a unary function.
`default SignalSource<A>`	`map(UnaryOperator<A> op)` Returns a signal source whose values are derived from the values of this signal source by applying a unary function.
`default BooleanSignalSource`	`neq(SignalSource<A> other)` Returns a new signal source whose value is `true` iff the value of this signal source is not identically equal to the simultaneous value of another signal source.
`default ClockedSignalSource<A>`	`power(BinaryOperator<SignalSource<A>> op, long n)`
`default Process`	`probe(Object key)` Returns a realtime event that, when fired, notifies the concerned observer of the current value of this signal source.
`default void`	`publishStoredValueVariable(CompilationContext context)`
`default BooleanSignalSource`	`relateWith(BiPredicate<A,A> pred, SignalSource<A> other)` Returns a boolean signal source whose values are derived from the simultaneous values of this and another signal source by applying a binary predicate.
`default ClockedSignalSource`	`sampleAndHold(BooleanSignalSource hold, A initialValue)` Returns a new clocked signal source whose value at each clock tick is either the current value of this signal source (sample mode), or its own value at the previous clock tick (hold mode), depending on the current value of a given boolean signal source.
`default ClockedSignalSource<A>`	`stored()` Returns a new signal source that stores snapshot values of this signal source driven by a clock.
`default SignalSource<A>`	`zipWith(BinaryOperator<A> op, SignalSource<A> other)` Returns a signal source whose values are derived from the simultaneous values of this and another signal source by applying a binary function.

Methods inherited from interface eu.bandm.sig.adlib2.compile.CompilableDataFlow
compileDataFlowTo, hasDataFlowIO

- Method Detail
  - get
```
A get()
```
    Returns the current value of this signal source.
    The value may be either computed on demand, or retrieved from storage.
    Implementations of this method should have no side effect.
    
    Specified by:
    
    get in interface Supplier<A>
    
    Returns:
    
    the current value of this signal source
  - getValueClass
```
default Class<? super A> getValueClass()
```
    Returns the type of values produced by this entity.
    For signals of primitive value type, the result will be the corresponding pseudoclass.
    This implementation returns Object.class. Subclasses may override this method to provide more specific type information.
    
    Specified by:
    
    getValueClass in interface CompilableDataFlow
    
    Returns:
    
    the type of signal values that this entity produces
    
    See Also:
    
    Class.isPrimitive()
  - getConstant
```
default Optional<A> getConstant()
```
    Returns the constant value of this signal source, if applicable.
    
    Returns:
    
    an Optional containing the value of this signal source if it is constant, or Optional.empty() otherwise.
  - hasConstant
```
default boolean hasConstant()
```
    Checks whether this signal source has a constant value.
    
    Returns:
    
    true iff the value of this signal source does not change over time
  - compileDataFlow
```
default Consumer<CompilationContext> compileDataFlow()
```
    Returns a code generator for outputting the value of this entity.
    This implementation generates code to invoke this.get().
    
    Specified by:
    
    compileDataFlow in interface CompilableDataFlow
  - constant
```
static <A> SignalSource<A> constant(Class<? super A> valueClass,
                                    A value)
```
    Returns a signal source whose value is constant (never changes).
    
    Parameters:
    
    valueClass - the type of the value produced by the new signal source
    
    value - the value of the new signal source
    
    Returns:
    
    a signal source that always has the given value
    
    Throws:
    
    NullPointerException - if value == null
  - constant
```
@Deprecated
static <A> SignalSource<A> constant(A value)
```
    Deprecated.
  - map
```
default SignalSource<A> map(UnaryOperator<A> op)
```
    Returns a signal source whose values are derived from the values of this signal source by applying a unary function.
    The implementation yields a signal source that computes the derived value by applying the given function every time its get() method is invoked. If the computation is costly and the value reused often, it may be convenient to compute and store the value proactively driven by a clock.
    
    Parameters:
    
    op - the function to apply to each value
    
    See Also:
    
    stored()
  - map
```
default <B> SignalSource<B> map(Function<? super A,? extends B> op,
                                Class<B> valueClass)
```
    Returns a signal source whose values are derived from the values of this signal source by applying a unary function.
    The implementation yields a signal source that computes the derived value by applying the given function every time its get() method is invoked. If the computation is costly and the value reused often, it may be convenient to compute and store the value proactively driven by a clock.
    
    Parameters:
    
    op - the function to apply to each value
    
    valueClass - the type of the value produced by the new signal source
    
    See Also:
    
    stored()
  - zipWith
```
default SignalSource<A> zipWith(BinaryOperator<A> op,
                                SignalSource<A> other)
```
    Returns a signal source whose values are derived from the simultaneous values of this and another signal source by applying a binary function.
    The implementation yields a signal source that computes the derived value by applying the given function every time its get() method is invoked. If the computation is costly and the value reused often, it may be convenient to compute the value proactively driven by a clock.
    
    Parameters:
    
    op - the function to apply to each pair of values
    
    other - the other signal source to consider
    
    See Also:
    
    stored()
  - guard
```
default BooleanSignalSource guard(Predicate<? super A> pred)
```
    Returns a boolean signal source whose values are derived from the values of this signal source by applying a unary predicate.
    The implementation yields a signal source that computes the derived value by applying the given predicate every time its get() method is invoked. If the computation is costly and the value reused often, it may be convenient to compute the value proactively driven by a clock.
    
    Parameters:
    
    pred - the predicate to apply to each value
    
    See Also:
    
    stored()
  - relateWith
```
default BooleanSignalSource relateWith(BiPredicate<A,A> pred,
                                       SignalSource<A> other)
```
    Returns a boolean signal source whose values are derived from the simultaneous values of this and another signal source by applying a binary predicate.
    The implementation yields a signal source that computes the derived value by applying the given predicate every time its get() method is invoked. If the computation is costly and the value reused often, it may be convenient to compute the value proactively driven by a clock.
    
    Parameters:
    
    pred - the predicate to apply to each value
    
    other - the other signal source to consider
    
    See Also:
    
    stored()
  - clock
```
@Undocumented
static <A> ClockedSignalSource<A> clock(SignalSource<A> output,
                                                      Process... processes)
```
  - invariant
```
@Undocumented
default ClockedSignalSource<A> invariant()
```
  - stored
```
default ClockedSignalSource<A> stored()
```
    Returns a new signal source that stores snapshot values of this signal source driven by a clock.
    The get() method of the returned signal source is guaranteed to be extremely fast, both in interpreted and compiled mode. The computational effort of the underlying signal source is instead spent on the Process.step(RealtimeContext) method of the returned signal source, to be invoked at each clock tick.
    If the underlying signal source is constant, the value is forwarded when the Process.init() method of the returned signal source is invoked, where as its implementation of Process.step(RealtimeContext) does nothing.
    
    Returns:
    
    a new signal source that takes value snapshots of this signal source.
  - delayed
```
default ClockedSignalSource<A> delayed(A initialValue)
```
    Returns a new signal source that mirrors the values of this signal source delayed by one clock tick.
    
    Parameters:
    
    initialValue - the initial value to output for the first clock tick
  - delayed
```
default ClockedSignalSource<A> delayed(A... initialValues)
```
    Returns a new signal source that mirror the values of this signal source delayed by a given number of clock ticks.
    The length of the delay in clock ticks is specified implicitly by the number of initial values.
    
    Parameters:
    
    initialValues - the initial values to output for the first clock ticks
  - delayedFeedback
```
static <A> ClockedSignalSource<A> delayedFeedback(Function<? super ClockedSignalSource<A>,? extends SignalSource<A>> loop,
                                                  Class<? super A> valueClass,
                                                  A initialValue)
```
    Returns a new signal source that receives its own delayed output as input.
    The circular data flow is constructed by specifying a function that receives as its argument a delayed signal source that will be fed back from the source that it returns. The passed function is applied exactly once.
    The output signal source is used both internally for the delayed feedback, and possibly externally by a consumer. Hence its value is stored implicitly in an intermediate variable in order to avoid duplicate computations.
    
    Parameters:
    
    loop - the function that creates the output signal source, given its delayed feedback
    
    valueClass - the type of the value produced by the new signal source
    
    initialValue - the initial value of the delayed feedback
  - delayedFeedback
```
@SafeVarargs
static <A> ClockedSignalSource<A> delayedFeedback(Function<? super ClockedSignalSource<A>,? extends SignalSource<A>> loop,
                                                               Class<? super A> valueClass,
                                                               A... initialValues)
```
  - probe
```
default Process probe(Object key)
```
    Returns a realtime event that, when fired, notifies the concerned observer of the current value of this signal source.
    
    Parameters:
    
    key - the key to associate the value of this signal source with
    
    See Also:
    
    RealtimeContext.getSignalProbe()
  - choose
```
static <A> SignalSource<A> choose(BooleanSignalSource condition,
                                  SignalSource<A> inTrue,
                                  SignalSource<A> inFalse)
```
    Returns a new signal source whose value is that of either of two given type-compatible signal sources, depending on the current value of a condition signal source.
    At any point in time, choose(condition, x, y).getAsInt() == (this.get() ? x : y).getAsInt() holds.
    
    Parameters:
    
    condition - the condition signal source
    
    inTrue - the signal source to consider when the value of the condition signal source is true
    
    inFalse - the signal source to consider when the value of the condition signal source is false
  - choose
```
static <E extends Enum<E>,A> SignalSource<A> choose(SignalSource<E> selector,
                                                    EnumMap<E,? extends SignalSource<A>> cases)
```
    Returns a new signal source whose value is selected dynamically from a range of cases indexed by enum values.
    At any point in time, choose(s, m).get() == m.get(s.get()).get() holds.
    The given map cases is assumed to be immutable and to contain an entry for every possible value of the enum type E.
    
    Type Parameters:
    
    E - the type of enum values
    
    A - the type of values produced by this signal source
    
    Parameters:
    
    selector - the signal source that provides the enum value
    
    cases - a map of enum values to signal sources to select from
  - choose
```
static <E extends Enum<E>,A> SignalSource<A> choose(EnumSignalSource<E> selector,
                                                    EnumMap<E,? extends SignalSource<A>> cases)
```
    Returns a new signal source whose value is selected dynamically from a range of cases indexed by enum values.
    At any point in time, choose(s, m).get() == m.get(E.values()[s.getAsInt()]).get() holds.
    The given map cases is assumed to be immutable and to contain an entry for every possible value of the enum type E.
    
    Type Parameters:
    
    E - the type of enum values
    
    A - the type of values produced by this signal source
    
    Parameters:
    
    selector - the signal source that provides the ordinal number of the enum value
    
    cases - a map of enum values to signal sources to select from
  - choose
```
@SafeVarargs
static <E extends Enum<E>,A> SignalSource<A> choose(EnumSignalSource<E> selector,
                                                                 SignalSource<A>... cases)
```
    Returns a new signal source whose value is selected dynamically from a range of cases indexed by enum values.
    At any point in time, choose(s, a).get() == m[s.getAsInt()].get() holds.
    The given array cases is assumed to be immutable and to contain an element for every possible value of the enum type E.
    
    Type Parameters:
    
    E - the type of enum values
    
    A - the type of values produced by this signal source
    
    Parameters:
    
    selector - the signal source that provides the enum value
    
    cases - an array signal sources to select from, in the definition order of enum elements
  - eq
```
default BooleanSignalSource eq(SignalSource<A> other)
```
    Returns a new signal source whose value is true iff the value of this signal source is identically equal to the simultaneous value of another signal source.
    At any point in time, this.lessThan(other).getAsBoolean() == this.get() == other.get() holds.
    
    Parameters:
    
    other - the other signal source to consider
  - neq
```
default BooleanSignalSource neq(SignalSource<A> other)
```
    Returns a new signal source whose value is true iff the value of this signal source is not identically equal to the simultaneous value of another signal source.
    At any point in time, this.lessThan(other).getAsBoolean() == this.get() != other.get() holds.
    
    Parameters:
    
    other - the other signal source to consider
  - sampleAndHold
```
default ClockedSignalSource sampleAndHold(BooleanSignalSource hold,
                                          A initialValue)
```
    Returns a new clocked signal source whose value at each clock tick is either the current value of this signal source (sample mode), or its own value at the previous clock tick (hold mode), depending on the current value of a given boolean signal source.
    
    Parameters:
    
    hold - a boolean signal source that, at each clock tick, selects hold mode if its value ist true, or sample mode if its value is false
    
    initialValue - the initial value to use if in hold mode at the first clock tick
  - power
```
@Undocumented
default ClockedSignalSource<A> power(BinaryOperator<SignalSource<A>> op,
                                                   long n)
```
  - compileMainSignalSource
```
@Undocumented
default void compileMainSignalSource(CompilationContext context)
```
  - publishStoredValueVariable
```
@Undocumented
default void publishStoredValueVariable(CompilationContext context)
```

Interface SignalSource<A>

Method Summary

Methods inherited from interface eu.bandm.sig.adlib2.compile.CompilableDataFlow

Method Detail

get

getValueClass

getConstant

hasConstant

compileDataFlow

constant

constant

map

map

zipWith

guard

relateWith

clock

invariant

stored

delayed

delayed

delayedFeedback

delayedFeedback

probe

choose

choose

choose

choose

eq

neq

sampleAndHold

power

compileMainSignalSource

publishStoredValueVariable