/// <summary>
/// Computes a time-sensitive top-k aggregate using snapshot semantics based on a key selector with the provided ordering comparer.
/// </summary>
public IAggregate <TSource, SortedMultiSet <TSource>, List <RankedEvent <TSource> > > TopK <TOrderValue>(Expression <Func <TSource, TOrderValue> > orderer, IComparerExpression <TOrderValue> comparer, int k)
{
Invariant.IsNotNull(orderer, nameof(orderer));
Invariant.IsNotNull(comparer, nameof(comparer));
Invariant.IsPositive(k, nameof(k));
var orderComparer = comparer.TransformInput(orderer);
var aggregate = new TopKAggregate <TSource>(k, orderComparer, this.Properties.QueryContainer);
return(aggregate.SkipNulls().ApplyFilter(this.Filter));
}
/// <summary>
/// Passes a truncated version of each event, where the event is truncated by a maximum event length.
/// </summary>
public static IStreamable <TKey, TPayload> ClipEventDuration <TKey, TPayload>(
this IStreamable <TKey, TPayload> source,
long limit)
{
Invariant.IsNotNull(source, nameof(source));
Invariant.IsPositive(limit, nameof(limit));
return(source.Properties.IsConstantDuration && limit < source.Properties.ConstantDurationLength.Value
? AlterEventDuration(source, limit)
: new ClipByConstantStreamable <TKey, TPayload>(source, limit));
}
/// <summary>
/// Changes the Vs and Ve of each event.
/// </summary>
/// <typeparam name="TKey">Key type of the stream</typeparam>
/// <typeparam name="TPayload">Data type of the stream</typeparam>
/// <param name="source">source stream</param>
/// <param name="startTimeSelector">Function which recomputes the event start time</param>
/// <param name="duration">Amount to alter the durations by</param>
/// <returns>The altered stream</returns>
public static IStreamable <TKey, TPayload> AlterEventLifetime <TKey, TPayload>(
this IStreamable <TKey, TPayload> source,
Expression <Func <long, long> > startTimeSelector,
long duration)
{
Invariant.IsNotNull(source, nameof(source));
Invariant.IsNotNull(startTimeSelector, nameof(startTimeSelector));
Invariant.IsPositive(duration, nameof(duration));
return(new AlterLifetimeStreamable <TKey, TPayload>(source, startTimeSelector, Expression.Lambda <Func <long> >(Expression.Constant(duration))));
}
/// <summary>
/// Changes the Ve of each event according to the duration provided
/// </summary>
/// <param name="source">Source stream</param>
/// <param name="duration"></param>
public static IStreamable <TKey, TPayload> AlterEventDuration <TKey, TPayload>(
this IStreamable <TKey, TPayload> source,
long duration)
{
Invariant.IsNotNull(source, nameof(source));
Invariant.IsPositive(duration, nameof(duration));
return(source is IFusibleStreamable <TKey, TPayload> s
? s.FuseSetDurationConstant(duration)
: (IStreamable <TKey, TPayload>) new AlterLifetimeStreamable <TKey, TPayload>(source, null, Expression.Lambda <Func <long> >(Expression.Constant(duration))));
}
/// <summary>
/// Adjusts the lifetime of incoming events to snap the start and end time of each event to quantized boundaries.
/// The function is similar to a hopping lifetime expression, except that all start edges are either moved
/// earlier or stay the same, and all end edges either move later or stay the same.
/// </summary>
/// <typeparam name="TKey">Type of (mapping) key in the stream</typeparam>
/// <typeparam name="TPayload">Type of payload in the stream</typeparam>
/// <param name="source">Input stream</param>
/// <param name="windowSize">Window size</param>
/// <param name="period">Period (or hop size)</param>
/// <param name="offset">Offset from the start of time</param>
/// <returns>Result (output) stream</returns>
public static IStreamable <TKey, TPayload> QuantizeLifetime <TKey, TPayload>(
this IStreamable <TKey, TPayload> source,
long windowSize,
long period,
long offset = 0)
{
Invariant.IsNotNull(source, nameof(source));
Invariant.IsPositive(windowSize, nameof(windowSize));
Invariant.IsPositive(period, nameof(period));
return(new QuantizeLifetimeStreamable <TKey, TPayload>(source, windowSize, period, period, offset));
}
public MultiUnionStreamable(IStreamable <TKey, TSource>[] sources, bool register = true, bool guaranteedDisjoint = false)
: base(sources.Skip(1).Select(o => o.Properties).Aggregate(sources[0].Properties, (r, p) => r.Union(p)))
{
Invariant.IsNotNull(sources, "sources");
Invariant.IsPositive(sources.Length, "sources.Length");
Invariant.IsNotNull(sources[0], "sources[0]");
this.Sources = sources;
this.registerScheduler = register;
if (guaranteedDisjoint)
{
this.constructor = (l, r, b) => new DisjointUnionStreamable <TKey, TSource>(l, r, b);
}
else
{
this.constructor = (l, r, b) => new UnionStreamable <TKey, TSource>(l, r, b);
}
}
/// <summary>
/// Adjusts the lifetime of incoming events to snap the start and end time of each event to quantized boundaries,
/// except that the start times are progressively spaced through the window.
/// The function is similar to a hopping lifetime expression, except that all start edges are either moved
/// earlier or stay the same, and all end edges either move later or stay the same.
/// </summary>
/// <typeparam name="TKey">Type of (mapping) key in the stream</typeparam>
/// <typeparam name="TPayload">Type of payload in the stream</typeparam>
/// <param name="source">Input stream</param>
/// <param name="windowSize">Window size</param>
/// <param name="period">Period (or hop size)</param>
/// <param name="progress">Interval at which progressive results within a window are requested</param>
/// <param name="offset">Offset from the start of time</param>
/// <returns>Result (output) stream</returns>
public static IStreamable <TKey, TPayload> ProgressiveQuantizeLifetime <TKey, TPayload>(
this IStreamable <TKey, TPayload> source,
long windowSize,
long period,
long progress,
long offset = 0)
{
Invariant.IsNotNull(source, nameof(source));
Invariant.IsPositive(windowSize, nameof(windowSize));
Invariant.IsPositive(period, nameof(period));
Invariant.IsPositive(progress, nameof(progress));
if (period % progress != 0)
{
throw new ArgumentException("Progress interval must be a proper divisor of the period.");
}
if (period <= progress)
{
throw new ArgumentException("Progress interval must be strictly smaller than the period.");
}
return(new QuantizeLifetimeStreamable <TKey, TPayload>(source, windowSize, period, progress, offset));
}
