com.fofx.observething 1.0.0 → 1.1.0

package/Runtime/Implementations/ObservableBase.cs

@@ -1,173 +1,173 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ObserveThing
-{
-    public interface IOperation
-    {
-        IObservable<IOperation> source { get; }
-    }
-
-    public abstract class ObservableBase<TObserver, TOperation> : IObservable<IOperation>, IDisposable
-        where TObserver : IObserverBase
-        where TOperation : IOperation
-    {
-        private class ObserverData : IPendingObserver, IDisposable
-        {
-            public IObserverBase observer { get; }
-            public bool immediate { get; }
-            public uint priority { get; }
-            public bool priorityAllocated { get; }
-            public bool disposed { get; private set; }
-
-            private Queue<TOperation> _pendingOperations = new Queue<TOperation>();
-            private Action<TOperation> _sendOperation;
-            private Action<ObserverData> _onDispose;
-
-            public ObserverData(IObserverBase observer, bool immediate, uint priority, bool priorityAllocated, Action<TOperation> sendOperation, Action<ObserverData> onDispose)
-            {
-                this.observer = observer;
-                this.immediate = immediate;
-                this.priority = priority;
-                this.priorityAllocated = priorityAllocated;
-
-                _sendOperation = sendOperation;
-                _onDispose = onDispose;
-            }
-
-            public void EnqueuePendingOperation(TOperation operation)
-            {
-                _pendingOperations.Enqueue(operation);
-            }
-
-            public void SendNext()
-            {
-                if (_pendingOperations.Count == 0)
-                    return;
-
-                try
-                {
-                    _sendOperation(_pendingOperations.Dequeue());
-                }
-                catch (Exception exc)
-                {
-                    observer.OnError(exc);
-                }
-            }
-
-            public void Dispose()
-            {
-                if (disposed)
-                    return;
-
-                disposed = true;
-
-                _onDispose?.Invoke(this);
-
-                observer.OnDispose();
-            }
-        }
-
-        public ObservationContext context { get; protected set; }
-        public bool disposed { get; private set; }
-
-        private List<ObserverData> _observers = new List<ObserverData>();
-
-        public ObservableBase(ObservationContext context)
-        {
-            this.context = context ?? Settings.DefaultObservationContext;
-        }
-
-        private void HandleObserverDisposed(ObserverData data)
-        {
-            if (disposed)
-                return;
-
-            if (!_observers.Remove(data))
-                return;
-
-            if (data.priorityAllocated)
-                context.DeallocateObserverPriority(data.priority);
-        }
-
-        protected void EnqueuePendingOperation(TOperation operation)
-        {
-            if (disposed)
-                throw new ObjectDisposedException(GetType().Name);
-
-            if (_observers.Count == 0)
-                return;
-
-            foreach (var observer in _observers)
-            {
-                observer.EnqueuePendingOperation(operation);
-                context.RegisterPendingObserver(observer);
-            }
-
-            context.NotifyPendingObserversIfNecessary();
-        }
-
-        protected virtual void DisposeInternal() { }
-
-        public void OnError(Exception error)
-        {
-            foreach (var observer in _observers.OrderByDescending(x => x.immediate).ThenBy(x => x.priority))
-                observer.observer.OnError(error);
-        }
-
-        protected abstract IEnumerable<TOperation> GetInitializationOperations();
-
-        protected IDisposable AddObserver(TObserver observer, bool immediate, uint? priority)
-            => AddObserverInternal(observer, immediate, priority, op => SendOperation(observer, op));
-
-        private IDisposable AddObserverInternal(IObserverBase observer, bool immediate, uint? priority, Action<TOperation> sendOperation)
-        {
-            if (disposed)
-                throw new ObjectDisposedException(GetType().Name);
-
-            var observerData = new ObserverData(
-                observer,
-                immediate,
-                priority ?? context.AllocateObserverPriority(),
-                priority == null,
-                sendOperation,
-                HandleObserverDisposed
-            );
-
-            // do this after calling OnFirstObserverAdded so any resulting operations won't be queued (they'll be reflected in GetInitializationOperations)
-            _observers.Add(observerData);
-
-            foreach (var op in GetInitializationOperations())
-                sendOperation(op);
-
-            return observerData;
-        }
-
-        protected abstract void SendOperation(TObserver observer, TOperation operation);
-
-        public virtual IDisposable Subscribe(TObserver observer, bool immediate = default, uint? priority = default)
-            => AddObserverInternal(observer, immediate, priority, op => SendOperation(observer, op));
-
-        public virtual IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = default, uint? priority = default)
-            => AddObserverInternal(observer, immediate, priority, op => observer.OnNext(op));
-
-        public void Dispose()
-        {
-            if (disposed)
-                return;
-
-            disposed = true;
-
-            foreach (var observer in _observers.OrderByDescending(x => x.immediate).ThenBy(x => x.priority))
-            {
-                observer.Dispose();
-                context.DeallocateObserverPriority(observer.priority);
-            }
-
-            _observers.Clear();
-
-            DisposeInternal();
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ObserveThing
+{
+    public interface IOperation
+    {
+        IObservable<IOperation> source { get; }
+    }
+
+    public abstract class ObservableBase<TObserver, TOperation> : IObservable<IOperation>, IDisposable
+        where TObserver : IObserverBase
+        where TOperation : IOperation
+    {
+        private class ObserverData : IPendingObserver, IDisposable
+        {
+            public IObserverBase observer { get; }
+            public bool immediate { get; }
+            public uint priority { get; }
+            public bool priorityAllocated { get; }
+            public bool disposed { get; private set; }
+
+            private Queue<TOperation> _pendingOperations = new Queue<TOperation>();
+            private Action<TOperation> _sendOperation;
+            private Action<ObserverData> _onDispose;
+
+            public ObserverData(IObserverBase observer, bool immediate, uint priority, bool priorityAllocated, Action<TOperation> sendOperation, Action<ObserverData> onDispose)
+            {
+                this.observer = observer;
+                this.immediate = immediate;
+                this.priority = priority;
+                this.priorityAllocated = priorityAllocated;
+
+                _sendOperation = sendOperation;
+                _onDispose = onDispose;
+            }
+
+            public void EnqueuePendingOperation(TOperation operation)
+            {
+                _pendingOperations.Enqueue(operation);
+            }
+
+            public void SendNext()
+            {
+                if (_pendingOperations.Count == 0)
+                    return;
+
+                try
+                {
+                    _sendOperation(_pendingOperations.Dequeue());
+                }
+                catch (Exception exc)
+                {
+                    observer.OnError(exc);
+                }
+            }
+
+            public void Dispose()
+            {
+                if (disposed)
+                    return;
+
+                disposed = true;
+
+                _onDispose?.Invoke(this);
+
+                observer.OnDispose();
+            }
+        }
+
+        public ObservationContext context { get; protected set; }
+        public bool disposed { get; private set; }
+
+        private List<ObserverData> _observers = new List<ObserverData>();
+
+        public ObservableBase(ObservationContext context)
+        {
+            this.context = context ?? Settings.DefaultObservationContext;
+        }
+
+        private void HandleObserverDisposed(ObserverData data)
+        {
+            if (disposed)
+                return;
+
+            if (!_observers.Remove(data))
+                return;
+
+            if (data.priorityAllocated)
+                context.DeallocateObserverPriority(data.priority);
+        }
+
+        protected void EnqueuePendingOperation(TOperation operation)
+        {
+            if (disposed)
+                throw new ObjectDisposedException(GetType().Name);
+
+            if (_observers.Count == 0)
+                return;
+
+            foreach (var observer in _observers)
+            {
+                observer.EnqueuePendingOperation(operation);
+                context.RegisterPendingObserver(observer);
+            }
+
+            context.NotifyPendingObserversIfNecessary();
+        }
+
+        protected virtual void DisposeInternal() { }
+
+        public void OnError(Exception error)
+        {
+            foreach (var observer in _observers.OrderByDescending(x => x.immediate).ThenBy(x => x.priority))
+                observer.observer.OnError(error);
+        }
+
+        protected abstract IEnumerable<TOperation> GetInitializationOperations();
+
+        protected IDisposable AddObserver(TObserver observer, bool immediate, uint? priority)
+            => AddObserverInternal(observer, immediate, priority, op => SendOperation(observer, op));
+
+        private IDisposable AddObserverInternal(IObserverBase observer, bool immediate, uint? priority, Action<TOperation> sendOperation)
+        {
+            if (disposed)
+                throw new ObjectDisposedException(GetType().Name);
+
+            var observerData = new ObserverData(
+                observer,
+                immediate,
+                priority ?? context.AllocateObserverPriority(),
+                priority == null,
+                sendOperation,
+                HandleObserverDisposed
+            );
+
+            // do this after calling OnFirstObserverAdded so any resulting operations won't be queued (they'll be reflected in GetInitializationOperations)
+            _observers.Add(observerData);
+
+            foreach (var op in GetInitializationOperations())
+                sendOperation(op);
+
+            return observerData;
+        }
+
+        protected abstract void SendOperation(TObserver observer, TOperation operation);
+
+        public virtual IDisposable Subscribe(TObserver observer, bool immediate = default, uint? priority = default)
+            => AddObserverInternal(observer, immediate, priority, op => SendOperation(observer, op));
+
+        public virtual IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = default, uint? priority = default)
+            => AddObserverInternal(observer, immediate, priority, op => observer.OnNext(op));
+
+        public void Dispose()
+        {
+            if (disposed)
+                return;
+
+            disposed = true;
+
+            foreach (var observer in _observers.OrderByDescending(x => x.immediate).ThenBy(x => x.priority))
+            {
+                observer.Dispose();
+                context.DeallocateObserverPriority(observer.priority);
+            }
+
+            _observers.Clear();
+
+            DisposeInternal();
+        }
+    }
 }

package/Runtime/Implementations/ObservableBase.cs.meta

@@ -1,2 +1,2 @@
-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: 009be06d9cf6e6c4fa2d65ff88b20888

package/Runtime/Implementations/ObservableCollection.cs

@@ -1,141 +1,141 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ObserveThing
-{
-    public interface ICollectionOp : IOperation
-    {
-        object element { get; }
-        uint elementId { get; }
-        bool isRemove { get; }
-    }
-
-    public struct CollectionOp<T> : ICollectionOp
-    {
-        public IObservable<IOperation> source { get; set; }
-        public T element { get; set; }
-        public uint elementId { get; set; }
-        public bool isRemove { get; set; }
-
-        object ICollectionOp.element => element;
-    }
-
-    public class ObservableCollection<T> : ObservableBase<ICollectionObserver<T>, CollectionOp<T>>, ICollectionObservable<T>, IEnumerable<T>
-    {
-        IEnumerator<T> IEnumerable<T>.GetEnumerator()
-            => _collection.Values.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator()
-            => _collection.Values.GetEnumerator();
-
-        public int Count => _collection.Count;
-
-        private Dictionary<uint, T> _collection = new Dictionary<uint, T>();
-
-        private CollectionIdProvider _idProvider;
-
-        public ObservableCollection() : this(default, default(IEnumerable<T>)) { }
-        public ObservableCollection(params T[] value) : this(default, (IEnumerable<T>)value) { }
-        public ObservableCollection(IEnumerable<T> value) : this(default, value) { }
-
-        public ObservableCollection(ObservationContext context) : this(context, default(IEnumerable<T>)) { }
-        public ObservableCollection(ObservationContext context, params T[] value) : this(context, (IEnumerable<T>)value) { }
-        public ObservableCollection(ObservationContext context, IEnumerable<T> value) : base(context)
-        {
-            _idProvider = new CollectionIdProvider(_collection.ContainsKey);
-
-            if (value == null)
-                return;
-
-            foreach (var element in value)
-            {
-                var id = _idProvider.GetUnusedId();
-                _collection.Add(id, element);
-            }
-        }
-
-        public bool Contains(T element)
-            => _collection.ContainsValue(element);
-
-        public uint Add(T element)
-        {
-            var id = _idProvider.GetUnusedId();
-            Add(id, element);
-            return id;
-        }
-
-        public void Add(uint id, T element)
-        {
-            _collection.Add(id, element);
-            EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = id, element = element, isRemove = false });
-        }
-
-        public bool Remove(T element)
-        {
-            var id = default(uint);
-            var found = false;
-
-            foreach (var kvp in _collection)
-            {
-                if (!Equals(element, kvp.Value))
-                    continue;
-
-                id = kvp.Key;
-                found = true;
-                break;
-            }
-
-            if (!found)
-                return false;
-
-            return Remove(id);
-        }
-
-        public bool Remove(uint id)
-        {
-            if (!_collection.TryGetValue(id, out var element))
-                return false;
-
-            _collection.Remove(id);
-            EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = id, element = element, isRemove = true });
-            return true;
-        }
-
-        public void Clear()
-        {
-            foreach (var kvp in _collection.ToArray())
-            {
-                _collection.Remove(kvp.Key);
-                EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = kvp.Key, element = kvp.Value, isRemove = true });
-            }
-        }
-
-        protected override IEnumerable<CollectionOp<T>> GetInitializationOperations()
-        {
-            foreach (var elementData in _collection)
-                yield return new CollectionOp<T>() { source = this, element = elementData.Value, elementId = elementData.Key, isRemove = false };
-        }
-
-        protected override void SendOperation(ICollectionObserver<T> observer, CollectionOp<T> operation)
-        {
-            if (operation.isRemove)
-            {
-                observer.OnRemove(operation.elementId, operation.element);
-            }
-            else
-            {
-                observer.OnAdd(operation.elementId, operation.element);
-            }
-        }
-
-        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
-            => Subscribe(new CollectionObserver<T>(
-                onAdd: (id, element) => observer.OnAdd(id, element),
-                onRemove: (id, element) => observer.OnRemove(id, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-    }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ObserveThing
+{
+    public interface ICollectionOp : IOperation
+    {
+        object element { get; }
+        uint elementId { get; }
+        bool isRemove { get; }
+    }
+
+    public struct CollectionOp<T> : ICollectionOp
+    {
+        public IObservable<IOperation> source { get; set; }
+        public T element { get; set; }
+        public uint elementId { get; set; }
+        public bool isRemove { get; set; }
+
+        object ICollectionOp.element => element;
+    }
+
+    public class ObservableCollection<T> : ObservableBase<ICollectionObserver<T>, CollectionOp<T>>, ICollectionObservable<T>, IEnumerable<T>
+    {
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+            => _collection.Values.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator()
+            => _collection.Values.GetEnumerator();
+
+        public int Count => _collection.Count;
+
+        private Dictionary<uint, T> _collection = new Dictionary<uint, T>();
+
+        private CollectionIdProvider _idProvider;
+
+        public ObservableCollection() : this(default, default(IEnumerable<T>)) { }
+        public ObservableCollection(params T[] value) : this(default, (IEnumerable<T>)value) { }
+        public ObservableCollection(IEnumerable<T> value) : this(default, value) { }
+
+        public ObservableCollection(ObservationContext context) : this(context, default(IEnumerable<T>)) { }
+        public ObservableCollection(ObservationContext context, params T[] value) : this(context, (IEnumerable<T>)value) { }
+        public ObservableCollection(ObservationContext context, IEnumerable<T> value) : base(context)
+        {
+            _idProvider = new CollectionIdProvider(_collection.ContainsKey);
+
+            if (value == null)
+                return;
+
+            foreach (var element in value)
+            {
+                var id = _idProvider.GetUnusedId();
+                _collection.Add(id, element);
+            }
+        }
+
+        public bool Contains(T element)
+            => _collection.ContainsValue(element);
+
+        public uint Add(T element)
+        {
+            var id = _idProvider.GetUnusedId();
+            Add(id, element);
+            return id;
+        }
+
+        public void Add(uint id, T element)
+        {
+            _collection.Add(id, element);
+            EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = id, element = element, isRemove = false });
+        }
+
+        public bool Remove(T element)
+        {
+            var id = default(uint);
+            var found = false;
+
+            foreach (var kvp in _collection)
+            {
+                if (!Equals(element, kvp.Value))
+                    continue;
+
+                id = kvp.Key;
+                found = true;
+                break;
+            }
+
+            if (!found)
+                return false;
+
+            return Remove(id);
+        }
+
+        public bool Remove(uint id)
+        {
+            if (!_collection.TryGetValue(id, out var element))
+                return false;
+
+            _collection.Remove(id);
+            EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = id, element = element, isRemove = true });
+            return true;
+        }
+
+        public void Clear()
+        {
+            foreach (var kvp in _collection.ToArray())
+            {
+                _collection.Remove(kvp.Key);
+                EnqueuePendingOperation(new CollectionOp<T>() { source = this, elementId = kvp.Key, element = kvp.Value, isRemove = true });
+            }
+        }
+
+        protected override IEnumerable<CollectionOp<T>> GetInitializationOperations()
+        {
+            foreach (var elementData in _collection)
+                yield return new CollectionOp<T>() { source = this, element = elementData.Value, elementId = elementData.Key, isRemove = false };
+        }
+
+        protected override void SendOperation(ICollectionObserver<T> observer, CollectionOp<T> operation)
+        {
+            if (operation.isRemove)
+            {
+                observer.OnRemove(operation.elementId, operation.element);
+            }
+            else
+            {
+                observer.OnAdd(operation.elementId, operation.element);
+            }
+        }
+
+        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
+            => Subscribe(new CollectionObserver<T>(
+                onAdd: (id, element) => observer.OnAdd(id, element),
+                onRemove: (id, element) => observer.OnRemove(id, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+    }
 }

package/Runtime/Implementations/ObservableCollection.cs.meta

@@ -1,2 +1,2 @@
-fileFormatVersion: 2
+fileFormatVersion: 2
 guid: c3e96a08fdf874645a4568052903de4b