Example #1
0
            private Tuple <ManagedGroup <TObject, TKey, TGroupKey>, bool> GetCache(TGroupKey key)
            {
                var cache = _groupCache.Lookup(key);

                if (cache.HasValue)
                {
                    return(Tuple.Create(cache.Value, false));
                }

                var newcache = new ManagedGroup <TObject, TKey, TGroupKey>(key);

                _groupCache[key] = newcache;
                return(Tuple.Create(newcache, true));
            }
Example #2
0
 private bool Equals(ManagedGroup <TObject, TKey, TGroupKey> other)
 {
     return(EqualityComparer <TGroupKey> .Default.Equals(Key, other.Key));
 }
Example #3
0
        public IObservable <IGroupChangeSet <TObject, TKey, TGroupKey> > Run()
        {
            return(Observable.Create <IGroupChangeSet <TObject, TKey, TGroupKey> >
                   (
                       observer =>
            {
                var locker = new object();

                //create source group cache
                var sourceGroups = _source.Synchronize(locker)
                                   .Group(_groupSelector)
                                   .DisposeMany()
                                   .AsObservableCache();

                //create parent groups
                var parentGroups = _resultGroupSource.Synchronize(locker)
                                   .Transform(x =>
                {
                    //if child already has data, populate it.
                    var result = new ManagedGroup <TObject, TKey, TGroupKey>(x);
                    var child = sourceGroups.Lookup(x);
                    if (child.HasValue)
                    {
                        //dodgy cast but fine as a groups is always a ManagedGroup;
                        var group = (ManagedGroup <TObject, TKey, TGroupKey>)child.Value;
                        result.Update(updater => updater.Update(group.GetInitialUpdates()));
                    }
                    return result;
                })
                                   .DisposeMany()
                                   .AsObservableCache();

                //connect to each individual item and update the resulting group
                var updateFromcChilds = sourceGroups.Connect()
                                        .SubscribeMany(x => x.Cache.Connect().Subscribe(updates =>
                {
                    var groupToUpdate = parentGroups.Lookup(x.Key);
                    if (groupToUpdate.HasValue)
                    {
                        groupToUpdate.Value.Update(updater => updater.Update(updates));
                    }
                }))
                                        .DisposeMany()
                                        .Subscribe();

                var notifier = parentGroups
                               .Connect()
                               .Select(x =>
                {
                    var groups = x.Select(s => new Change <IGroup <TObject, TKey, TGroupKey>, TGroupKey>(s.Reason, s.Key, s.Current));
                    return new GroupChangeSet <TObject, TKey, TGroupKey>(groups);
                })
                               .SubscribeSafe(observer);

                return Disposable.Create(() =>
                {
                    notifier.Dispose();
                    sourceGroups.Dispose();
                    parentGroups.Dispose();
                    updateFromcChilds.Dispose();
                });
            }));
        }