/// <summary> /// The IdentityArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static IdentityArrow IdentityArrow(this IArrowSender ArrowSender, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _IdentityArrow = new IdentityArrow(Recipient, Recipients); ArrowSender.OnMessageAvailable += _IdentityArrow.ReceiveMessage; return(_IdentityArrow); }
/// <summary> /// An active sensor. /// </summary> /// <param name="IEnumerator">An enumerator of TValues.</param> /// <param name="SensorId">The unique identification of the sensor.</param> /// <param name="SensorName">The name of the sensor.</param> /// <param name="ValueUnit">The unit of the value (m, m², °C, °F, MBytes, ...).</param> /// <param name="Recipient">A recipient of the processed measurements.</param> /// <param name="Autostart">Start the sniper automatically.</param> /// <param name="StartAsTask">Start the ActiveSensor within its own task.</param> /// <param name="InitialDelay">Set the initial delay of the sniper.</param> public ActiveSensor(IEnumerator <TValue> IEnumerator, TId SensorId, String SensorName, String ValueUnit, IArrowReceiver <TValue> Recipient, Boolean Autostart = false, Boolean StartAsTask = false, Nullable <TimeSpan> InitialDelay = null) : this(IEnumerator, SensorId, SensorName, ValueUnit, Autostart, StartAsTask, InitialDelay) { #region Initial Checks if (Recipient == null) { throw new ArgumentNullException("The given Recipient must not be null!"); } #endregion lock (this) { this.OnMessageAvailable += Recipient.ReceiveMessage; } }
public static void SendTo <T1, T2, T3, T4, T5>(this IArrowSender <T1, T2, T3, T4, T5> INotification, IArrowReceiver <T1, T2, T3, T4, T5> Target) { INotification.OnNotification += Target.ProcessArrow; INotification.OnExceptionOccured += Target.ProcessExceptionOccured; INotification.OnCompleted += Target.ProcessCompleted; }
/// <summary> /// A generic Arrow transforming incoming messages into outgoing messages. /// </summary> /// <param name="Func">A generic transformation of incoming messages into outgoing messages.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public FuncArrow(Func <TMessage, TOutput> Func, IArrowReceiver <TOutput> Recipient, params IArrowReceiver <TOutput>[] Recipients) : base(Recipient, Recipients) { if (Func == null) { throw new ArgumentNullException("The given message transformation func must not be null!"); } this.Func = Func; }
/// <summary> /// Filters the consuming objects by calling a Func<S, Boolean>. /// </summary> /// <param name="FilterFunc">A Func<S, Boolean> filtering the consuming objects. True means filter (ignore).</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public FuncFilterArrow(Func <TMessage, Boolean> FilterFunc, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) : base(Recipient, Recipients) { if (FilterFunc == null) { throw new ArgumentNullException("The given FilterFunc must not be null!"); } _FilterFunc = FilterFunc; }
/// <summary> /// The ActionArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="Action">An Action <S> to invoke on every accepted message/object before forwarding it.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public ActionArrow(Action_Object Action, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) : base(Recipient, Recipients) { if (Action == null) { throw new ArgumentNullException("The given Action<TIn> must not be null!"); } this.Action = Action; }
/// <summary> /// Creates a new ActiveSensor based on the given ISensor<TId, TValue>. /// </summary> /// <typeparam name="TId">The type of the unique identification.</typeparam> /// <typeparam name="TValue">The type of the measured value.</typeparam> /// <param name="ISensor">An ISensor<TId, TValue>.</param> /// <param name="Recipient">A recipient of the processed measurements.</param> /// <param name="Autostart">Start the sniper automatically.</param> /// <param name="StartAsTask">Start the ActiveSensor within its own task.</param> /// <param name="InitialDelay">Set the initial delay of the sniper.</param> /// <returns>A new IActiveSensor<TId, TValue>.</returns> public static IActiveSensor <TId, TValue> ToActiveSensor <TId, TValue>(this ISensor <TId, TValue> ISensor, IArrowReceiver <TValue> Recipient, Boolean Autostart = false, Boolean StartAsTask = false, Nullable <TimeSpan> InitialDelay = null) where TId : IEquatable <TId>, IComparable <TId>, IComparable { return(new ActiveSensor <TId, TValue>(ISensor, Recipient, Autostart, StartAsTask, InitialDelay)); }
/// <summary> /// The AggregatorArrow produces a side effect that is the provided collection /// filled with the contents of all the objects that have passed through it. /// The collection enumerator is used as the emitting enumerator. Thus, what /// goes into AggregatorArrow may not be the same as what comes out of /// AggregatorPipe. /// For example, duplicates removed, different order to the stream, etc. /// Finally, note that different Collections have different behaviors and /// write/read times. /// </summary> /// <param name="ICollection">An ICollection to store the passed messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public AggregatorArrow(ICollection <TMessage> ICollection, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) : base(Recipient, Recipients) { if (ICollection == null) { _SideEffect = new List <TMessage>(); } else { _SideEffect = ICollection; } }
/// <summary> /// Creates a new ActiveSensor fireing the content of the given IEnumerator. /// </summary> /// <typeparam name="TId">The type of the unique identification.</typeparam> /// <typeparam name="TValue">The type of the measured value.</typeparam> /// <param name="IEnumerator">An enumerator of messages/objects to send.</param> /// <param name="SensorId">The unique identification of the sensor.</param> /// <param name="SensorName">The name of the sensor.</param> /// <param name="ValueUnit">The unit of the value (m, m², °C, °F, MBytes, ...).</param> /// <param name="Recipient">A recipient of the processed measurements.</param> /// <param name="Autostart">Start the sniper automatically.</param> /// <param name="StartAsTask">Start the ActiveSensor within its own task.</param> /// <param name="InitialDelay">Set the initial delay of the sniper.</param> /// <returns>A new IActiveSensor<TId, TValue>.</returns> public static IActiveSensor <TId, TValue> ToActiveSensor <TId, TValue>(this IEnumerator <TValue> IEnumerator, TId SensorId, String SensorName, String ValueUnit, IArrowReceiver <TValue> Recipient, Boolean Autostart = false, Boolean StartAsTask = false, Nullable <TimeSpan> InitialDelay = null) where TId : IEquatable <TId>, IComparable <TId>, IComparable { return(new ActiveSensor <TId, TValue>(IEnumerator, SensorId, SensorName, ValueUnit, Recipient, Autostart, StartAsTask, InitialDelay)); }
/// <summary> /// Creates a new AbstractArrow and adds the given recipients /// to the list of message recipients. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public AbstractArrowSender(IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { lock (this) { if (Recipient != null) { this.OnMessageAvailable += Recipient.ReceiveMessage; } if (Recipients != null) { foreach (var _Recipient in Recipients) { this.OnMessageAvailable += _Recipient.ReceiveMessage; } } } }
/// <summary> /// The Sniper fetches messages/objects from the given IEnumerator /// and sends them to the recipients. /// </summary> /// <param name="IEnumerator">An IEnumerator<S> as element source.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Autostart">Start the sniper automatically.</param> /// <param name="StartAsTask">Start the sniper within its own task.</param> /// <param name="InitialDelay">Set the initial delay of the sniper in milliseconds.</param> public Sniper(IEnumerator <TOut> IEnumerator, IArrowReceiver <TOut> Recipient, Boolean Autostart = false, Boolean StartAsTask = false, Nullable <TimeSpan> InitialDelay = null) : this(IEnumerator, Autostart, StartAsTask, InitialDelay) { #region Initial Checks if (Recipient == null) { throw new ArgumentNullException("The given Recipient must not be null!"); } #endregion lock (this) { this.OnMessageAvailable += Recipient.ReceiveMessage; } }
/// <summary> /// The AggregatorArrow produces a side effect that is the provided collection /// filled with the contents of all the objects that have passed through it. /// The collection enumerator is used as the emitting enumerator. Thus, what /// goes into AggregatorArrow may not be the same as what comes out of /// AggregatorPipe. /// For example, duplicates removed, different order to the stream, etc. /// Finally, note that different Collections have different behaviors and /// write/read times. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="ICollection">An optional ICollection to store the passed messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static AggregatorArrow <TMessage> Aggregator <TMessage>(this IArrowSender <TMessage> ArrowSender, ICollection <TMessage> ICollection, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) { var _AggregatorArrow = new AggregatorArrow <TMessage>(ICollection, Recipient, Recipients); ArrowSender.OnMessageAvailable += _AggregatorArrow.ReceiveMessage; return(_AggregatorArrow); }
/// <summary> /// The ActionArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Action">An Action <S> to invoke on every accepted message/object before forwarding it.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static ActionArrow ActionArrow(this IArrowSender ArrowSender, Action_Object Action, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _ActionArrow = new ActionArrow(Action, Recipient, Recipients); ArrowSender.OnMessageAvailable += _ActionArrow.ReceiveMessage; return(_ActionArrow); }
/// <summary> /// The IdentityArrow is the most basic arrow. /// It simply sends the incoming message to the recipients without any processing. /// This arrow is useful in various test case situations. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public IdentityArrow(IArrowReceiver Recipient, params IArrowReceiver[] Recipients) : base(Recipient, Recipients) { }
/// <summary> /// Filters the consuming objects by calling a Func<S, Boolean>. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="FilterFunc">A Func<S, Boolean> filtering the consuming objects. True means filter (ignore).</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static FuncFilterArrow <TMessage> FuncFilter <TMessage>(this IArrowSender <TMessage> ArrowSender, Func <TMessage, Boolean> FilterFunc, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) { var _FuncFilterArrow = new FuncFilterArrow <TMessage>(FilterFunc, Recipient, Recipients); ArrowSender.OnMessageAvailable += _FuncFilterArrow.ReceiveMessage; return(_FuncFilterArrow); }
/// <summary> /// Accepts a message of type TIn from a sender for further processing /// and delivery to the subscribers. /// </summary> /// <typeparam name="TMessage">The type of the consuming messages/objects.</typeparam> /// <param name="ArrowReceiver">The receiver of the message.</param> /// <param name="Message">The message.</param> /// <returns>True if the message was accepted and could be processed; False otherwise.</returns> public static Boolean ReceiveMessage <TMessage>(this IArrowReceiver <TMessage> ArrowReceiver, TMessage Message) { return(ArrowReceiver.ReceiveMessage(null, Message)); }
/// <summary> /// The IdentityArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static IdentityArrow IdentityArrow(this IArrowSender ArrowSender, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _IdentityArrow = new IdentityArrow(Recipient, Recipients); ArrowSender.OnMessageAvailable += _IdentityArrow.ReceiveMessage; return _IdentityArrow; }
/// <summary> /// Creates a new AbstractArrow and adds the given recipients /// to the list of message recipients. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public AbstractArrowSender(IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { lock (this) { if (Recipient != null) this.OnMessageAvailable += Recipient.ReceiveMessage; if (Recipients != null) foreach (var _Recipient in Recipients) this.OnMessageAvailable += _Recipient.ReceiveMessage; } }
/// <summary> /// The StdDevSideEffectArrow produces a side effect that /// is the sliding standard deviation and the average of /// messages/objects that have passed through it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static StdDevSideEffectArrow StdDevSideEffectArrow(this IArrowSender<Double> ArrowSender, IArrowReceiver<Double> Recipient, params IArrowReceiver<Double>[] Recipients) { var _CountArrow = new StdDevSideEffectArrow(Recipient, Recipients); ArrowSender.OnMessageAvailable += _CountArrow.ReceiveMessage; return _CountArrow; }
/// <summary> /// Sends a message when then received values are not within /// the bounding box of then given Min/Max-values. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Lower">The lower bound of the passed values.</param> /// <param name="Upper">The upper bound of the passed values.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static BandFilterArrow <TMessage> BandFilter <TMessage>(this IArrowSender <TMessage> ArrowSender, TMessage Lower, TMessage Upper, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) where TMessage : IComparable <TMessage>, IComparable { var _BandFilterArrow = new BandFilterArrow <TMessage>(Lower, Upper, Recipient, Recipients); ArrowSender.OnMessageAvailable += _BandFilterArrow.ReceiveMessage; return(_BandFilterArrow); }
/// <summary> /// The StdDevSideEffectArrow produces a side effect that /// is the sliding standard deviation and the average of /// messages/objects that have passed through it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static StdDevSideEffectArrow StdDevSideEffectArrow(this IArrowSender <Double> ArrowSender, IArrowReceiver <Double> Recipient, params IArrowReceiver <Double>[] Recipients) { var _CountArrow = new StdDevSideEffectArrow(Recipient, Recipients); ArrowSender.OnMessageAvailable += _CountArrow.ReceiveMessage; return(_CountArrow); }
/// <summary> /// The SkipArrow simply sends the incoming message to the recipients /// without any processing, but skips the first n messages. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="NumberOfMessagesToSkip">The number of messages to skip.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static SkipArrow SkipArrow(this IArrowSender ArrowSender, UInt32 NumberOfMessagesToSkip, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _SkipArrow = new SkipArrow(NumberOfMessagesToSkip, Recipient, Recipients); ArrowSender.OnMessageAvailable += _SkipArrow.ReceiveMessage; return _SkipArrow; }
/// <summary> /// The CountArrow produces a side effect that is the total /// number of messages/objects that have passed through it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="InitialValue">The initial value of the counter.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static CountArrow <TMessage> Count <TMessage>(this IArrowSender <TMessage> ArrowSender, Int64 InitialValue, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) { var _CountArrow = new CountArrow <TMessage>(InitialValue, Recipient, Recipients); ArrowSender.OnMessageAvailable += _CountArrow.ReceiveMessage; return(_CountArrow); }
/// <summary> /// The SkipArrow simply sends the incoming message to the recipients /// without any processing, but skips the first n messages. /// </summary> /// <param name="NumberOfMessagesToSkip">The number of messages to skip.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public SkipArrow(UInt32 NumberOfMessagesToSkip, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) : base(Recipient, Recipients) { this.NumberOfMessagesToSkip = NumberOfMessagesToSkip; }
/// <summary> /// The MinMaxArrow produces two side effects which keep /// track of the Min and Max values of S. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Min">The initial minimum.</param> /// <param name="Max">The initial maximum.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static MinMaxArrow <TMessage> MinMax <TMessage>(this IArrowSender <TMessage> ArrowSender, TMessage Min, TMessage Max, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) where TMessage : IComparable, IComparable <TMessage>, IEquatable <TMessage> { var _MinMaxArrow = new MinMaxArrow <TMessage>(Min, Max, Recipient, Recipients); ArrowSender.OnMessageAvailable += _MinMaxArrow.ReceiveMessage; return(_MinMaxArrow); }
/// <summary> /// The SkipArrow simply sends the incoming message to the recipients /// without any processing, but skips the first n messages. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="NumberOfMessagesToSkip">The number of messages to skip.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static SkipArrow SkipArrow(this IArrowSender ArrowSender, UInt32 NumberOfMessagesToSkip, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _SkipArrow = new SkipArrow(NumberOfMessagesToSkip, Recipient, Recipients); ArrowSender.OnMessageAvailable += _SkipArrow.ReceiveMessage; return(_SkipArrow); }
/// <summary> /// The StdDevArrow consumes doubles and emitts the /// sliding standard deviation and the average of /// messages/objects that have passed through it. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public StdDevArrow(IArrowReceiver <Tuple <Double, Double, Double> > Recipient, params IArrowReceiver <Tuple <Double, Double, Double> >[] Recipients) : base(Recipient, Recipients) { }
/// <summary> /// The DuplicateFilterArrow will not allow a duplicate object to pass through it. /// This is accomplished by the Arrow maintaining an internal HashSet that is used /// to store a history of previously seen objects. /// Thus, the more unique objects that pass through this Arrow, the slower it /// becomes as a log_2 index is checked for every object. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public DuplicateFilterArrow(IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) : base(Recipient, Recipients) { _HistorySet = new HashSet <TMessage>(); }
/// <summary> /// The StdDevArrow consumes doubles and emitts the /// sliding standard deviation and the average of /// messages/objects that have passed through it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static StdDevArrow StdDevArrow(this IArrowSender <Double> ArrowSender, IArrowReceiver <Tuple <Double, Double, Double> > Recipient, params IArrowReceiver <Tuple <Double, Double, Double> >[] Recipients) { var _StdDevArrow = new StdDevArrow(Recipient, Recipients); ArrowSender.OnMessageAvailable += _StdDevArrow.ReceiveMessage; return(_StdDevArrow); }
/// <summary> /// The CountArrow produces a side effect that is the total /// number of messages/objects that have passed through it. /// </summary> /// <param name="InitialValue">The initial value of the counter.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public CountArrow(Int64 InitialValue, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) : base(Recipient, Recipients) { _SideEffect = InitialValue; }
/// <summary> /// The ActionArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Action">An Action <S> to invoke on every accepted message/object before forwarding it.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static ActionArrow ActionArrow(this IArrowSender ArrowSender, Action_Object Action, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) { var _ActionArrow = new ActionArrow(Action, Recipient, Recipients); ArrowSender.OnMessageAvailable += _ActionArrow.ReceiveMessage; return _ActionArrow; }
/// <summary> /// The ActionArrow is much like the IdentityArrow, but calls /// an Action <S> on every accepted message/object before /// forwarding it. /// </summary> /// <param name="Action">An Action <S> to invoke on every accepted message/object before forwarding it.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public ActionArrow(Action_Object Action, IArrowReceiver Recipient, params IArrowReceiver[] Recipients) : base(Recipient, Recipients) { if (Action == null) throw new ArgumentNullException("The given Action<TIn> must not be null!"); this.Action = Action; }
/// <summary> /// A generic Arrow transforming incoming messages into outgoing messages. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Func">A generic transformation of incoming messages into outgoing messages.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static FuncArrow <TIn, TOutput> FuncArrow <TIn, TOutput>(this IArrowSender <TIn> ArrowSender, Func <TIn, TOutput> Func, IArrowReceiver <TOutput> Recipient, params IArrowReceiver <TOutput>[] Recipients) { var _FuncArrow = new FuncArrow <TIn, TOutput>(Func, Recipient, Recipients); ArrowSender.OnMessageAvailable += _FuncArrow.ReceiveMessage; return(_FuncArrow); }
/// <summary> /// Filters the consuming objects by calling a Func<S, Boolean>. /// </summary> /// <param name="Lower">The lower bound of the passed values.</param> /// <param name="Upper">The upper bound of the passed values.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public BandFilterArrow(TMessage Lower, TMessage Upper, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) : base(Recipient, Recipients) { this.Lower = Lower; this.Upper = Upper; }
/// <summary> /// The DuplicateFilterArrow will not allow a duplicate object to pass through it. /// This is accomplished by the Arrow maintaining an internal HashSet that is used /// to store a history of previously seen objects. /// Thus, the more unique objects that pass through this Arrow, the slower it /// becomes as a log_2 index is checked for every object. /// </summary> /// <param name="ArrowSender">The sender of the messages/objects.</param> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">Further recipients of the processed messages.</param> public static DuplicateFilterArrow <TMessage> DuplicateFilter <TMessage>(this IArrowSender <TMessage> ArrowSender, IArrowReceiver <TMessage> Recipient, params IArrowReceiver <TMessage>[] Recipients) { var _DuplicateFilterArrow = new DuplicateFilterArrow <TMessage>(Recipient, Recipients); ArrowSender.OnMessageAvailable += _DuplicateFilterArrow.ReceiveMessage; return(_DuplicateFilterArrow); }
/// <summary> /// The StdDevSideEffectArrow produces a side effect that /// is the sliding standard deviation and the average of /// messages/objects that have passed through it. /// </summary> /// <param name="Recipient">A recipient of the processed messages.</param> /// <param name="Recipients">The recipients of the processed messages.</param> public StdDevSideEffectArrow(IArrowReceiver <Double> Recipient, params IArrowReceiver <Double>[] Recipients) : base(Recipient, Recipients) { }