public JoinExpression(IEnumerableExpression <TOuter> outer, IEnumerable <TInner> inner, Expression <Func <TOuter, TKey> > outerKeySelector, Func <TOuter, TKey> outerKeySelectorCompiled, Expression <Func <TInner, TKey> > innerKeySelector, Func <TInner, TKey> innerKeySelectorCompiled, Expression <Func <TOuter, TInner, TResult> > resultSelector, Func <TOuter, TInner, TResult> resultSelectorCompiled, IEqualityComparer <TKey> comparer)
{
if (outer == null)
{
throw new ArgumentNullException("outer");
}
if (inner == null)
{
throw new ArgumentNullException("inner");
}
if (outerKeySelector == null)
{
throw new ArgumentNullException("outerKeySelector");
}
if (innerKeySelector == null)
{
throw new ArgumentNullException("innerKeySelector");
}
if (resultSelector == null)
{
throw new ArgumentNullException("resultSelector");
}
Source = outer;
Inner = inner;
OuterKeySelector = outerKeySelector;
OuterKeySelectorCompiled = outerKeySelectorCompiled ?? ExpressionCompileRewriter.Compile(outerKeySelector);
InnerKeySelector = innerKeySelector;
InnerKeySelectorCompiled = innerKeySelectorCompiled ?? ExpressionCompileRewriter.Compile(innerKeySelector);
ResultSelector = resultSelector;
ResultSelectorCompiled = resultSelectorCompiled ?? ExpressionCompileRewriter.Compile(resultSelector);
Comparer = comparer;
}
private void AddElements(IEnumerableExpression <T> elements)
{
if (elements != null)
{
if (Incremental)
{
var incElements = elements.AsNotifiable();
foreach (var node in incElements)
{
nodes.Add(node, new EulerVertex(node, this));
}
foreach (var vertex in nodes.Values)
{
CreateEdgesFor(vertex);
}
incElements.Successors.Set(this);
this.incElements = incElements;
}
else
{
foreach (var node in elements)
{
nodes.Add(node, new EulerVertex(node, this));
}
foreach (var vertex in nodes.Values)
{
CreateEdgesFor(vertex);
}
}
}
}
public override Func <bool> CreateCheck(IEnumerableExpression <Node> nodes, Node start, Node target)
{
var holm = new HolmConnectivity <Node>(n => n.Edges, true, nodes);
var inc = Observable.Expression(() => holm.AreConnected(start, target));
return(() => inc.Value);
}
public ProcessColumn(int column, IEnumerableExpression <ProcessWell> wells)
{
Column = column;
Samples = wells;
AllSamples = wells.Select(w => w.Sample);
AnyValidSample = _anyNonErrorSample.Observe(this);
AnyValidSample.Successors.SetDummy();
}
public ProcessPlate(string name, IEnumerableExpression <ProcessColumn> columns)
{
Name = name;
Columns = columns;
AllSamples = columns.SelectMany(c => c.AllSamples);
AnyValidSample = _hasValidSample.Observe(this);
AnyValidSample.Successors.SetDummy();
}
/// <summary>
/// This method encapsulates the query. It is used both for the incremental version as well as the batch version
/// </summary>
/// <param name="employees">The collection of employees</param>
/// <returns>A query of employees</returns>
private static IEnumerableExpression <Employee> CreateQuery(IEnumerableExpression <Employee> employees)
{
return(from employee in employees
group employee by employee.Team into team
let teamMax = team.Max(member => member.WorkItems)
from collegue in team
where 4 * collegue.WorkItems < teamMax
select collegue);
}
public CustomCollection(IEnumerableExpression <T> inner)
{
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
Inner = inner;
}
public OfTypeExpression(IEnumerableExpression source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
Source = source;
}
/// <summary>
/// This method encapsulates the query. It is used both for the incremental version as well as the batch version
/// </summary>
/// <param name="employees">The collection of employees</param>
/// <returns>A query of employees</returns>
private static IEnumerableExpression<Employee> CreateQuery(IEnumerableExpression<Employee> employees)
{
return from employee in employees
group employee by employee.Team into team
let teamMax = team.Max(member => member.WorkItems)
from collegue in team
where 4 * collegue.WorkItems < teamMax
select collegue;
}
public JobsOfProtocolStep(string protocolStepName, IEnumerableExpression <IJob> jobs, ITransformationContext context) : this(context)
{
_protocolStepName = protocolStepName;
foreach (var item in jobs)
{
Jobs.Add(item);
}
}
public DistinctExpression(IEnumerableExpression <T> source, IEqualityComparer <T> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
Source = source;
Comparer = comparer ?? EqualityComparer <T> .Default;
}
public void InitializeContext(IEnumerableExpression <ISample> samples, ISynchronizationContext context)
{
context.Data.Add(_platesKey, samples
.ChunkIndexed(8, (samples, column) => new ProcessColumn(column, samples.Select(tuple => new ProcessWell(tuple.Item2 % 96, tuple.Item1))))
.Chunk(12, (columns, plateIndex) => new ProcessPlate($"Plate{plateIndex+1:00}", columns))
.AsNotifiable());
context.Data.Add(_tubesKey, samples
.ChunkIndexed(16, (samples, tubeIndex) => new Tubes($"Tube{tubeIndex+1:00}", samples.Select(tuple => new ProcessWell(tuple.Item2 % 16, tuple.Item1))))
.AsNotifiable());
}
public ConcatExpression(IEnumerableExpression <T> source, IEnumerable <T> other)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (other == null)
{
throw new ArgumentNullException("other");
}
Source = source;
Other = other;
}
public SetExpression(IEnumerableExpression <T> source, IEnumerable <T> other, IEqualityComparer <T> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (other == null)
{
throw new ArgumentNullException("other");
}
Source = source;
Other = other;
Comparer = comparer ?? EqualityComparer <T> .Default;
}
public WhereExpression(IEnumerableExpression <T> source, Expression <Func <T, bool> > predicate, Func <T, bool> predicateCompiled)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (predicate == null)
{
throw new ArgumentNullException("selector");
}
if (predicateCompiled == null)
{
predicateCompiled = ExpressionCompileRewriter.Compile(predicate);
}
Source = source;
PredicateExpression = predicate;
PredicateCompiled = predicateCompiled;
}
public SelectExpression(IEnumerableExpression <TSource> source, Expression <Func <TSource, TResult> > selector, Func <TSource, TResult> selectorCompiled)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (selectorCompiled == null)
{
selectorCompiled = ExpressionCompileRewriter.Compile(selector);
}
Source = source;
SelectorExpression = selector;
SelectorCompiled = selectorCompiled;
}
public GroupByExpression(IEnumerableExpression <TElement> source, Expression <Func <TElement, TKey> > keySelector, Func <TElement, TKey> keySelectorCompiled, IEqualityComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
if (keySelectorCompiled == null)
{
keySelectorCompiled = ExpressionCompileRewriter.Compile(keySelector);
}
Source = source;
Predicate = keySelector;
PredicateCompiled = keySelectorCompiled;
Comparer = comparer ?? EqualityComparer <TKey> .Default;
}
public SelectManyExpression(IEnumerableExpression <TSource> source, Expression <Func <TSource, IEnumerable <TIntermediate> > > func, Func <TSource, IEnumerable <TIntermediate> > funcCompiled, Expression <Func <TSource, TIntermediate, TResult> > resultSelector, Func <TSource, TIntermediate, TResult> resultSelectorCompiled)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (func == null)
{
throw new ArgumentNullException("func");
}
if (resultSelector == null)
{
throw new ArgumentNullException("resultSelector");
}
Source = source;
FuncExpression = func;
FuncCompiled = funcCompiled ?? ExpressionCompileRewriter.Compile(func);
ResultSelector = resultSelector;
ResultSelectorCompiled = resultSelectorCompiled ?? ExpressionCompileRewriter.Compile(resultSelector);
}
private void AddElements(IEnumerableExpression <T> elements)
{
if (elements != null)
{
if (Incremental)
{
var incElements = elements.AsNotifiable();
foreach (var node in incElements)
{
GetOrCreate(node, true);
}
incElements.CollectionChanged += RootElementsChanged;
this.incElements = incElements;
}
else
{
foreach (var node in elements)
{
GetOrCreate(node, true);
}
}
}
}
public static INotifyValue <int> SumLambdaIntExpression <TSource>(IEnumerableExpression <TSource> source, Expression <Func <TSource, int> > selector)
{
return(SumInt(source.AsNotifiable().Select(selector)));
}
protected override bool ParseExpression(ParseContext context, IAstNode parent)
{
this.EnumerableExpression = new EnumerableExpression();
return(this.EnumerableExpression.Parse(context, this));
}
public static ObservableLambdaAny <TSource> CreateExpression(IEnumerableExpression <TSource> source, Expression <Func <TSource, bool> > selector)
{
return(new ObservableLambdaAny <TSource>(source.AsNotifiable(), selector));
}
public static ObservableAny <TSource> CreateExpression(IEnumerableExpression <TSource> source)
{
return(new ObservableAny <TSource>(source.AsNotifiable()));
}
public static ObservableSingleOrDefault <TSource> CreateExpressionForPredicate2(IEnumerableExpression <TSource> source, Expression <Func <TSource, bool> > predicate, Func <TSource, bool> predicateCompiled)
{
return(CreateExpressionForPredicate(source, predicate));
}
public static ObservableSingleOrDefault <TSource> CreateExpressionForPredicate(IEnumerableExpression <TSource> source, Expression <Func <TSource, bool> > predicate)
{
return(new ObservableSingleOrDefault <TSource>(source.AsNotifiable().Where(predicate)));
}
public static ObservableFirstOrDefault <TSource> CreateExpression(IEnumerableExpression <TSource> source)
{
return(Create(source.AsNotifiable()));
}
public static INotifyValue <decimal?> SumLambdaNullableDecimalExpression <TSource>(IEnumerableExpression <TSource> source, Expression <Func <TSource, decimal?> > selector)
{
return(SumNullableDecimal(source.AsNotifiable().Select(selector)));
}
public static INotifyValue <float?> SumLambdaNullableFloatExpression <TSource>(IEnumerableExpression <TSource> source, Expression <Func <TSource, float?> > selector)
{
return(SumNullableFloat(source.AsNotifiable().Select(selector)));
}
public static INotifyValue <double> SumLambdaDoubleExpression <TSource>(IEnumerableExpression <TSource> source, Expression <Func <TSource, double> > selector)
{
return(SumDouble(source.AsNotifiable().Select(selector)));
}
private static Expression<Func<bool>> CreateConnectivityAnalysis(IEnumerableExpression<Employee> employees, Employee a, Employee b)
{
return () => Connectivity<Employee>.Create(e => e.Knows, employees).AreConnected(a, b);
}
public static INotifyValue <decimal?> SumNullableDecimalExpression(IEnumerableExpression <decimal?> source)
{
return(SumNullableDecimal(source.AsNotifiable()));
}
public static INotifyValue <long> SumLambdaLongExpression <TSource>(IEnumerableExpression <TSource> source, Expression <Func <TSource, long> > selector)
{
return(SumLong(source.AsNotifiable().Select(selector)));
}
protected override bool ParseExpression(ParseContext context, IAstNode parent) {
this.EnumerableExpression = new EnumerableExpression();
return this.EnumerableExpression.Parse(context, this);
}
