public static IReactivityModel Create(IModelUpdateSource updateSource) { return(new Impl(updateSource)); }
public Impl(IModelUpdateSource updateSource) { object moduleCacheLocker = new object(); mModuleCache = updateSource.Modules .ToObservableChangeSet(m => m.ModuleId) .Transform(CreateModule) .Synchronize(moduleCacheLocker) .AsObservableCache(); Modules = mModuleCache.Connect().SynchronizeSubscribe(moduleCacheLocker).Flatten().Select(chg => chg.Current); IObservable <IInstrumentedMethod> methods = updateSource.InstrumentedMethods .Select(CreateInstrumentedMethod) .Publish() .ConnectForEver(); object instrumentedMethodCacheLocker = new object(); mInstrumentedMethodCache = methods .ToObservableChangeSet(m => m.InstrumentedMethodId) .Synchronize(instrumentedMethodCacheLocker) .AsObservableCache(); InstrumentedMethods = mInstrumentedMethodCache.Connect().SynchronizeSubscribe(instrumentedMethodCacheLocker) .Flatten().Select(chg => chg.Current); object instrumentedCallsCacheLocker = new object(); mInstrumentedCallsCache = methods.SelectMany(m => m.InstrumentedCalls) .ToObservableChangeSet(c => c.InstrumentedCallId) .Synchronize(instrumentedCallsCacheLocker) .AsObservableCache(); InstrumentedCalls = mInstrumentedCallsCache.Connect().SynchronizeSubscribe(instrumentedCallsCacheLocker) .Flatten().Select(chg => chg.Current); object observableInstancesCacheLocker = new object(); mObservableInstancesCache = updateSource.ObservableInstances .ToObservableChangeSet(o => o.Created.SequenceId) .Transform(CreateObservableInstance) .Synchronize(observableInstancesCacheLocker) .AsObservableCache(); ObservableInstances = mObservableInstancesCache.Connect().SynchronizeSubscribe(observableInstancesCacheLocker) .Flatten().Select(chg => chg.Current); mSubscriptionsCache = updateSource.CreatedSubscriptions .ToObservableChangeSet(s => s.Subscribed.SequenceId) .Transform(CreateSubscription) .AsObservableCache(); mSubscriptionDisposalsCache = updateSource.DisposedSubscriptions .ToObservableChangeSet(d => d.SubscriptionId) .Transform(d => new UnsubscribeEvent(d.Disposed)) .AsObservableCache(); mInstrumentedMethodsByModule = methods .GroupBy(m => m.Module.ModuleId) .ToObservableChangeSet(grp => grp.Key) .Transform(grp => grp.Replay().ConnectForEver()) .AsObservableCache(); mObservableInstancesByCall = updateSource.ObservableInstances .GroupBy(o => o.InstrumentedCallId) .ToObservableChangeSet(grp => grp.Key) .Transform(obses => obses.SelectMany(obs => mObservableInstancesCache.WatchValue(obs.Created.SequenceId).Take(1)).Replay().ConnectForEver()) .AsObservableCache(); mObservableInstanceInputsByOutput = updateSource.ObservableInstanceLinks .GroupBy(l => l.OutputId) .ToObservableChangeSet(grp => grp.Key) .Transform(links => links.SelectMany(link => mObservableInstancesCache.WatchValue(link.InputId).Take(1)).Replay().ConnectForEver()) .AsObservableCache(); mSubscriptionsByObservableInstance = updateSource.CreatedSubscriptions .GroupBy(s => s.ObservableId) .ToObservableChangeSet(grp => grp.Key) .Transform(subs => subs.SelectMany(sub => mSubscriptionsCache.WatchValue(sub.Subscribed.SequenceId).Take(1)).Replay().ConnectForEver()) .AsObservableCache(); mStreamEventsBySubscription = updateSource.StreamEvents .GroupBy(e => e.SubscriptionId) .ToObservableChangeSet(grp => grp.Key) .Transform(es => es.Select(CreateStreamEvent).Replay().ConnectForEver()) .AsObservableCache(); mTypeInfoCache = updateSource.Types .ToObservableChangeSet(t => t.TypeId) .AsObservableCache(); mObjectPropertiesInfoByObjectId = updateSource.ObjectPropertiesInfos .ToObservableChangeSet(info => info.ObjectId) .AsObservableCache(); var clientEvents = updateSource.ClientEvents.Replay(); clientEvents.Connect(); ClientEvents = clientEvents.AsObservable(); }
private DataFileConnectionModel(string dataFilePath, IReactivityModel model, IModelUpdateSource updateSource) { DataFilePath = dataFilePath; Model = model; mUpdateSource = updateSource; }