Realtime (BandM signal & music)

All Superinterfaces:

CompilableControlFlow, Runnable

All Known Implementing Classes:

Apdsr, BooleanClockedSignalSource, ClockedFloatSignalSource, ClockedSignalSource, DataLineSink, DataLineSource, FloatClockedSignalSource, FloatDelay, FloatFFT, FloatLinearOscillator, FloatOscillator, FloatPanorama, FloatPfg, FloatResonator, FloatRingBuffer, FloatSamplePlayer, FloatSeries, FloatSlopeLimiter, FloatSnapshotBuffer, FloatTableOscillator, FloatTwoTablesOscillator, IntClockedSignalSource, KennLine, KennLine.Animation, MidiMessageSource, MidiMessageToSignal, SigSequencer, StreamSink, VariaRun

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 Realtime
extends Runnable, CompilableControlFlow
```
Common interface for objects that react repeatedly to clock events.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_AFAP_INTERRUPT_LATENCY` Default upper bound on the number of events that may be generates by a fast driver before checking the executing thread's interrupt status.
`static long`	`DEFAULT_SLEEP_TIME_MS` Default number of milliseconds to sleep in an event-generating thread that has outrun real time.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static Realtime`	`adHoc(Realtime r)` Helper method that enables lambda notation for instances of this class in any context.
`default Runnable`	`afap()` Creates a driver for this object that generates events as fast as possible.
`default Runnable`	`afap(int interruptLatency)` Creates a driver for this object that generates events as fast as possible.
`default Realtime`	`andThen(Realtime other)` Creates a wrapper that performs, for each event, the reactions of this object and another in sequence.
`default Realtime`	`asAsynchronousSwingEvent()` Creates a wrapper that executes this event asynchronously in the Swing event thread.
`default <V,L> void`	`compileControlFlow(CompilationContext<V,L> context)`
`default Realtime`	`every(int slowdown)` Creates a wrapper that passes only every n-th event to this object, starting with the first event.
`default Realtime`	`every(int slowdown, int initialCountdown)` Creates a wrapper that passes only every n-th event to this object, starting after a given number of initially skipped events.
`default Runnable`	`frequently(float freq)` Creates a driver for this object that generates events with a given asymptotic real-time frequency.
`default Runnable`	`frequently(float freq, long sleepTimeMS)` Creates a driver for this object that generates events with a given asymptotic real-time frequency.
`default Runnable`	`frequently(float freq, long sleepTimeMS, int sleepTimeNS)` Creates a driver for this object that generates events with a given asymptotic real-time frequency.
`void`	`run()` Processes an event.
`static Realtime`	`sequence(Realtime... elems)` Creates a wrapper that performs, for each event, the reactions of an arbitrary number of objects in sequence.
`default Runnable`	`times(long n)`
`default Runnable`	`times(long n, int interruptLatency)`

- Field Detail
  - DEFAULT_SLEEP_TIME_MS
```
static final long DEFAULT_SLEEP_TIME_MS
```
    Default number of milliseconds to sleep in an event-generating thread that has outrun real time.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_AFAP_INTERRUPT_LATENCY
```
static final int DEFAULT_AFAP_INTERRUPT_LATENCY
```
    Default upper bound on the number of events that may be generates by a fast driver before checking the executing thread's interrupt status.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - run
```
void run()
```
    Processes an event.
    Any implementation of this method should complete promptly and normally. In particular it must not block indefinitely.
    
    Specified by:
    
    run in interface Runnable
  - adHoc
```
static Realtime adHoc(Realtime r)
```
    Helper method that enables lambda notation for instances of this class in any context. The parameter is simply returned.
    
    Parameters:
    
    r - the object to return
    
    Returns:
    
    the object
  - andThen
```
default Realtime andThen(Realtime other)
```
    Creates a wrapper that performs, for each event, the reactions of this object and another in sequence.
    
    Parameters:
    
    other - the other object to react to each event after this object.
    
    Returns:
    
    a composite object that performs, for each event, the reactions of this object and another in sequence.
    
    Throws:
    
    IllegalArgumentException - if other == null.
  - sequence
```
static Realtime sequence(Realtime... elems)
```
    Creates a wrapper that performs, for each event, the reactions of an arbitrary number of objects in sequence.
    
    Parameters:
    
    elems - the array of objects to react to each event in sequence.
    
    Returns:
    
    a composite object that performs, for each event, the reactions of an arbitrary number of objects in sequence.
    
    Throws:
    
    IllegalArgumentException - if other == null.
  - every
```
default Realtime every(int slowdown)
```
    Creates a wrapper that passes only every n-th event to this object, starting with the first event.
    
    Parameters:
    
    slowdown - the number of events for the wrapper that result in a single event for the wrapped object.
    
    Returns:
    
    a wrapper that passes only every n-th event to this object, starting with the first event.
    
    Throws:
    
    IllegalArgumentException - if slowdown < 1.
  - every
```
default Realtime every(int slowdown,
                       int initialCountdown)
