private void AttachResult(TIntermediate element)
{
TaggedObservableValue <TResult, int> result;
if (!Results.TryGetValue(element, out result))
{
result = Parent.selector.InvokeTagged(Item, element, 0);
result.Successors.Set(this);
Results.Add(element, result);
}
result.Tag++;
}
public void AttachResult(TIntermediate element)
{
TaggedObservableValue <TResult, int> result;
if (!Values.TryGetValue(element, out result))
{
result = Parent.selector.InvokeTagged(this, element, 0);
result.ValueChanged += Parent.ResultChanged;
Values.Add(element, result);
}
result.Tag++;
}
private void DetachResult(TIntermediate element)
{
TaggedObservableValue <TResult, int> result;
if (Results.TryGetValue(element, out result))
{
result.Tag--;
if (result.Tag == 0)
{
Results.Remove(element);
result.Successors.Unset(this);
}
}
}
public void DetachResult(TIntermediate element)
{
TaggedObservableValue <TResult, int> result;
if (Values.TryGetValue(element, out result))
{
result.Tag--;
if (result.Tag == 0)
{
Values.Remove(element);
result.ValueChanged -= Parent.ResultChanged;
result.Detach();
}
}
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
_trackBinding = playerData as TBinding;
if (_trackBinding == null)
{
return;
}
if (!FirstFrameHappened)
{
Default = GetState(_trackBinding);
}
ApplyState(Mix(playable, info, _trackBinding), _trackBinding);
FirstFrameHappened = true;
}
internal override bool MoveNext(ref TIntermediate currentElement, ref int currentKey)
{
if (!this.m_accumulated)
{
this.m_accumulated = true;
bool flag = false;
TIntermediate local = default(TIntermediate);
if (this.m_reduceOperator.m_seedIsSpecified)
{
local = (this.m_reduceOperator.m_seedFactory == null) ? this.m_reduceOperator.m_seed : this.m_reduceOperator.m_seedFactory();
}
else
{
TInput local2 = default(TInput);
TKey local3 = default(TKey);
if (!this.m_source.MoveNext(ref local2, ref local3))
{
return(false);
}
flag = true;
local = (TIntermediate)local2;
}
TInput local4 = default(TInput);
TKey local5 = default(TKey);
int num = 0;
while (this.m_source.MoveNext(ref local4, ref local5))
{
if ((num++ & 0x3f) == 0)
{
CancellationState.ThrowIfCanceled(this.m_cancellationToken);
}
flag = true;
local = this.m_reduceOperator.m_intermediateReduce(local, local4);
}
if (flag)
{
currentElement = local;
currentKey = this.m_partitionIndex;
return(true);
}
}
return(false);
}
//---------------------------------------------------------------------------------------
// This API, upon the first time calling it, walks the entire source query tree. It begins
// with an accumulator value set to the aggregation operator's seed, and always passes
// the accumulator along with the current element from the data source to the binary
// intermediary aggregation operator. The return value is kept in the accumulator. At
// the end, we will have our intermediate result, ready for final aggregation.
//
internal override bool MoveNext(ref TIntermediate currentElement, ref int currentKey)
{
Contract.Assert(_reduceOperator != null);
Contract.Assert(_reduceOperator._intermediateReduce != null, "expected a compiled operator");
// Only produce a single element. Return false if MoveNext() was already called before.
if (_accumulated)
{
return(false);
}
_accumulated = true;
bool hadNext = false;
TIntermediate accumulator = default(TIntermediate);
// Initialize the accumulator.
if (_reduceOperator._seedIsSpecified)
{
// If the seed is specified, initialize accumulator to the seed value.
accumulator = _reduceOperator._seedFactory == null
? _reduceOperator._seed
: _reduceOperator._seedFactory();
}
else
{
// If the seed is not specified, then we take the first element as the seed.
// Seed may be unspecified only if TInput is the same as TIntermediate.
Contract.Assert(typeof(TInput) == typeof(TIntermediate));
TInput acc = default(TInput);
TKey accKeyUnused = default(TKey);
if (!_source.MoveNext(ref acc, ref accKeyUnused))
{
return(false);
}
hadNext = true;
accumulator = (TIntermediate)((object)acc);
}
// Scan through the source and accumulate the result.
TInput input = default(TInput);
TKey keyUnused = default(TKey);
int i = 0;
while (_source.MoveNext(ref input, ref keyUnused))
{
if ((i++ & CancellationState.POLL_INTERVAL) == 0)
{
CancellationState.ThrowIfCanceled(_cancellationToken);
}
hadNext = true;
accumulator = _reduceOperator._intermediateReduce(accumulator, input);
}
if (hadNext)
{
currentElement = accumulator;
currentKey = _partitionIndex; // A reduction's "index" is just its partition number.
return(true);
}
return(false);
}
public TaggedIntermediate(TIntermediate d, int taskNumber)
{
ProcessedData = d;
TaskNumber = taskNumber;
}
/// <summary> /// Apply the output of the mixer to the given object /// </summary> /// <param name="intermediate"></param> /// <param name="trackBinding"></param> protected abstract void ApplyState(TIntermediate intermediate, [NotNull] TBinding trackBinding);
