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;
}
