com.fofx.observething 1.0.0 → 1.1.0

package/Runtime/Implementations/ObservableSet.cs

@@ -1,137 +1,137 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ObserveThing
-{
-    public interface ISetOp : IOperation
-    {
-        uint elementId { get; }
-        object element { get; }
-        bool isRemove { get; }
-    }
-
-    public struct SetOp<T> : ISetOp
-    {
-        public IObservable<IOperation> source { get; set; }
-        public uint elementId { get; set; }
-        public T element { get; set; }
-        public bool isRemove { get; set; }
-
-        object ISetOp.element => element;
-    }
-
-    public class ObservableSet<T> : ObservableBase<ISetObserver<T>, SetOp<T>>, ISetObservable<T>, IEnumerable<T>
-    {
-        public int count => _set.Count;
-
-        public IEnumerator<T> GetEnumerator()
-            => _set.Keys.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator()
-            => _set.Keys.GetEnumerator();
-
-        private Dictionary<T, uint> _set = new Dictionary<T, uint>();
-        private CollectionIdProvider _idProvider;
-
-        public ObservableSet() : this(default, default) { }
-        public ObservableSet(IEnumerable<T> values) : this(default, values) { }
-        public ObservableSet(ObservationContext context) : this(context, null) { }
-        public ObservableSet(ObservationContext context, IEnumerable<T> values) : base(context)
-        {
-            _idProvider = new CollectionIdProvider(x => _set.ContainsValue(x));
-
-            if (values == null)
-                return;
-
-            foreach (T value in values)
-                _set.Add(value, _idProvider.GetUnusedId());
-        }
-
-        public bool Add(T element)
-        {
-            if (_set.ContainsKey(element))
-                return false;
-
-            var id = _idProvider.GetUnusedId();
-            _set.Add(element, id);
-            EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = id, element = element, isRemove = false });
-            return true;
-        }
-
-        public void AddRange(IEnumerable<T> elements)
-        {
-            foreach (var element in elements)
-                Add(element);
-        }
-
-        public bool Remove(T element)
-        {
-            if (!_set.TryGetValue(element, out var id))
-                return false;
-
-            _set.Remove(element);
-            EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = id, element = element, isRemove = true });
-
-            return true;
-        }
-
-        public void Clear()
-        {
-            foreach (var kvp in _set.ToArray())
-            {
-                _set.Remove(kvp.Key);
-                EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = kvp.Value, element = kvp.Key, isRemove = true });
-            }
-        }
-
-        public bool Contains(T element)
-            => _set.ContainsKey(element);
-
-        public uint GetElementId(T element)
-            => _set[element];
-
-        protected override IEnumerable<SetOp<T>> GetInitializationOperations()
-        {
-            foreach (var element in _set)
-                yield return new SetOp<T>() { source = this, element = element.Key, elementId = element.Value, isRemove = false };
-        }
-
-        protected override void SendOperation(ISetObserver<T> observer, SetOp<T> operation)
-        {
-            if (operation.isRemove)
-            {
-                observer.OnRemove(operation.elementId, operation.element);
-            }
-            else
-            {
-                observer.OnAdd(operation.elementId, operation.element);
-            }
-        }
-
-        IDisposable ISetObservable.Subscribe(ISetObserver observer, bool immediate, uint? priority)
-            => Subscribe(new SetObserver<T>(
-                onAdd: (id, element) => observer.OnAdd(id, element),
-                onRemove: (id, element) => observer.OnRemove(id, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable<T>.Subscribe(ICollectionObserver<T> observer, bool immediate, uint? priority)
-            => Subscribe(new SetObserver<T>(
-                onAdd: (id, element) => observer.OnAdd(id, element),
-                onRemove: (id, element) => observer.OnRemove(id, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
-            => Subscribe(new SetObserver<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 ISetOp : IOperation
+    {
+        uint elementId { get; }
+        object element { get; }
+        bool isRemove { get; }
+    }
+
+    public struct SetOp<T> : ISetOp
+    {
+        public IObservable<IOperation> source { get; set; }
+        public uint elementId { get; set; }
+        public T element { get; set; }
+        public bool isRemove { get; set; }
+
+        object ISetOp.element => element;
+    }
+
+    public class ObservableSet<T> : ObservableBase<ISetObserver<T>, SetOp<T>>, ISetObservable<T>, IEnumerable<T>
+    {
+        public int count => _set.Count;
+
+        public IEnumerator<T> GetEnumerator()
+            => _set.Keys.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator()
+            => _set.Keys.GetEnumerator();
+
+        private Dictionary<T, uint> _set = new Dictionary<T, uint>();
+        private CollectionIdProvider _idProvider;
+
+        public ObservableSet() : this(default, default) { }
+        public ObservableSet(IEnumerable<T> values) : this(default, values) { }
+        public ObservableSet(ObservationContext context) : this(context, null) { }
+        public ObservableSet(ObservationContext context, IEnumerable<T> values) : base(context)
+        {
+            _idProvider = new CollectionIdProvider(x => _set.ContainsValue(x));
+
+            if (values == null)
+                return;
+
+            foreach (T value in values)
+                _set.Add(value, _idProvider.GetUnusedId());
+        }
+
+        public bool Add(T element)
+        {
+            if (_set.ContainsKey(element))
+                return false;
+
+            var id = _idProvider.GetUnusedId();
+            _set.Add(element, id);
+            EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = id, element = element, isRemove = false });
+            return true;
+        }
+
+        public void AddRange(IEnumerable<T> elements)
+        {
+            foreach (var element in elements)
+                Add(element);
+        }
+
+        public bool Remove(T element)
+        {
+            if (!_set.TryGetValue(element, out var id))
+                return false;
+
+            _set.Remove(element);
+            EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = id, element = element, isRemove = true });
+
+            return true;
+        }
+
+        public void Clear()
+        {
+            foreach (var kvp in _set.ToArray())
+            {
+                _set.Remove(kvp.Key);
+                EnqueuePendingOperation(new SetOp<T>() { source = this, elementId = kvp.Value, element = kvp.Key, isRemove = true });
+            }
+        }
+
+        public bool Contains(T element)
+            => _set.ContainsKey(element);
+
+        public uint GetElementId(T element)
+            => _set[element];
+
+        protected override IEnumerable<SetOp<T>> GetInitializationOperations()
+        {
+            foreach (var element in _set)
+                yield return new SetOp<T>() { source = this, element = element.Key, elementId = element.Value, isRemove = false };
+        }
+
+        protected override void SendOperation(ISetObserver<T> observer, SetOp<T> operation)
+        {
+            if (operation.isRemove)
+            {
+                observer.OnRemove(operation.elementId, operation.element);
+            }
+            else
+            {
+                observer.OnAdd(operation.elementId, operation.element);
+            }
+        }
+
+        IDisposable ISetObservable.Subscribe(ISetObserver observer, bool immediate, uint? priority)
+            => Subscribe(new SetObserver<T>(
+                onAdd: (id, element) => observer.OnAdd(id, element),
+                onRemove: (id, element) => observer.OnRemove(id, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable<T>.Subscribe(ICollectionObserver<T> observer, bool immediate, uint? priority)
+            => Subscribe(new SetObserver<T>(
+                onAdd: (id, element) => observer.OnAdd(id, element),
+                onRemove: (id, element) => observer.OnRemove(id, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
+            => Subscribe(new SetObserver<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/ObservableSet.cs.meta

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

package/Runtime/Implementations/ObservableValue.cs

@@ -1,59 +1,59 @@
-using System;
-using System.Collections.Generic;
-
-namespace ObserveThing
-{
-    public interface IValueOp : IOperation
-    {
-        object value { get; }
-    }
-
-    public struct ValueOp<T> : IValueOp
-    {
-        public IObservable<IOperation> source { get; set; }
-        public T value { get; set; }
-
-        object IValueOp.value => value;
-    }
-
-    public class ObservableValue<T> : ObservableBase<IValueObserver<T>, ValueOp<T>>, IValueObservable<T>
-    {
-        public T value
-        {
-            get => _value;
-            set
-            {
-                if (Equals(_value, value))
-                    return;
-
-                _value = value;
-                EnqueuePendingOperation(new ValueOp<T>() { source = this, value = value });
-            }
-        }
-
-        private T _value;
-
-        public ObservableValue() : this(default, default) { }
-        public ObservableValue(T value) : this(default, value) { }
-        public ObservableValue(ObservationContext context) : this(context, default) { }
-        public ObservableValue(ObservationContext context, T value) : base(context)
-        {
-            _value = value;
-        }
-
-        protected override IEnumerable<ValueOp<T>> GetInitializationOperations()
-        {
-            yield return new ValueOp<T>() { source = this, value = _value };
-        }
-
-        protected override void SendOperation(IValueObserver<T> observer, ValueOp<T> operation)
-            => observer.OnNext(operation.value);
-
-        public IDisposable Subscribe(IValueObserver observer, bool immediate = false, uint? priority = null)
-            => Subscribe(new ValueObserver<T>(
-                onNext: x => observer.OnNext(x),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-    }
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public interface IValueOp : IOperation
+    {
+        object value { get; }
+    }
+
+    public struct ValueOp<T> : IValueOp
+    {
+        public IObservable<IOperation> source { get; set; }
+        public T value { get; set; }
+
+        object IValueOp.value => value;
+    }
+
+    public class ObservableValue<T> : ObservableBase<IValueObserver<T>, ValueOp<T>>, IValueObservable<T>
+    {
+        public T value
+        {
+            get => _value;
+            set
+            {
+                if (Equals(_value, value))
+                    return;
+
+                _value = value;
+                EnqueuePendingOperation(new ValueOp<T>() { source = this, value = value });
+            }
+        }
+
+        private T _value;
+
+        public ObservableValue() : this(default, default) { }
+        public ObservableValue(T value) : this(default, value) { }
+        public ObservableValue(ObservationContext context) : this(context, default) { }
+        public ObservableValue(ObservationContext context, T value) : base(context)
+        {
+            _value = value;
+        }
+
+        protected override IEnumerable<ValueOp<T>> GetInitializationOperations()
+        {
+            yield return new ValueOp<T>() { source = this, value = _value };
+        }
+
+        protected override void SendOperation(IValueObserver<T> observer, ValueOp<T> operation)
+            => observer.OnNext(operation.value);
+
+        public IDisposable Subscribe(IValueObserver observer, bool immediate = false, uint? priority = null)
+            => Subscribe(new ValueObserver<T>(
+                onNext: x => observer.OnNext(x),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+    }
 }

package/Runtime/Implementations/ObservableValue.cs.meta

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

package/Runtime/Observables/BatchObservable.cs

@@ -1,72 +1,72 @@
-using System;
-using System.Collections.Generic;
-
-namespace ObserveThing
-{
-    public class BatchObservable<T> : IInitializationOperationsProvider<BatchOp<T>>, IPendingObserver where T : IOperation
-    {
-        public bool immediate { get; } = false;
-        public uint priority { get; private set; }
-        public bool disposed { get; private set; }
-
-        private IObservable<T> _source;
-        private Observable<BatchOp<T>> _operand;
-        private IDisposable _subscriptions;
-        private bool _pending;
-
-        private List<T> _batchedOperations = new List<T>();
-
-        public BatchObservable(IObservable<T> source, Observable<BatchOp<T>> operand)
-        {
-            priority = source.context.AllocateObserverPriority();
-
-            _source = source;
-            _operand = operand;
-
-            _subscriptions = source.Subscribe(new Observer<T>(
-                onNext: HandleSourceOperation,
-                onError: operand.OnError,
-                onDispose: Dispose
-            ), immediate: true);
-        }
-
-        private void HandleSourceOperation(T operation)
-        {
-            _batchedOperations.Add(operation);
-
-            if (_pending)
-                return;
-
-            _pending = true;
-            _source.context.RegisterPendingObserver(this);
-            _source.context.NotifyPendingObserversIfNecessary();
-        }
-
-        public IEnumerable<BatchOp<T>> GetInitializationOperations()
-        {
-            List<T> initOps = new List<T>();
-            var subscription = _source.Subscribe(new Observer<T>(x => initOps.Add(x)));
-            subscription.Dispose();
-            yield return new BatchOp<T>() { source = _source, operations = initOps };
-        }
-
-        public void SendNext()
-        {
-            _pending = false;
-
-            var batch = _batchedOperations.ToArray();
-            _batchedOperations.Clear();
-
-            _operand.EnqueueOperation(new BatchOp<T>() { source = _source, operations = batch });
-        }
-
-        public void Dispose()
-        {
-            disposed = true;
-            _source.context.DeallocateObserverPriority(priority);
-            _subscriptions?.Dispose();
-            _subscriptions = null;
-            _operand.Dispose();
-        }
-    }
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class BatchObservable<T> : IInitializationOperationsProvider<BatchOp<T>>, IPendingObserver where T : IOperation
+    {
+        public bool immediate { get; } = false;
+        public uint priority { get; private set; }
+        public bool disposed { get; private set; }
+
+        private IObservable<T> _source;
+        private Observable<BatchOp<T>> _operand;
+        private IDisposable _subscriptions;
+        private bool _pending;
+
+        private List<T> _batchedOperations = new List<T>();
+
+        public BatchObservable(IObservable<T> source, Observable<BatchOp<T>> operand)
+        {
+            priority = source.context.AllocateObserverPriority();
+
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = source.Subscribe(new Observer<T>(
+                onNext: HandleSourceOperation,
+                onError: operand.OnError,
+                onDispose: Dispose
+            ), immediate: true);
+        }
+
+        private void HandleSourceOperation(T operation)
+        {
+            _batchedOperations.Add(operation);
+
+            if (_pending)
+                return;
+
+            _pending = true;
+            _source.context.RegisterPendingObserver(this);
+            _source.context.NotifyPendingObserversIfNecessary();
+        }
+
+        public IEnumerable<BatchOp<T>> GetInitializationOperations()
+        {
+            List<T> initOps = new List<T>();
+            var subscription = _source.Subscribe(new Observer<T>(x => initOps.Add(x)));
+            subscription.Dispose();
+            yield return new BatchOp<T>() { source = _source, operations = initOps };
+        }
+
+        public void SendNext()
+        {
+            _pending = false;
+
+            var batch = _batchedOperations.ToArray();
+            _batchedOperations.Clear();
+
+            _operand.EnqueueOperation(new BatchOp<T>() { source = _source, operations = batch });
+        }
+
+        public void Dispose()
+        {
+            disposed = true;
+            _source.context.DeallocateObserverPriority(priority);
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
 }

package/Runtime/Observables/BatchObservable.cs.meta

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