com.fofx.observething 1.0.0 → 1.1.0

package/Runtime/Implementations/ObservableDictionary.cs

@@ -1,166 +1,166 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace ObserveThing
-{
-    public interface IDictionaryOp : IOperation
-    {
-        uint elementId { get; }
-        object key { get; }
-        object value { get; }
-        bool isRemove { get; }
-    }
-
-    public struct DictionaryOp<TKey, TValue> : IDictionaryOp
-    {
-        public IObservable<IOperation> source { get; set; }
-        public uint elementId { get; set; }
-        public TKey key { get; set; }
-        public TValue value { get; set; }
-        public bool isRemove { get; set; }
-
-        object IDictionaryOp.key => key;
-        object IDictionaryOp.value => value;
-    }
-
-    public class ObservableDictionary<TKey, TValue> : ObservableBase<IDictionaryObserver<TKey, TValue>, DictionaryOp<TKey, TValue>>, IDictionaryObservable<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>
-    {
-        public TValue this[TKey key]
-        {
-            get => _dictionary[key];
-            set
-            {
-                Remove(key);
-                Add(key, value);
-            }
-        }
-
-        public int Count => _dictionary.Count;
-
-        public IEnumerable<TKey> Keys => _dictionary.Keys;
-        public IEnumerable<TValue> Values => _dictionary.Values;
-
-        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
-            => _dictionary.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator()
-            => _dictionary.GetEnumerator();
-
-        private Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();
-        private Dictionary<TKey, uint> _ids = new Dictionary<TKey, uint>();
-        private CollectionIdProvider _idProvider;
-
-        public ObservableDictionary() : this(default, default) { }
-        public ObservableDictionary(IEnumerable<KeyValuePair<TKey, TValue>> value) : this(default, value) { }
-
-        public ObservableDictionary(ObservationContext context) : this(context, default) { }
-        public ObservableDictionary(ObservationContext context, IEnumerable<KeyValuePair<TKey, TValue>> value) : base(context)
-        {
-            _idProvider = new CollectionIdProvider(_ids.Values.Contains);
-
-            if (value == null)
-                return;
-
-            foreach (var kvp in value)
-            {
-                _dictionary.Add(kvp.Key, kvp.Value);
-                _ids.Add(kvp.Key, _idProvider.GetUnusedId());
-            }
-        }
-
-        public void Add(TKey key, TValue value)
-        {
-            var id = _idProvider.GetUnusedId();
-            _dictionary.Add(key, value);
-            _ids.Add(key, id);
-            EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = key, value = value, isRemove = false });
-        }
-
-        public bool Remove(TKey key)
-        {
-            if (!_dictionary.TryGetValue(key, out var value))
-                return false;
-
-            var id = _ids[key];
-
-            _dictionary.Remove(key);
-            _ids.Remove(key);
-            EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = key, value = value, isRemove = true });
-
-            return true;
-        }
-
-        public void Clear()
-        {
-            foreach (var kvp in _dictionary.ToArray())
-            {
-                var id = _ids[kvp.Key];
-                _dictionary.Remove(kvp.Key);
-                _ids.Remove(kvp.Key);
-                EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = true });
-            }
-        }
-
-        public bool TryGetValueInternal(TKey key, out TValue value)
-            => _dictionary.TryGetValue(key, out value);
-
-        public bool ContainsKey(TKey key)
-            => _dictionary.ContainsKey(key);
-
-        public bool ContainsValue(TValue value)
-            => _dictionary.ContainsValue(value);
-
-        protected override IEnumerable<DictionaryOp<TKey, TValue>> GetInitializationOperations()
-        {
-            foreach (var kvp in _dictionary)
-            {
-                yield return new DictionaryOp<TKey, TValue>()
-                {
-                    source = this,
-                    elementId = _ids[kvp.Key],
-                    key = kvp.Key,
-                    value = kvp.Value,
-                    isRemove = false
-                };
-            }
-        }
-
-        protected override void SendOperation(IDictionaryObserver<TKey, TValue> observer, DictionaryOp<TKey, TValue> operation)
-        {
-            if (operation.isRemove)
-            {
-                observer.OnRemove(operation.elementId, KeyValuePair.Create(operation.key, operation.value));
-            }
-            else
-            {
-                observer.OnAdd(operation.elementId, KeyValuePair.Create(operation.key, operation.value));
-            }
-        }
-
-        IDisposable IDictionaryObservable.Subscribe(IDictionaryObserver observer, bool immediate, uint? priority)
-            => Subscribe(new DictionaryObserver<TKey, TValue>(
-                onAdd: (id, kvp) => observer.OnAdd(id, new KeyValuePair<object, object>(kvp.Key, kvp.Value)),
-                onRemove: (id, kvp) => observer.OnRemove(id, new KeyValuePair<object, object>(kvp.Key, kvp.Value)),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable<KeyValuePair<TKey, TValue>>.Subscribe(ICollectionObserver<KeyValuePair<TKey, TValue>> observer, bool immediate, uint? priority)
-            => Subscribe(new DictionaryObserver<TKey, TValue>(
-                onAdd: (id, kvp) => observer.OnAdd(id, kvp),
-                onRemove: (id, kvp) => observer.OnRemove(id, kvp),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
-            => Subscribe(new DictionaryObserver<TKey, TValue>(
-                onAdd: (id, kvp) => observer.OnAdd(id, kvp),
-                onRemove: (id, kvp) => observer.OnRemove(id, kvp),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-    }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ObserveThing
+{
+    public interface IDictionaryOp : IOperation
+    {
+        uint elementId { get; }
+        object key { get; }
+        object value { get; }
+        bool isRemove { get; }
+    }
+
+    public struct DictionaryOp<TKey, TValue> : IDictionaryOp
+    {
+        public IObservable<IOperation> source { get; set; }
+        public uint elementId { get; set; }
+        public TKey key { get; set; }
+        public TValue value { get; set; }
+        public bool isRemove { get; set; }
+
+        object IDictionaryOp.key => key;
+        object IDictionaryOp.value => value;
+    }
+
+    public class ObservableDictionary<TKey, TValue> : ObservableBase<IDictionaryObserver<TKey, TValue>, DictionaryOp<TKey, TValue>>, IDictionaryObservable<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>
+    {
+        public TValue this[TKey key]
+        {
+            get => _dictionary[key];
+            set
+            {
+                Remove(key);
+                Add(key, value);
+            }
+        }
+
+        public int Count => _dictionary.Count;
+
+        public IEnumerable<TKey> Keys => _dictionary.Keys;
+        public IEnumerable<TValue> Values => _dictionary.Values;
+
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+            => _dictionary.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator()
+            => _dictionary.GetEnumerator();
+
+        private Dictionary<TKey, TValue> _dictionary = new Dictionary<TKey, TValue>();
+        private Dictionary<TKey, uint> _ids = new Dictionary<TKey, uint>();
+        private CollectionIdProvider _idProvider;
+
+        public ObservableDictionary() : this(default, default) { }
+        public ObservableDictionary(IEnumerable<KeyValuePair<TKey, TValue>> value) : this(default, value) { }
+
+        public ObservableDictionary(ObservationContext context) : this(context, default) { }
+        public ObservableDictionary(ObservationContext context, IEnumerable<KeyValuePair<TKey, TValue>> value) : base(context)
+        {
+            _idProvider = new CollectionIdProvider(_ids.Values.Contains);
+
+            if (value == null)
+                return;
+
+            foreach (var kvp in value)
+            {
+                _dictionary.Add(kvp.Key, kvp.Value);
+                _ids.Add(kvp.Key, _idProvider.GetUnusedId());
+            }
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            var id = _idProvider.GetUnusedId();
+            _dictionary.Add(key, value);
+            _ids.Add(key, id);
+            EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = key, value = value, isRemove = false });
+        }
+
+        public bool Remove(TKey key)
+        {
+            if (!_dictionary.TryGetValue(key, out var value))
+                return false;
+
+            var id = _ids[key];
+
+            _dictionary.Remove(key);
+            _ids.Remove(key);
+            EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = key, value = value, isRemove = true });
+
+            return true;
+        }
+
+        public void Clear()
+        {
+            foreach (var kvp in _dictionary.ToArray())
+            {
+                var id = _ids[kvp.Key];
+                _dictionary.Remove(kvp.Key);
+                _ids.Remove(kvp.Key);
+                EnqueuePendingOperation(new DictionaryOp<TKey, TValue>() { source = this, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = true });
+            }
+        }
+
+        public bool TryGetValueInternal(TKey key, out TValue value)
+            => _dictionary.TryGetValue(key, out value);
+
+        public bool ContainsKey(TKey key)
+            => _dictionary.ContainsKey(key);
+
+        public bool ContainsValue(TValue value)
+            => _dictionary.ContainsValue(value);
+
+        protected override IEnumerable<DictionaryOp<TKey, TValue>> GetInitializationOperations()
+        {
+            foreach (var kvp in _dictionary)
+            {
+                yield return new DictionaryOp<TKey, TValue>()
+                {
+                    source = this,
+                    elementId = _ids[kvp.Key],
+                    key = kvp.Key,
+                    value = kvp.Value,
+                    isRemove = false
+                };
+            }
+        }
+
+        protected override void SendOperation(IDictionaryObserver<TKey, TValue> observer, DictionaryOp<TKey, TValue> operation)
+        {
+            if (operation.isRemove)
+            {
+                observer.OnRemove(operation.elementId, KeyValuePair.Create(operation.key, operation.value));
+            }
+            else
+            {
+                observer.OnAdd(operation.elementId, KeyValuePair.Create(operation.key, operation.value));
+            }
+        }
+
+        IDisposable IDictionaryObservable.Subscribe(IDictionaryObserver observer, bool immediate, uint? priority)
+            => Subscribe(new DictionaryObserver<TKey, TValue>(
+                onAdd: (id, kvp) => observer.OnAdd(id, new KeyValuePair<object, object>(kvp.Key, kvp.Value)),
+                onRemove: (id, kvp) => observer.OnRemove(id, new KeyValuePair<object, object>(kvp.Key, kvp.Value)),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable<KeyValuePair<TKey, TValue>>.Subscribe(ICollectionObserver<KeyValuePair<TKey, TValue>> observer, bool immediate, uint? priority)
+            => Subscribe(new DictionaryObserver<TKey, TValue>(
+                onAdd: (id, kvp) => observer.OnAdd(id, kvp),
+                onRemove: (id, kvp) => observer.OnRemove(id, kvp),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
+            => Subscribe(new DictionaryObserver<TKey, TValue>(
+                onAdd: (id, kvp) => observer.OnAdd(id, kvp),
+                onRemove: (id, kvp) => observer.OnRemove(id, kvp),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+    }
 }

package/Runtime/Implementations/ObservableDictionary.cs.meta

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

package/Runtime/Implementations/ObservableList.cs

@@ -1,163 +1,163 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace ObserveThing
-{
-    public interface IListOp : IOperation
-    {
-        uint elementId { get; }
-        int index { get; }
-        object element { get; }
-        bool isRemove { get; }
-    }
-
-    public struct ListOp<T> : IListOp
-    {
-        public IObservable<IOperation> source { get; set; }
-        public int index { get; set; }
-        public uint elementId { get; set; }
-        public T element { get; set; }
-        public bool isRemove { get; set; }
-
-        object IListOp.element => element;
-    }
-
-    public class ObservableList<T> : ObservableBase<IListObserver<T>, ListOp<T>>, IListObservable<T>, IEnumerable<T>
-    {
-        public T this[int index]
-        {
-            get => _list[index];
-            set
-            {
-                RemoveAt(index);
-                Insert(index, value);
-            }
-        }
-
-        IEnumerator<T> IEnumerable<T>.GetEnumerator()
-            => _list.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator()
-            => _list.GetEnumerator();
-
-        public int count => _list.Count;
-
-        private List<T> _list = new List<T>();
-        private List<uint> _ids = new List<uint>();
-        private CollectionIdProvider _idProvider;
-
-        public ObservableList() : this(default, default(IEnumerable<T>)) { }
-        public ObservableList(params T[] value) : this(default, (IEnumerable<T>)value) { }
-        public ObservableList(IEnumerable<T> value) : this(default, value) { }
-
-        public ObservableList(ObservationContext context) : this(context, default(IEnumerable<T>)) { }
-        public ObservableList(ObservationContext context, params T[] value) : this(context, (IEnumerable<T>)value) { }
-        public ObservableList(ObservationContext context, IEnumerable<T> value) : base(context)
-        {
-            _idProvider = new CollectionIdProvider(_ids.Contains);
-
-            if (value == null)
-                return;
-
-            foreach (var element in value)
-            {
-                _list.Add(element);
-                _ids.Add(_idProvider.GetUnusedId());
-            }
-        }
-
-        public void Add(T added)
-            => Insert(_list.Count, added);
-
-        public void AddRange(IEnumerable<T> toAdd)
-        {
-            foreach (var added in toAdd)
-                Add(added);
-        }
-
-        public bool Remove(T removed)
-        {
-            var index = _list.IndexOf(removed);
-
-            if (index == -1)
-                return false;
-
-            RemoveAt(index);
-            return true;
-        }
-
-        public void RemoveAt(int index)
-        {
-            var removed = _list[index];
-            var id = _ids[index];
-            _list.RemoveAt(index);
-            _ids.RemoveAt(index);
-            EnqueuePendingOperation(new ListOp<T>() { source = this, element = removed, elementId = id, index = index, isRemove = true });
-        }
-
-        public void Insert(int index, T item)
-        {
-            var id = _idProvider.GetUnusedId();
-            _list.Insert(index, item);
-            _ids.Insert(index, id);
-            EnqueuePendingOperation(new ListOp<T>() { source = this, element = item, elementId = id, index = index, isRemove = false });
-        }
-
-        public void Clear()
-        {
-            while (_list.Count > 0)
-                RemoveAt(_list.Count - 1);
-        }
-
-        public int IndexOf(T item)
-            => _list.IndexOf(item);
-
-        public bool Contains(T item)
-            => _list.Contains(item);
-
-        protected override IEnumerable<ListOp<T>> GetInitializationOperations()
-        {
-            for (int i = 0; i < _list.Count; i++)
-            {
-                yield return new ListOp<T>() { source = this, element = _list[i], elementId = _ids[i], index = i, isRemove = false };
-            }
-        }
-
-        protected override void SendOperation(IListObserver<T> observer, ListOp<T> operation)
-        {
-            if (operation.isRemove)
-            {
-                observer.OnRemove(operation.elementId, operation.index, operation.element);
-            }
-            else
-            {
-                observer.OnAdd(operation.elementId, operation.index, operation.element);
-            }
-        }
-
-        IDisposable IListObservable.Subscribe(IListObserver observer, bool immediate, uint? priority)
-            => Subscribe(new ListObserver<T>(
-                onAdd: (id, index, element) => observer.OnAdd(id, index, element),
-                onRemove: (id, index, element) => observer.OnRemove(id, index, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable<T>.Subscribe(ICollectionObserver<T> observer, bool immediate, uint? priority)
-            => Subscribe(new ListObserver<T>(
-                onAdd: (id, index, element) => observer.OnAdd(id, element),
-                onRemove: (id, index, element) => observer.OnRemove(id, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-
-        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
-            => Subscribe(new ListObserver<T>(
-                onAdd: (id, index, element) => observer.OnAdd(id, element),
-                onRemove: (id, index, element) => observer.OnRemove(id, element),
-                onDispose: observer.OnDispose,
-                onError: observer.OnError
-            ), immediate, priority);
-    }
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public interface IListOp : IOperation
+    {
+        uint elementId { get; }
+        int index { get; }
+        object element { get; }
+        bool isRemove { get; }
+    }
+
+    public struct ListOp<T> : IListOp
+    {
+        public IObservable<IOperation> source { get; set; }
+        public int index { get; set; }
+        public uint elementId { get; set; }
+        public T element { get; set; }
+        public bool isRemove { get; set; }
+
+        object IListOp.element => element;
+    }
+
+    public class ObservableList<T> : ObservableBase<IListObserver<T>, ListOp<T>>, IListObservable<T>, IEnumerable<T>
+    {
+        public T this[int index]
+        {
+            get => _list[index];
+            set
+            {
+                RemoveAt(index);
+                Insert(index, value);
+            }
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+            => _list.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator()
+            => _list.GetEnumerator();
+
+        public int count => _list.Count;
+
+        private List<T> _list = new List<T>();
+        private List<uint> _ids = new List<uint>();
+        private CollectionIdProvider _idProvider;
+
+        public ObservableList() : this(default, default(IEnumerable<T>)) { }
+        public ObservableList(params T[] value) : this(default, (IEnumerable<T>)value) { }
+        public ObservableList(IEnumerable<T> value) : this(default, value) { }
+
+        public ObservableList(ObservationContext context) : this(context, default(IEnumerable<T>)) { }
+        public ObservableList(ObservationContext context, params T[] value) : this(context, (IEnumerable<T>)value) { }
+        public ObservableList(ObservationContext context, IEnumerable<T> value) : base(context)
+        {
+            _idProvider = new CollectionIdProvider(_ids.Contains);
+
+            if (value == null)
+                return;
+
+            foreach (var element in value)
+            {
+                _list.Add(element);
+                _ids.Add(_idProvider.GetUnusedId());
+            }
+        }
+
+        public void Add(T added)
+            => Insert(_list.Count, added);
+
+        public void AddRange(IEnumerable<T> toAdd)
+        {
+            foreach (var added in toAdd)
+                Add(added);
+        }
+
+        public bool Remove(T removed)
+        {
+            var index = _list.IndexOf(removed);
+
+            if (index == -1)
+                return false;
+
+            RemoveAt(index);
+            return true;
+        }
+
+        public void RemoveAt(int index)
+        {
+            var removed = _list[index];
+            var id = _ids[index];
+            _list.RemoveAt(index);
+            _ids.RemoveAt(index);
+            EnqueuePendingOperation(new ListOp<T>() { source = this, element = removed, elementId = id, index = index, isRemove = true });
+        }
+
+        public void Insert(int index, T item)
+        {
+            var id = _idProvider.GetUnusedId();
+            _list.Insert(index, item);
+            _ids.Insert(index, id);
+            EnqueuePendingOperation(new ListOp<T>() { source = this, element = item, elementId = id, index = index, isRemove = false });
+        }
+
+        public void Clear()
+        {
+            while (_list.Count > 0)
+                RemoveAt(_list.Count - 1);
+        }
+
+        public int IndexOf(T item)
+            => _list.IndexOf(item);
+
+        public bool Contains(T item)
+            => _list.Contains(item);
+
+        protected override IEnumerable<ListOp<T>> GetInitializationOperations()
+        {
+            for (int i = 0; i < _list.Count; i++)
+            {
+                yield return new ListOp<T>() { source = this, element = _list[i], elementId = _ids[i], index = i, isRemove = false };
+            }
+        }
+
+        protected override void SendOperation(IListObserver<T> observer, ListOp<T> operation)
+        {
+            if (operation.isRemove)
+            {
+                observer.OnRemove(operation.elementId, operation.index, operation.element);
+            }
+            else
+            {
+                observer.OnAdd(operation.elementId, operation.index, operation.element);
+            }
+        }
+
+        IDisposable IListObservable.Subscribe(IListObserver observer, bool immediate, uint? priority)
+            => Subscribe(new ListObserver<T>(
+                onAdd: (id, index, element) => observer.OnAdd(id, index, element),
+                onRemove: (id, index, element) => observer.OnRemove(id, index, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable<T>.Subscribe(ICollectionObserver<T> observer, bool immediate, uint? priority)
+            => Subscribe(new ListObserver<T>(
+                onAdd: (id, index, element) => observer.OnAdd(id, element),
+                onRemove: (id, index, element) => observer.OnRemove(id, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+
+        IDisposable ICollectionObservable.Subscribe(ICollectionObserver observer, bool immediate, uint? priority)
+            => Subscribe(new ListObserver<T>(
+                onAdd: (id, index, element) => observer.OnAdd(id, element),
+                onRemove: (id, index, element) => observer.OnRemove(id, element),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
+    }
 }

package/Runtime/Implementations/ObservableList.cs.meta

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