public PropertySynchronization(INotifyValue <T> source, Action <T> target)
{
Source = source;
Target = target;
Source.ValueChanged += Source_ValueChanged;
}
/// <summary>
/// Initializes the job. The time taken here is measured.
/// </summary>
/// <param name="options">The benchmark options</param>
public override void Initialize(BenchmarkOptions options)
{
if (options.Incremental)
{
incrementalValue = Observable.Expression(Query(Benchmark.Root));
}
}
private void AttachItem(TItem item, INotifyValue <TKey> key)
{
var entry = new Entry(key, item, this);
Stack <Entry> entryStack;
if (!keys.TryGetValue(item, out entryStack))
{
entryStack = new Stack <Entry>();
keys.Add(item, entryStack);
}
entryStack.Push(entry);
var add = false;
ObservableGroup <TKey, TItem> group;
if (!groups.TryGetValue(key.Value, out group))
{
group = new ObservableGroup <TKey, TItem>(key.Value);
groups.Add(key.Value, group);
add = true;
}
group.ItemsInternal.Add(item);
key.ValueChanged += entry.KeyChanged;
if (add)
{
OnAddItem(group);
}
}
private INotifyValue <bool> AttachItem(T item)
{
if (isValueType || item != null)
{
TaggedObservableValue <bool, ItemMultiplicity> lambdaResult;
if (!lambdas.TryGetValue(item, out lambdaResult))
{
lambdaResult = Lambda.InvokeTagged(item, new ItemMultiplicity(item, 1));
lambdas.Add(item, lambdaResult);
lambdaResult.ValueChanged += LambdaChanged;
}
else
{
lambdaResult.Tag = lambdaResult.Tag.Increase();
}
return(lambdaResult);
}
else
{
nulls++;
if (nullCheck == null)
{
nullCheck = Lambda.Observe(default(T));
nullCheck.ValueChanged += NullCheckValueChanged;
}
return(nullCheck);
}
}
public Itemdata(INotifyValue <IEnumerable <TResult> > item, INotifyEnumerable <TResult> notifiable, int count)
: this()
{
Item = item;
Notifiable = notifiable;
Count = count;
}
public override void Initialize()
{
var computeAverage = Observable.Func(((int, int)tuple) => ((double)tuple.Item1) / tuple.Item2);
var recurse = Observable.Recurse <int, (int, int), (int, int)>((rec, index, tuple) => index >= root.Items.Count ? tuple : Add(rec(index + 1, tuple), root.Items[index].Value));
resultCache = Observable.Expression(() => computeAverage.Evaluate(recurse.Evaluate(0, ValueTuple.Create(0, 0))));
}
public static INotifyValue <T> AsReversableObserver <T>(INotifyValue <T> value, INotifyValue <Action <T> > reversableHandler)
{
if (reversableHandler == null)
{
throw new ArgumentNullException("reversableHandler");
}
return(value.AsReversable(reversableHandler.Value));
}
public OneWayLTRSynchronization(INotifyValue <TDepLeft> left, SynchronizationComputation <TLeft, TRight> computation, SynchronizationSingleDependency <TLeft, TRight, TDepLeft, TDepRight> parent)
{
Left = left;
Parent = parent;
Computation = computation;
Left.ValueChanged += Left_ValueChanged;
}
public OneWayRTLDependency(INotifyValue <TDepRight> right, SynchronizationComputation <TRight, TLeft> computation, SynchronizationSingleDependency <TLeft, TRight, TDepLeft, TDepRight> parent)
{
Right = right;
Parent = parent;
Computation = computation;
Right.ValueChanged += Left_ValueChanged;
}
public override void Initialize()
{
var computeAverage = Observable.Func(((int, int)tuple) => ((double)tuple.Item1) / tuple.Item2);
var recurse = Observable.Recurse <IItem, (int, int), (int, int)>((rec, item, tuple) => item == null ? tuple : Add(rec(item.Next, tuple), item.Value));
resultCache = Observable.Expression(() => computeAverage.Evaluate(recurse.Evaluate(root.Head, ValueTuple.Create(0, 0))));
resultCache.Successors.SetDummy();
}
public ObservableProxyExpression(INotifyValue <T> value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
this.value = value;
}
internal TaggedObservableValue <TResult, TTag> InvokeTagged <TTag>(INotifyValue <T1> input, TTag tag = default(TTag))
{
var parameters = new Dictionary <string, object>();
if (!isParameterFree)
{
parameters.Add(parameter1Name, input);
}
return(new TaggedObservableValue <TResult, TTag>(expression.ApplyParameters(parameters), tag));
}
public Dependency(ISynchronizationJob <TLeft, TRight> inner, SynchronizationComputation <TLeft, TRight> computation, SynchronizationDirection direction, INotifyValue <bool> tracker)
{
Inner = inner;
Computation = computation;
Direction = direction;
Tracker = tracker;
if (tracker.Value)
{
Current = Inner.Perform(Computation, Direction, Computation.SynchronizationContext);
}
Tracker.ValueChanged += Tracker_ValueChanged;
}
protected virtual void RegisterCollectionChanged <T>(INotifyValue <T> value)
{
if (value == null)
{
return;
}
var notifyCollection = value.Value as INotifyCollectionChanged;
if (notifyCollection != null)
{
notifyCollection.CollectionChanged += notifyCollection_CollectionChanged;
}
value.ValueChanged += value_ValueChanged;
}
private void NotifySource(CollectionChangedNotificationResult <T> sourceChange, List <T> added, List <T> removed)
{
if (sourceChange.RemovedItems != null)
{
foreach (var item in sourceChange.RemovedItems)
{
if (isValueType || item != null)
{
TaggedObservableValue <bool, ItemMultiplicity> lambdaResult;
if (lambdaInstances.TryGetValue(item, out lambdaResult))
{
if (lambdaResult.Value)
{
removed.Add(lambdaResult.Tag.Item);
}
lambdaResult.Tag = lambdaResult.Tag.Decrease();
if (lambdaResult.Tag.Multiplicity == 0)
{
lambdaResult.Successors.Unset(this);
lambdaInstances.Remove(item);
}
}
}
else
{
nulls--;
if (nulls == 0)
{
nullCheck.Successors.Unset(this);
nullCheck = null;
}
removed.Add(default(T));
}
}
}
if (sourceChange.AddedItems != null)
{
foreach (var item in sourceChange.AddedItems)
{
var lambdaResult = AttachItem(item);
if (lambdaResult.Value)
{
added.Add(item);
}
}
}
}
public static INotifyValue <T> AsReversable <T>(this INotifyValue <T> value, Action <T> reversableHandler)
{
if (reversableHandler == null)
{
throw new ArgumentNullException("reversableHandler");
}
var expression = value as INotifyExpression <T>;
if (expression != null)
{
return(new ReversableProxyExpression <T>(expression, reversableHandler));
}
else
{
return(new ReversableProxyValue <T, INotifyValue <T> >(value, reversableHandler));
}
}
public GuardedSynchronization(SynchronizationComputation <TLeft, TRight> computation, Func <SynchronizationComputation <TLeft, TRight>, IDisposable> func, INotifyValue <bool> guard)
{
Computation = computation;
Func = func;
Guard = guard;
if (guard.Value)
{
Current = func(computation);
if (Current != null)
{
Computation.Dependencies.Add(Current);
}
}
Guard.ValueChanged += Guard_ValueChanged;
}
public ObservableProxyExpression(INotifyValue <T> value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
this.value = value;
Successors.Attached += (obj, e) =>
{
foreach (var dep in Dependencies)
{
dep.Successors.Set(this);
}
};
Successors.Detached += (obj, e) =>
{
foreach (var dep in Dependencies)
{
dep.Successors.Unset(this);
}
};
}
public static INotifyValue <int> FacProxy(INotifyValue <int> n)
{
return(fac.Observe(n));
}
private void SourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Move)
{
return;
}
if (e.Action != NotifyCollectionChangedAction.Reset)
{
if (e.OldItems != null)
{
var removed = new List <T>();
foreach (T item in e.OldItems)
{
TaggedObservableValue <bool, ItemMultiplicity> lambdaResult;
if (isValueType || item != null)
{
if (lambdas.TryGetValue(item, out lambdaResult))
{
if (lambdaResult.Value)
{
removed.Add(lambdaResult.Tag.Item);
}
lambdaResult.Tag = lambdaResult.Tag.Decrease();
if (lambdaResult.Tag.Multiplicity == 0)
{
lambdaResult.ValueChanged -= LambdaChanged;
lambdaResult.Detach();
lambdas.Remove(item);
}
}
else
{
//throw new InvalidOperationException();
}
}
else
{
nulls--;
if (nulls == 0)
{
nullCheck.Detach();
nullCheck = null;
}
removed.Add(default(T));
}
}
OnRemoveItems(removed);
}
if (e.NewItems != null)
{
var added = new List <T>();
foreach (T item in e.NewItems)
{
var lambdaResult = AttachItem(item);
if (lambdaResult.Value)
{
added.Add(item);
}
}
OnAddItems(added);
}
}
else
{
DetachSource();
OnCleared();
}
}
public static INotifyValue<TypeA.IA> AElementWithName(INotifyValue<string> name)
{
return aElementWithNameFunc.Observe(name);
}
public Monitor(INotifyValue <bool> instantiationMonitor, SynchronizationComputation <TLeft, TRight> computation)
{
InstantiationMonitor = instantiationMonitor;
Computation = computation;
}
public override void Initialize()
{
resultCache = Observable.Expression(() => root.Items.Average(i => i.Value));
}
public static INotifyValue<int> FacProxy(INotifyValue<int> n)
{
return fac.Observe(n);
}
public static INotifyValue<bool> TestNameOfAElement(INotifyValue<string> name, INotifyValue<TypeA.IA> element)
{
return testNameOfAElementFunc.Observe(name, element);
}
public INotifyValue <TResult> Observe(INotifyValue <T1> in1)
{
return(InnerFunc.Observe(Func, in1));
}
public static INotifyValue <bool> Member2FemaleFilter(INotifyValue <Families.IMember> self)
{
return(Member2FemaleFilterFunc.Observe(self));
}
public static INotifyValue <string> FamilyName(INotifyValue <Families.IMember> self)
{
return(familyNameFunc.Observe(self));
}
public static INotifyValue <bool> IsFemale(INotifyValue <Families.IMember> self)
{
return(IsFemaleFunc.Observe(self));
}
public static INotifyValue <TypeA.IA> AElementWithName(INotifyValue <string> name)
{
return(aElementWithNameFunc.Observe(name));
}
public static INotifyValue <bool> TestNameOfAElement(INotifyValue <string> name, INotifyValue <TypeA.IA> element)
{
return(testNameOfAElementFunc.Observe(name, element));
}
public static INotifyValue<bool> PortA2OutPortBFilter(INotifyValue<TypeA.IPortA> self)
{
return portA2OutPortBFilterFunc.Observe(self);
}
public SubSourcePair(INotifyValue <IEnumerable <TIntermediate> > subSource, TSource item, ObservableSelectMany <TSource, TIntermediate, TResult> parent)
{
SubSource = subSource;
Item = item;
Parent = parent;
}
public ChangeRecorder(INotifyValue <T> value)
{
Value = value;
Value.ValueChanged += Value_ValueChanged;
}
