Timeline/gov.nasa.ammos.aerie.procedural.timeline.collections.profiles/Constants

Constants

data class Constants<V : Any>(timeline: Timeline<Segment<V>, Constants<V>>) : Timeline<Segment<V>, Constants<V>> , SerialConstantOps<V, Constants<V>>

A profile of piece-wise constant values.

Constructors

Link copied to clipboard
constructor(v: V)
constructor(vararg segments: Segment<V>)
constructor(segments: List<Segment<V>>)
constructor(timeline: Timeline<Segment<V>, Constants<V>>)

Types

Link copied to clipboard
object Companion

Functions

Link copied to clipboard
open infix fun assignGaps(v: V): Constants<V>

(DOC) Fills in gaps in this profile with a constant value.

open infix fun assignGaps(other: SerialSegmentOps<V, *>): Constants<V>

(DOC) Fills in gaps in this profile with another profile.

Link copied to clipboard
open override fun cache(): Constants<V>

(DOC) Caches the timeline for all available time.

open override fun cache(opts: CollectOptions): Constants<V>

Caches the result of collecting this timeline, to be reused for future collect requests if possible.

open override fun cache(bounds: Interval): Constants<V>

(DOC) A simplified version of cache.

Link copied to clipboard
open override fun changes(): Booleans

(DOC) Returns a Booleans that is true whenever this profile changes, and false or gap everywhere else.

Link copied to clipboard
open override fun collect(): List<Segment<V>>

(DOC) Collects the timeline for all available time.

open override fun collect(opts: CollectOptions): List<Segment<V>>

(DOC) Evaluates the stack of operations and produces a list of timeline payload objects.

open override fun collect(bounds: Interval): List<Segment<V>>

(DOC) A simplified version of collect.

Link copied to clipboard
open fun <RESULT : GeneralOps<Segment<V>, RESULT>> convert(ctor: (Timeline<Segment<V>, RESULT>) -> RESULT): RESULT

(DOC) Safely converts to another timeline type that accepts the same payload type.

Link copied to clipboard
open fun detectEdges(edgePredicate: NullBinaryOperation<V, V, Boolean?>): Booleans

(DOC) Uses a NullBinaryOperation as a predicate to highlight edges between segments.

Link copied to clipboard
open infix fun equalTo(v: V): Booleans

(DOC) Returns a Booleans that is true when this equals a constant value.

open infix fun equalTo(other: SerialConstantOps<V, *>): Booleans

(DOC) Returns a Booleans that is true when this and another profile are equal.

Link copied to clipboard
open fun filter(preserveMargin: Boolean = false, f: (Segment<V>) -> Boolean): Constants<V>

(DOC) Removes or retains objects based on a predicate.

Link copied to clipboard
open fun filterByDuration(validInterval: Interval): Constants<V>

(DOC) Removes objects whose duration is outside a given valid interval.

Link copied to clipboard
open fun filterByWindows(windows: SerialOps<Interval, *>, truncateMarginal: Boolean = true): Constants<V>

(DOC) Filters out payload objects whose intervals are not contained in the given Windows timeline.

Link copied to clipboard
open fun filterLongerThan(dur: Duration): Constants<V>

(DOC) Removes objects whose duration is shorter than a given duration.

Link copied to clipboard
open fun filterShorterThan(dur: Duration): Constants<V>

(DOC) Removes objects whose duration is longer than a given duration.

Link copied to clipboard
open fun <W : Any> flatMap2OptionalValues(other: SerialSegmentOps<W, *>, op: NullBinaryOperation<V, W, SerialSegmentOps<V, *>?>): Constants<V>

(DOC) Performs a local binary operation that produces profiles, and flattens it into a profile of the same type as this.

open fun <W : Any, R : Any, RESULT : GeneralOps<Segment<R>, RESULT>> flatMap2OptionalValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SerialSegmentOps<W, *>, op: NullBinaryOperation<V, W, SerialSegmentOps<R, *>?>): RESULT

(DOC) Performs a local binary operation that produces profiles, and flattens it, with special treatment of gaps.

Link copied to clipboard
open fun flatMap2Values(other: SegmentOps<V, *>, op: (V, V, Interval) -> SegmentOps<V, *>?): Constants<V>

(DOC) A simpler version of flatMap2Values for operations that don't change the timeline type.

open fun <W : Any, R : Any, RESULT : SegmentOps<R, RESULT>> flatMap2Values(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SegmentOps<W, *>, op: (V, W, Interval) -> SegmentOps<R, *>?): RESULT

(DOC) Performs a local binary operation that produces profiles, and flattens it.

Link copied to clipboard
open fun flatMapValues(f: (Segment<V>) -> SegmentOps<V, *>): Constants<V>

(DOC) A simpler version of flatMapValues for operations that don't change the timeline type.

open fun <R : Any, RESULT : SegmentOps<R, RESULT>> flatMapValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, f: (Segment<V>) -> SegmentOps<R, *>): RESULT

(DOC) Maps segments into a collection of nested timelines and flattens them into their original intervals.

Link copied to clipboard
open fun forEach(p0: Consumer<in Segment<V>>)
Link copied to clipboard
open fun highlight(f: (Segment<V>) -> Boolean): Windows

(DOC) Similar to filter, but produces a coalesced Windows object that highlights everything that satisfies the predicate.

Link copied to clipboard
open fun highlightEqualTo(value: V): Windows

(DOC) Highlights intervals where the value is equal to a specific value.

Link copied to clipboard
open fun inspect(f: Consumer<List<Segment<V>>>): Constants<V>

(DOC) Inserts a no-op function into the operation stack to allow side effects, such as printing.

Link copied to clipboard
open fun isolate(f: (Segment<V>) -> Boolean): Universal<Segment<V>>