```
    Creates a wrapper that passes only every n-th event to this object, starting after a given number of initially skipped events.
    
    Parameters:
    
    slowdown - the number of events for the wrapper that result in a single event for the wrapped object.
    
    initialCountdown - the number of events to skip initially. Note that this number may exceed the value of .
    
    Returns:
    
    a wrapper that passes only every n-th event to this object, starting after a given number of initially skipped events.
    
    Throws:
    
    IllegalArgumentException - if slowdown < 1 or initialCountdown < 0.
  - frequently
```
default Runnable frequently(float freq)
```
    Creates a driver for this object that generates events with a given asymptotic real-time frequency.
    This method is a shorthand for frequently(freq, DEFAULT_SLEEP_TIME_MS, 0).
    
    See Also:
    
    frequently(float, long, int), DEFAULT_SLEEP_TIME_MS
  - frequently
```
default Runnable frequently(float freq,
                            long sleepTimeMS)
```
    Creates a driver for this object that generates events with a given asymptotic real-time frequency.
    This method is a shorthand for frequently(freq, sleepTimeMS, 0).
    
    See Also:
    
    frequently(float, long, int)
  - frequently
```
default Runnable frequently(float freq,
                            long sleepTimeMS,
                            int sleepTimeNS)
```
    Creates a driver for this object that generates events with a given asymptotic real-time frequency. Events are generated in bursts. During a burst, events are generated as fast as possible, that is, after the reaction method run() of the wrapped object has completed, it is immediately reinvoked. After each burst, the executing thread sleeps for a given amount of time.
    The number of events in a burst is determined by the amount of real time elapsed since the start of the previous burst, and the specified frequency. Thus the frequency is obeyed asymptotically, and the latency of each individual event is bounded by the given sleep time.
    The driver continues to operate until its executing thread is interrupted; then it completes normally after finishing the current burst, and clears the interrupt status.
    
    Parameters:
    
    freq - the real-time frequency of events.
    
    sleepTimeMS - the number of milliseconds to sleep between bursts.
    
    sleepTimeNS - the number of additional nanoseconds to sleep between bursts.
    
    Returns:
    
    a driver for this object that generates events with a given asymptotic real-time frequency.
    
    Throws:
    
    IllegalArgumentException - if !(freq >= 0) or sleepTimeMS < 0 or sleepTimeNS < 0.
    
    See Also:
    
    Thread.Thread(Runnable)
  - asAsynchronousSwingEvent
```
default Realtime asAsynchronousSwingEvent()
```
    Creates a wrapper that executes this event asynchronously in the Swing event thread.
    
    Returns:
    
    a wrapper that executes this event asynchronously in the Swing event thread.
    
    See Also:
    
    SwingUtilities.invokeLater(java.lang.Runnable)
  - afap
```
default Runnable afap()
```
    Creates a driver for this object that generates events as fast as possible.
    This method is a shorthand for afap(DEFAULT_AFAP_INTERRUPT_LATENCY).
    
    See Also:
    
    afap(int)
  - afap
```
default Runnable afap(int interruptLatency)
```
    Creates a driver for this object that generates events as fast as possible.
    The driver continues to operate until its executing thread is interrupted; then it completes normally after no more than a given number of events, and clears the interrupt status.
    
    Parameters:
    
    interruptLatency - the number of events that may be generated before the interrupt status of the executing thread is checked, or zero to disable interrupt checking altogether.
    
    Throws:
    
    IllegalArgumentException - if interruptLatency < 0.
    
    See Also:
    
    Thread.Thread(Runnable)
  - times
```
default Runnable times(long n)
```
  - times
```
default Runnable times(long n,
                       int interruptLatency)
```
  - compileControlFlow
```
default <V,L> void compileControlFlow(CompilationContext<V,L> context)
```
    Specified by:
    
    compileControlFlow in interface CompilableControlFlow

Interface Realtime

Field Summary

Method Summary

Field Detail

DEFAULT_SLEEP_TIME_MS

DEFAULT_AFAP_INTERRUPT_LATENCY

Method Detail

run

adHoc

andThen

sequence

every

every

frequently

frequently

frequently

asAsynchronousSwingEvent

afap

afap

times

times

compileControlFlow