/// <summary>
/// Creates an new abstract side effect pipe using the given pipe as element source.
/// </summary>
/// <param name="SourcePipe">A pipe as element source.</param>
/// <param name="SideEffect1">The initial value of the first side effect.</param>
/// <param name="SideEffect2">The initial value of the second side effect.</param>
public AbstractTwoSideEffectsPipe(IEndPipe <S> SourcePipe,
T1 SideEffect1,
T2 SideEffect2)
: base(SourcePipe)
{
this.SideEffect1 = SideEffect1;
this.SideEffect2 = SideEffect2;
}
/// <summary>
/// Determines whether a pipe emits any items.
/// </summary>
/// <typeparam name="T">The type of the items emitted by the pipe.</typeparam>
/// <param name="SourcePipe">A pipe.</param>
/// <returns>True if the pipe emits any items; otherwise, false.</returns>
public static Boolean Any <T>(this IEndPipe <T> SourcePipe)
{
if (SourcePipe == null)
{
return(false);
}
using (var Enumerator = SourcePipe)
return(Enumerator.MoveNext());
}
public ZipMergePipe(IEndPipe <S1> SourcePipe1,
IEndPipe <S2> SourcePipe2,
Func <S1, S2, E> ZipDelegate)
: base(SourcePipe1, SourcePipe2)
{
this.ZipDelegate = ZipDelegate;
this.ProcessingDelegate = GetProcessingDelegate();
}
/// <summary>
/// Splits a given strings into elements by a given sperator.
/// </summary>
/// <param name="SourcePipe">An enumeration of strings.</param>
/// <param name="IgnoreLines">A regular expression indicating which input strings should be ignored. Default: All lines starting with a '#'.</param>
/// <param name="Seperators">An array of string used to split the input strings.</param>
/// <param name="StringSplitOptions">Split options, e.g. remove empty entries.</param>
/// <param name="ExpectedNumberOfColumns">If the CSV file had a schema, a specific number of columns can be expected. If instead it is a list of values no such value can be expected.</param>
/// <param name="FailOnWrongNumberOfColumns">What to do when the current and expected number of columns do not match.</param>
/// <param name="TrimColumns">Remove leading and trailing whitespaces.</param>
/// <returns>An enumeration of string arrays.</returns>
public static IEndPipe <String[]> ToCSV(this IEndPipe <String> SourcePipe,
Regex IgnoreLines = null,
String[] Seperators = null,
StringSplitOptions StringSplitOptions = StringSplitOptions.None,
UInt16?ExpectedNumberOfColumns = null,
Boolean FailOnWrongNumberOfColumns = false,
Boolean TrimColumns = true)
{
return(new CSVReaderPipe(SourcePipe, IgnoreLines, Seperators, StringSplitOptions, ExpectedNumberOfColumns, FailOnWrongNumberOfColumns, TrimColumns));
}
public ZipTuplePipe(IEndPipe <S1> SourcePipe1,
IEndPipe <S2> SourcePipe2,
Func <S1, S2, UInt64, IlliasC.Tuple <S1, S2> > CountedZipDelegate)
: base(SourcePipe1, SourcePipe2)
{
this.CountedZipDelegate = CountedZipDelegate;
this.ProcessingDelegate = GetProcessingDelegate();
}
/// <summary>
/// Creates an new abstract side effect pipe using the given pipe as element source.
/// </summary>
/// <param name="SourcePipe">A pipe as element source.</param>
/// <param name="SideEffect1">The initial value of the first side effect.</param>
/// <param name="SideEffect2">The initial value of the second side effect.</param>
/// <param name="SideEffect3">The initial value of the third side effect.</param>
public AbstractThreeSideEffectsPipe(IEndPipe <S> SourcePipe,
T1 SideEffect1,
T2 SideEffect2,
T3 SideEffect3)
: base(SourcePipe)
{
this.SideEffect1 = SideEffect1;
this.SideEffect2 = SideEffect2;
this.SideEffect3 = SideEffect3;
}
/// <summary>
/// Creates a new RangeFilterPipe.
/// </summary>
/// <param name="Low">The minimal value.</param>
/// <param name="High">The maximum value.</param>
/// <param name="IEnumerable">An optional enumation of directories as element source.</param>
/// <param name="IEnumerator">An optional enumerator of directories as element source.</param>
public RangeFilterPipe(IEndPipe <S> SourcePipe, Int32 Low, Int32 High)
: base(SourcePipe)
{
if (Low > -1 && High > -1 && Low >= High)
{
throw new ArgumentOutOfRangeException("Low must be smaller than High!");
}
this.Low = Low;
this.High = High;
this.Counter = -1;
}
/// <summary>
/// Creates a new property filter pipe.
/// </summary>
/// <param name="SourcePipe">A pipe as element source.</param>
/// <param name="Key">The property key.</param>
/// <param name="ComparisonFilter">The comparison filter to use.</param>
public APropertyFilterPipe(IEndPipe <S> SourcePipe,
TKey Key,
ComparisonFilter <TValue> ComparisonFilter)
: base(SourcePipe)
{
ComparisonFilter.CheckNull("ComparisonFilter");
this.Key = Key;
this.ComparisonFilter = ComparisonFilter;
}
/// <summary>
/// Scans the given directories for files matching the given filters.
/// </summary>
/// <param name="SearchPattern">A simple search pattern like "*.jpg".</param>
/// <param name="SearchOption">Include or do not include subdirectories.</param>
/// <param name="FileFilter">A delegate for filtering the found files.</param>
/// <param name="IEnumerable">An optional enumation of directories as element source.</param>
/// <param name="IEnumerator">An optional enumerator of directories as element source.</param>
public FileFilterPipe(IEndPipe <String> SourcePipe,
String SearchPattern = "*",
SearchOption SearchOption = SearchOption.TopDirectoryOnly,
FileFilter FileFilter = null,
IEnumerable <String> IEnumerable = null,
IEnumerator <String> IEnumerator = null)
: base(SourcePipe)
{
_SearchPattern = SearchPattern;
_SearchOption = SearchOption;
_FileFilter = FileFilter;
}
/// <summary>
/// Creates a new AbstractPipe using the elements emitted
/// by the given IEnumerator as input.
/// </summary>
/// <param name="InternalPipes">The array of all wrapped pipes.</param>
/// <param name="IEnumerable">An IEnumerable<S> as element source.</param>
/// <param name="IEnumerator">An IEnumerator<S> as element source.</param>
public AbstractMetaPipe(IPipe[] InternalPipes, IEnumerable <S> IEnumerable, IEnumerator <S> IEnumerator)
{
#region Initial checks
if (InternalPipes == null)
{
throw new ArgumentNullException("The array of wrapped pipes must not be null!");
}
if (InternalPipes.Length < 2)
{
throw new ArgumentException("The array of wrapped pipes must at least wrap two pipes!");
}
if (!(InternalPipes[0] is IStartPipe <S>))
{
throw new ArgumentException("The first wrapped pipe must implement IStartPipe<S>!");
}
if (!(InternalPipes[InternalPipes.Length - 1] is IEndPipe <E>))
{
throw new ArgumentException("The last wrapped pipe must implement IEndPipe<E>!");
}
if (IEnumerator != null && IEnumerable != null)
{
throw new ArgumentException("Please decide between IEnumerator and IEnumerable!");
}
#endregion
this.InternalPipes = InternalPipes;
this.StartPipe = InternalPipes[0] as IStartPipe <S>;
this.EndPipe = InternalPipes[InternalPipes.Length - 1] as IEndPipe <E>;
if (IEnumerable != null)
{
this.StartPipe.SetSourceCollection(IEnumerable);
}
if (IEnumerator != null)
{
this.StartPipe.SetSource(IEnumerator);
}
for (var i = 1; i < InternalPipes.Length; i++)
{
InternalPipes[i].SetSource(InternalPipes[i - 1]);
}
}
/// <summary>
/// Creates an new abstract pipe using the given enumerable as element source.
/// </summary>
/// <param name="SourceEnumerable">An enumeration as element source.</param>
/// <param name="SourceEnumerator">An enumerator as element source.</param>
public AbstractPipe(IEnumerable <S> SourceEnumeration, IEnumerator <S> SourceEnumerator)
{
if (SourceEnumeration == null && SourceEnumerator == null)
{
throw new ArgumentNullException("The given sources must not both be null!");
}
if (SourceEnumeration != null)
{
this.SourcePipe = EndPipe.CreatePipe(SourceEnumeration);
}
if (SourceEnumerator != null)
{
this.SourcePipe = EndPipe.CreatePipe(SourceEnumerator);
}
}
/// <summary>
/// Determines whether any item emitted by a pipe satisfies a condition.
/// </summary>
/// <typeparam name="T">The type of the items emitted by the pipe.</typeparam>
/// <param name="SourcePipe">A pipe.</param>
/// <param name="IncludeFilter">A delegate to test each item emitted by the pipe for a condition.</param>
/// <returns>True if the pipe emits any matching items; otherwise, false.</returns>
public static Boolean Any <T>(this IEndPipe <T> SourcePipe, Func <T, Boolean> IncludeFilter)
{
if (SourcePipe == null)
{
return(false);
}
foreach (var Item in SourcePipe)
{
if (IncludeFilter(Item))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// True if the enumerator was successfully advanced to the next
/// element; false if the enumerator has passed the end of the
/// collection.
/// </returns>
public Boolean MoveNext()
{
if (_InternalEnumerator == null)
{
return(false);
}
if (_EndPipe == null && _PipelineDefinition == null)
{
return(false);
}
if (_EndPipe != null)
{
if (_EndPipe.MoveNext())
{
_CurrentElement = _EndPipe.Current;
return(true);
}
}
else if (_PipelineDefinition != null)
{
while (true)
{
if (_TmpIterator != null && _TmpIterator.MoveNext())
{
_CurrentElement = _TmpIterator.Current;
return(true);
}
else if (_InternalEnumerator.MoveNext())
{
_TmpIterator = _PipelineDefinition(_InternalEnumerator.Current);
}
else
{
return(false);
}
}
}
return(false);
}
/// <summary>
/// Splits a given strings into elements by a given sperator.
/// </summary>
/// <param name="SourcePipe"></param>
/// <param name="IgnoreLines">A regular expression indicating which input strings should be ignored. Default: All lines starting with a '#'.</param>
/// <param name="Seperators">An array of string used to split the input strings.</param>
/// <param name="StringSplitOptions">Split options, e.g. remove empty entries.</param>
/// <param name="ExpectedNumberOfColumns">If the CSV file had a schema, a specific number of columns can be expected. If instead it is a list of values no such value can be expected.</param>
/// <param name="FailOnWrongNumberOfColumns">What to do when the current and expected number of columns do not match.</param>
/// <param name="TrimColumns">Remove leading and trailing whitespaces.</param>
public CSVReaderPipe(IEndPipe <String> SourcePipe,
Regex IgnoreLines = null,
String[] Seperators = null,
StringSplitOptions StringSplitOptions = StringSplitOptions.None,
UInt16?ExpectedNumberOfColumns = null,
Boolean FailOnWrongNumberOfColumns = false,
Boolean TrimColumns = true)
: base(SourcePipe, 0UL)
{
this.IgnoreLines = (IgnoreLines == null) ? new Regex(@"^\#") : IgnoreLines;
this.Seperators = (Seperators == null) ? new String[] { "," } : Seperators;
this.StringSplitOptions = StringSplitOptions;
this.ExpectedNumberOfColumns = ExpectedNumberOfColumns;
this.FailOnWrongNumberOfColumns = FailOnWrongNumberOfColumns;
this.TrimColumns = TrimColumns;
this.EmptyColumRegex = new Regex("\\" + this.Seperators[0] + "\\s\\" + this.Seperators[0]);
}
/// <summary>
/// Safely aggregates the items emitted by the given pipe. If the pipe is null
/// or has no elements the default value will be returned.
/// </summary>
/// <typeparam name="T">The type of the items emitted by the pipe.</typeparam>
/// <param name="SourcePipe">A pipe.</param>
/// <param name="DefaultValue">The default value to return for an empty pipe.</param>
public static T Aggregate <T>(this IEndPipe <T> SourcePipe,
T Prefix,
Func <T, T> Map,
Func <T, T, T> Reduce,
T Suffix,
T DefaultValue = default(T))
{
if (SourcePipe == null)
{
return(DefaultValue);
}
try
{
return(Reduce(Reduce(Prefix, SourcePipe.Select(Item => Map(Item)).Aggregate(Reduce)), Suffix));
}
catch (Exception e)
{
return(DefaultValue);
}
}
/// <summary>
/// Returns the last item of the given pipe that satisfies a condition
/// or the given default value if no such item was found.
/// </summary>
/// <typeparam name="T">The type of the items emitted by the pipe.</typeparam>
/// <param name="SourcePipe">A pipe.</param>
/// <param name="IncludeFilter">A delegate to test each item emitted by the pipe for a condition.</param>
/// <param name="DefaultValue">A default value.</param>
public static T LastOrDefault <T>(this IEndPipe <T> SourcePipe,
Func <T, Boolean> IncludeFilter = null,
T DefaultValue = default(T))
{
if (SourcePipe == null)
{
return(DefaultValue);
}
T Value = DefaultValue;
foreach (var Item in SourcePipe)
{
if (IncludeFilter(Item))
{
Value = Item;
}
}
return(Value);
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// True if the enumerator was successfully advanced to the next
/// element; false if the enumerator has passed the end of the
/// collection.
/// </returns>
public override Boolean MoveNext()
{
while (true)
{
if (CurrentPipe == null)
{
if (!SourcePipe2.MoveNext())
{
return(false);
}
CurrentPipe = SourcePipe2.Current;
}
if (CurrentPipe.MoveNext())
{
_CurrentElement = CurrentPipe.Current;
return(true);
}
CurrentPipe = null;
}
}
public static List <T> ToList <T>(this IEndPipe <T> SourcePipe,
Boolean ResetPipeBefore = false,
Boolean ResetPipeAfter = false)
{
var List = new List <T>();
if (ResetPipeBefore)
{
SourcePipe.Reset();
}
foreach (var Item in SourcePipe)
{
List.Add(Item);
}
if (ResetPipeAfter)
{
SourcePipe.Reset();
}
return(List);
}
/// <summary>
/// Determines whether a pipe emits the specified element by
/// using the default equality comparer.
/// </summary>
/// <typeparam name="T">The type of the items emitted by the pipe.</typeparam>
/// <param name="SourcePipe">A pipe.</param>
/// <param name="Value">The value to locate in the pipe.</param>
/// <param name="ValueComparer">An equality comparer to compare values.</param>
/// <returns>True if the pipe contains an item that has the specified value; otherwise, false.</returns>
public static Boolean Contains <T>(this IEndPipe <T> SourcePipe,
T Value,
IEqualityComparer <T> ValueComparer = null)
{
if (SourcePipe == null)
{
return(false);
}
if (ValueComparer == null)
{
ValueComparer = EqualityComparer <T> .Default;
}
foreach (var Item in SourcePipe)
{
if (ValueComparer.Equals(Item, Value))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Use when extending Pipeline and setting the pipeline chain without making use of the constructor.
/// </summary>
/// <param name="IPipes">the ordered array of pipes to chain together into a pipeline.</param>
protected void SetPipes(params IPipe[] IPipes)
{
_Pipes = IPipes;
var _PipeNames = new List <String>();
var _Length = IPipes.Length;
_StartPipe = IPipes[0] as IStartPipe <S>;
if (_StartPipe == null)
{
throw new ArgumentException("The first Pipe must implement 'IStartPipe<" + typeof(S) + ">', but '" + IPipes[0].GetType() + "' was provided!");
}
_EndPipe = IPipes[_Length - 1] as IEndPipe <E>;
if (_EndPipe == null)
{
throw new ArgumentException("The last Pipe must implement 'IEndPipe<" + typeof(E) + ">', but '" + IPipes[_Length - 1].GetType() + "' was provided!");
}
_PipeNames.Add(_StartPipe.ToString());
Type[] _GenericArguments = null;
Type _Consumes;
Type _Emitts;
#if SILVERLIGHT
Type _GenericIPipeInterface = _StartPipe.GetType().GetInterface("IPipe`2", false);
#else
Type _GenericIPipeInterface = _StartPipe.GetType().GetInterface("IPipe`2");
#endif
if (_GenericIPipeInterface == null)
{
throw new ArgumentException("IPipe<?,?> expected!");
}
_Emitts = _GenericIPipeInterface.GetGenericArguments()[1];
for (var i = 1; i < _Length; i++)
{
#if SILVERLIGHT
_GenericArguments = IPipes[i].GetType().GetInterface("IPipe`2", false).GetGenericArguments();
#else
_GenericArguments = IPipes[i].GetType().GetInterface("IPipe`2").GetGenericArguments();
#endif
_Consumes = _GenericArguments[0];
if (_Consumes != _Emitts)
{
throw new ArgumentException(IPipes[i - 1].GetType() + " emitts other objects than " + IPipes[i].GetType() + " consumes!");
}
_Emitts = _GenericArguments[1];
IPipes[i].SetSource(IPipes[i - 1]);
_PipeNames.Add(IPipes[i].ToString());
}
if (_InternalEnumerator != null)
{
IPipes[0].SetSource(_InternalEnumerator);
}
_PipelineString = _PipeNames.ToString();
}
/// <summary>
/// Creates an new random filter pipe using the given pipe as element source.
/// </summary>
/// <param name="SourcePipe">A pipe as element source.</param>
/// <param name="Bias">The bias.</param>
/// <param name="Random">An optional source of randomness.</param>
public RandomFilterPipe(IEndPipe <S> SourcePipe, Double Bias, Random Random = null)
: base(SourcePipe)
{
this.Bias = Bias;
this.Random = (Random == null) ? new Random(DateTime.Now.Millisecond) : Random;
}
/// <summary>
/// Starts with 1!
/// </summary>
public static WhereCountedPipe <S> Where <S, E>(this IEndPipe <S> SourcePipe,
CountedPredicate <S> CountedInclude)
{
return(new WhereCountedPipe <S>(SourcePipe, CountedInclude));
}
public static WherePipe <S> Where <S, E>(this IEndPipe <S> SourcePipe,
Predicate <S> Include)
{
return(new WherePipe <S>(SourcePipe, Include));
}
/// <summary>
/// Starts with 1!
/// </summary>
public static ZipMergePipe <S1, S2, E> Zip <S1, S2, E>(this IEndPipe <S1> SourcePipe1,
IEndPipe <S2> SourcePipe2,
Func <S1, S2, UInt64, E> CountedZipDelegate)
{
return(new ZipMergePipe <S1, S2, E>(SourcePipe1, SourcePipe2, CountedZipDelegate));
}
public PathPipe(IEndPipe <S> SourcePipe)
: base(SourcePipe)
{
}
public EndPipeEnumerable(IEndPipe <E> EndPipe)
{
this.EndPipe = EndPipe;
}
/// <summary>
/// Creates a new StdDevPipe calculating a side effect that is the
/// sliding standard deviation and the average of the input.
/// </summary>
/// <param name="SourcePipe">A pipe as element source.</param>
public StdDevPipe(IEndPipe <Double> SourcePipe)
: base(SourcePipe, 0, 0)
{
this.Counter = 0;
}
public EndPipeEnumerator(IEndPipe <E> EndPipe)
{
this.EndPipe = EndPipe;
}
/// <summary>
/// The RangeFilter will only allow a sequential subset of its incoming
/// objects to be emitted to its output. This pipe can be provided -1 for
/// both its high and low range to denote a wildcard for high and/or low.
/// Note that -1 for both high and low is equivalent to the IdentityPipe.
/// </summary>
/// <param name="Low">The minimal value.</param>
/// <param name="High">The maximum value.</param>
/// <param name="IEnumerable">An enumeration of objects of type S.</param>
/// <typeparam name="S">The type of the elements within the filter.</typeparam>
public static RangeFilterPipe <S> RangeFilter <S>(this IEndPipe <S> SourcePipe, Int32 Low, Int32 High)
{
return(new RangeFilterPipe <S>(SourcePipe, Low, High));
}
public static EndPipeEnumerable <E> AsEnumerable <E>(this IEndPipe <E> EndPipe)
{
return(new EndPipeEnumerable <E>(EndPipe));
}
