//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext([MaybeNullWhen(false), AllowNull] ref TOutput currentElement, ref TKey currentKey)
{
// So long as the source has a next element, we have an element.
TInput element = default(TInput) !;
if (_source.MoveNext(ref element !, ref currentKey))
{
Debug.Assert(_selector != null, "expected a compiled operator");
currentElement = _selector(element);
return(true);
}
return(false);
}
//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext(ref TOutput currentElement, ref TKey currentKey)
{
// So long as the source has a next element, we have an element.
TInput element = default(TInput);
if (m_source.MoveNext(ref element, ref currentKey))
{
Contract.Assert(m_selector != null, "expected a compiled operator");
currentElement = m_selector(element);
return(true);
}
return(false);
}
internal void Activity_GetInputTest()
{
var activity = Substitute.ForPartsOf <ActivityBase <TOutput, TOutput> >("SimpleActivity", "taskList"); // { Version = "1.0" };
var exptected = new TOutput {
Value = "correct value"
};
((IActivity)activity).Input = Utils.SerializeToJSON(exptected);
var result = activity.Input;
AssertObjectEquals.PropertyValuesAreEqual(result, exptected);
}
public void ProcessWithoutBuffer(ref TInput input, ref TOutput output)
{
if (InitialWindowedBuffer.Count < InitialWindowSize)
{
InitialWindowedBuffer.AddLast(input);
SetNaOutput(ref output);
if (InitialWindowedBuffer.Count == InitialWindowSize)
{
LearnStateFromDataCore(InitialWindowedBuffer);
}
}
else
{
TransformCore(ref input, WindowedBuffer, RowCounter - InitialWindowSize, ref output);
IncrementRowCounter();
}
}
/// <summary>
/// Tries get the value for the given key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="input">???</param>
/// <param name="output">The output containing the value if record of the given exists.</param>
/// <returns>true if the record of the key exists; false otherwise.</returns>
public bool TryGet(ref TKey key, ref TInput input, ref TOutput output)
{
var context = new StoreContext <TOutput>();
var status = _session.Read(ref key, ref input, ref output, context, 0);
if (status == Status.PENDING)
{
_session.CompletePending(true);
context.FinalizeRead(ref status, ref output);
}
if (status == Status.NOTFOUND)
{
return(false);
}
if (status != Status.OK)
{
throw new InvalidOperationException("Error ocurred when reading data.");
}
return(true);
}
/// <summary>
/// Tests if the store contains the given key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns>true if the given key is in the store; false otherwise.</returns>
public bool ContainsKey(ref TKey key)
{
var input = new TInput();
var output = new TOutput();
var context = new StoreContext <TOutput>();
var status = _session.Read(ref key, ref input, ref output, context, 0);
if (status == Status.PENDING)
{
_session.CompletePending(true);
context.FinalizeRead(ref status, ref output);
}
if (status == Status.NOTFOUND || status == Status.ERROR)
{
return(false);
}
else
{
return(true);
}
}
public void ProcessWithoutBuffer(ref TInput input, ref TOutput output)
{
if (PreviousPosition == -1)
{
UpdateStateCore(ref input, false);
}
if (InitialWindowedBuffer.Count < InitialWindowSize)
{
SetNaOutput(ref output);
if (InitialWindowedBuffer.Count == InitialWindowSize)
{
LearnStateFromDataCore(InitialWindowedBuffer);
}
}
else
{
TransformCore(ref input, WindowedBuffer, RowCounter - InitialWindowSize, ref output);
}
}
internal override bool MoveNext(ref TOutput currentElement, ref Pair <TLeftKey, int> currentKey)
{
while (true)
{
if (this.m_currentRightSource == null)
{
this.m_mutables = new Mutables <TLeftInput, TRightInput, TOutput, TLeftKey>();
if ((this.m_mutables.m_lhsCount++ & 0x3f) == 0)
{
CancellationState.ThrowIfCanceled(this.m_cancellationToken);
}
if (!this.m_leftSource.MoveNext(ref this.m_mutables.m_currentLeftElement, ref this.m_mutables.m_currentLeftKey))
{
return(false);
}
this.m_currentRightSource = this.m_selectManyOperator.m_rightChildSelector(this.m_mutables.m_currentLeftElement).GetEnumerator();
if (this.m_selectManyOperator.m_resultSelector == null)
{
this.m_currentRightSourceAsOutput = (IEnumerator <TOutput>) this.m_currentRightSource;
}
}
if (this.m_currentRightSource.MoveNext())
{
this.m_mutables.m_currentRightSourceIndex++;
if (this.m_selectManyOperator.m_resultSelector != null)
{
currentElement = this.m_selectManyOperator.m_resultSelector(this.m_mutables.m_currentLeftElement, this.m_currentRightSource.Current);
}
else
{
currentElement = this.m_currentRightSourceAsOutput.Current;
}
currentKey = new Pair <TLeftKey, int>(this.m_mutables.m_currentLeftKey, this.m_mutables.m_currentRightSourceIndex);
return(true);
}
this.m_currentRightSource.Dispose();
this.m_currentRightSource = null;
this.m_currentRightSourceAsOutput = null;
}
}
public void ProcessWithoutBuffer(ref TInput input, ref TOutput output)
{
//Using prediction engine will not evaluate the below condition to true.
if (PreviousPosition == -1)
{
UpdateStateCore(ref input);
}
if (InitialWindowedBuffer.Count < InitialWindowSize)
{
SetNaOutput(ref output);
if (InitialWindowedBuffer.Count == InitialWindowSize)
{
LearnStateFromDataCore(InitialWindowedBuffer);
}
}
else
{
TransformCore(ref input, WindowedBuffer, RowCounter - InitialWindowSize, ref output);
}
}
public static void Level <TData, TOutput>() where TOutput : AOutput <TData>, new()
{
var data = DeserializeFile <TData>();
if (data == null)
{
Console.WriteLine("Une erreur est survenue lors de la récupération des données, veuillez vérifier que le fichier 'data.json' est présent et correct.");
return;
}
try
{
var output = new TOutput().FromData(data);
var serialized = SerializeFile(output);
if (serialized == false)
{
Console.WriteLine("Une erreur est survenue lors de la création des données, un fichier 'output.json' doit pouvoir être créé.");
}
}
catch (Exception)
{
Console.WriteLine("Une erreur est survenue lors du traitement des données, veuillez vérifier que le fichier 'data.json' contient des données valides.");
}
}
//---------------------------------------------------------------------------------------
// Straightforward IEnumerator<T> methods.
//
internal override bool MoveNext(ref TOutput currentElement, ref Pair <TLeftKey, int> currentKey)
{
while (true)
{
if (_currentRightSource == null)
{
_mutables = new Mutables();
// Check cancellation every few lhs-enumerations in case none of them are producing
// any outputs. Otherwise, we rely on the consumer of this operator to be performing the checks.
if ((_mutables._lhsCount++ & CancellationState.POLL_INTERVAL) == 0)
{
CancellationState.ThrowIfCanceled(_cancellationToken);
}
// We don't have a "current" right enumerator to use. We have to fetch the next
// one. If the left has run out of elements, however, we're done and just return
// false right away.
if (!_leftSource.MoveNext(ref _mutables._currentLeftElement, ref _mutables._currentLeftKey))
{
return(false);
}
// Use the source selection routine to create a right child.
IEnumerable <TRightInput> rightChild = _selectManyOperator._rightChildSelector(_mutables._currentLeftElement);
Debug.Assert(rightChild != null);
_currentRightSource = rightChild.GetEnumerator();
Debug.Assert(_currentRightSource != null);
// If we have no result selector, we will need to access the Current element of the right
// data source as though it is a TOutput. Unfortunately, we know that TRightInput must
// equal TOutput (we check it during operator construction), but the type system doesn't.
// Thus we would have to cast the result of invoking Current from type TRightInput to
// TOutput. This is no good, since the results could be value types. Instead, we save the
// enumerator object as an IEnumerator<TOutput> and access that later on.
if (_selectManyOperator._resultSelector == null)
{
_currentRightSourceAsOutput = (IEnumerator <TOutput>)_currentRightSource;
Debug.Assert(_currentRightSourceAsOutput == _currentRightSource,
"these must be equal, otherwise the surrounding logic will be broken");
}
}
if (_currentRightSource.MoveNext())
{
_mutables._currentRightSourceIndex++;
// If the inner data source has an element, we can yield it.
if (_selectManyOperator._resultSelector != null)
{
// In the case of a selection function, use that to yield the next element.
currentElement = _selectManyOperator._resultSelector(_mutables._currentLeftElement, _currentRightSource.Current);
}
else
{
// Otherwise, the right input and output types must be the same. We use the
// casted copy of the current right source and just return its current element.
Debug.Assert(_currentRightSourceAsOutput != null);
currentElement = _currentRightSourceAsOutput.Current;
}
currentKey = new Pair <TLeftKey, int>(_mutables._currentLeftKey, _mutables._currentRightSourceIndex);
return(true);
}
else
{
// Otherwise, we have exhausted the right data source. Loop back around and try
// to get the next left element, then its right, and so on.
_currentRightSource.Dispose();
_currentRightSource = null;
_currentRightSourceAsOutput = null;
}
}
}
/// <summary>
/// The abstract method that specifies the NA value for the dst type.
/// </summary>
/// <returns></returns>
private protected virtual void SetNaOutput(ref TOutput dst)
{
}
/// <summary>
/// The abstract method that realizes the main logic for the transform.
/// </summary>
/// <param name="input">A reference to the input object.</param>
/// <param name="dst1">A reference to the dst object.</param>
/// <param name="dst2"></param>
/// <param name="dst3"></param>
/// <param name="windowedBuffer">A reference to the windowed buffer.</param>
/// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param>
private protected virtual void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration,
ref TOutput dst1, ref TOutput dst2, ref TOutput dst3)
{
}
public virtual void ConfidenceIntervalUpperBound(ref TOutput dst)
{
}
public virtual void Forecast(ref TOutput dst)
{
}
/// <summary>
/// The abstract method that realizes the main logic for the transform.
/// </summary>
/// <param name="input">A reference to the input object.</param>
/// <param name="dst">A reference to the dst object.</param>
/// <param name="windowedBuffer">A reference to the windowed buffer.</param>
/// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param>
public virtual void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration, ref TOutput dst)
{
}
/// <summary> /// The abstract method that specifies the NA value for <paramref name="dst"/>'s type. /// </summary> /// <returns></returns> private protected abstract void SetNaOutput(ref TOutput dst);
public OfferedMessage(ISourceBlock <TInput> source, DataflowMessageHeader sourceHeader, TOutput transformedValue)
{
this.Source = source;
this.SourceHeader = sourceHeader;
this.TransformedValue = transformedValue;
}
public void OnCompleted <TInput>(Action continuation, TInput task) where TInput : TOutput
{
_task = task;
continuation();
}
//like class template member partical specialize
public TOutput Converter <TOutput>()
{
TOutput output = (TOutput)Convert.ChangeType(data, typeof(TOutput));
return(output);
}
public TOutput Converter <TOutput>()
{
TOutput result = (TOutput)Convert.ChangeType(m_value, typeof(TOutput));
return(result);
}
/// <summary> /// The abstract method that realizes the main logic for the transform. /// </summary> /// <param name="input">A reference to the input object.</param> /// <param name="dst">A reference to the dst object.</param> /// <param name="windowedBuffer">A reference to the windowed buffer.</param> /// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param> private protected abstract void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration, ref TOutput dst);
public void OnNext(TSource value)
{
TOutput selectedValue = this.selection(value);
this.observer.OnNext(selectedValue);
}