(DOC) Similar to filter, but returns an Universal timeline.

Link copied to clipboard
open fun isolateEqualTo(value: V): Universal<Segment<V>>

(DOC) Isolates intervals where the value is equal to a specific value.

Link copied to clipboard
open operator override fun iterator(): Iterator<Segment<V>>
Link copied to clipboard
open fun <W : Any> map2OptionalValues(other: SerialSegmentOps<W, *>, op: NullBinaryOperation<V, W, V?>): Constants<V>

(DOC) Performs a local binary operation between two profiles where the result is the same type as this profile.

open fun <W : Any, R : Any, RESULT : GeneralOps<Segment<R>, RESULT>> map2OptionalValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SerialSegmentOps<W, *>, op: NullBinaryOperation<V, W, R?>): RESULT

(DOC) Performs a local binary operation between two profiles, with special treatment of gaps.

Link copied to clipboard
open fun map2Values(other: SegmentOps<V, *>, op: (V, V, Interval) -> V?): Constants<V>

(DOC) A simplified version of map2Values for operations that don't change the timeline type.

open fun <W : Any, R : Any, RESULT : SegmentOps<R, RESULT>> map2Values(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, other: SegmentOps<W, *>, op: (V, W, Interval) -> R?): RESULT

(DOC) Performs a local binary operation between two segment-valued timelines.

Link copied to clipboard
open fun mapValues(f: (Segment<V>) -> V): Constants<V>

(DOC) Locally transforms the values of a profile without changing the intervals or profile type.

open fun <R : Any, RESULT : SegmentOps<R, RESULT>> mapValues(ctor: (Timeline<Segment<R>, RESULT>) -> RESULT, f: (Segment<V>) -> R): RESULT

(DOC) Locally transforms the values of a profile without changing the intervals.

Link copied to clipboard
open infix fun notEqualTo(v: V): Booleans

(DOC) Returns a Booleans that is true when this is not equal to a constant value.

open infix fun notEqualTo(other: SerialConstantOps<V, *>): Booleans

(DOC) Returns a Booleans that is true when this and another profile are not equal.

Link copied to clipboard
open fun sample(time: Duration): V?

(DOC) Calculates the value of the profile at the given time.

Link copied to clipboard
open fun select(interval: Interval): Constants<V>

(DOC) Restricts the timeline to only be evaluated in the given interval.

Link copied to clipboard
open infix fun set(other: SerialSegmentOps<V, *>): Constants<V>

(DOC) Overwrites this profile with another. Gaps in the argument profile will be filled in with this profile.

Link copied to clipboard
open fun shift(dur: Duration): Constants<V>

(DOC) Uniformly shifts the entire timeline in time (positive shifts toward the future).

Link copied to clipboard
open fun split(f: (Segment<V>) -> Int): Constants<V>

(DOC) Splits payload objects into a variable number of equally sized pieces.

Link copied to clipboard
open fun splitEqualTo(value: V, numPieces: Int): Constants<V>

(DOC) Splits segments where the value is equal to a specific value.

Link copied to clipboard
Link copied to clipboard
open fun transitions(from: V, to: V): Booleans

(DOC) Returns a Booleans that is true when this profile's value changes between two specific values.

Link copied to clipboard
open override fun <RESULT : Timeline<Segment<V>, RESULT>> unsafeCast(ctor: (Timeline<Segment<V>, RESULT>) -> RESULT): RESULT

(DOC) UNSAFE! Casts this timeline type to another type without changing its contents.

Link copied to clipboard
open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeFlatMap(ctor: (Timeline<R, RESULT>) -> RESULT, boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<V>) -> Segment<GeneralOps<R, *>>): RESULT

(DOC) UNSAFE! Maps each object to a nested timeline and flattens all the timelines into one.

Link copied to clipboard
open fun unsafeMap(boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<V>) -> Segment<V>): Constants<V>

(DOC) UNSAFE! A simpler version of unsafeMap for operations that don't change the timeline type.

open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeMap(ctor: (Timeline<R, RESULT>) -> RESULT, boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<V>) -> R): RESULT

(DOC) UNSAFE! Maps each timeline object to another object, of potentially a different type, at potentially a different time.

Link copied to clipboard
open fun <W : IntervalLike<W>, R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeMap2(ctor: (Timeline<R, RESULT>) -> RESULT, other: GeneralOps<W, *>, op: (Segment<V>, W, Interval) -> R?): RESULT

Performs a generalized binary operation between this and another timeline.

Link copied to clipboard
open fun unsafeMapIntervals(boundsTransformer: BoundsTransformer, truncate: Boolean, f: (Segment<V>) -> Interval): Constants<V>

(DOC) UNSAFE! Maps the interval of each object, leaving the rest of the object unchanged.

Link copied to clipboard
open fun unsafeOperate(f: Timeline<Segment<V>, Constants<V>>.(opts: CollectOptions) -> List<Segment<V>>): Constants<V>

(DOC) UNSAFE! A simpler version of unsafeOperate for operations that don't change the timeline type.

open fun <R : IntervalLike<R>, RESULT : GeneralOps<R, RESULT>> unsafeOperate(ctor: (Timeline<R, RESULT>) -> RESULT, f: Timeline<Segment<V>, Constants<V>>.(opts: CollectOptions) -> List<R>): RESULT

(DOC) UNSAFE! The basic, most general operation method. All operations eventually delegate here.

Link copied to clipboard
open fun unset(reject: Interval): Constants<V>

(DOC) Unsets everything in a given interval. Timeline objects whose intervals fully contain the rejected interval may be split into two objects.

Link copied to clipboard
open infix fun zip(other: SerialSegmentOps<V, *>): Constants<V>

Overlays two profiles on each other, asserting that they both cannot be defined at the same time.