com.fofx.observething 1.0.0

package/Runtime/Implementations/ObservableList.cs

@@ -0,0 +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);
+    }
+}

package/Runtime/Implementations/ObservableList.cs.meta

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

package/Runtime/Implementations/ObservableSet.cs

@@ -0,0 +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);
+    }
+}

package/Runtime/Implementations/ObservableSet.cs.meta

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

package/Runtime/Implementations/ObservableValue.cs

@@ -0,0 +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);
+    }
+}

package/Runtime/Implementations/ObservableValue.cs.meta

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

package/Runtime/Implementations.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e8d0c3cfd1121d2438fb3dc60ce9a8ba
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Observables/BatchObservable.cs

@@ -0,0 +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();
+        }
+    }
+}

package/Runtime/Observables/BatchObservable.cs.meta

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

package/Runtime/Observables/CastObservable.cs

@@ -0,0 +1,128 @@
+using System;
+
+namespace ObserveThing
+{
+    public class CastValueObservable<T> : IDisposable
+    {
+        private ObservableValue<T> _operand;
+        private IDisposable _subscription;
+
+        public CastValueObservable(IValueObservable source, ObservableValue<T> operand)
+        {
+            _operand = operand;
+            _subscription = source.Subscribe(
+                onNext: x => operand.value = (T)x,
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CastCollectionObservable<T> : IDisposable
+    {
+        private ObservableCollection<T> _operand;
+        private IDisposable _subscription;
+
+        public CastCollectionObservable(ICollectionObservable source, ObservableCollection<T> operand)
+        {
+            _operand = operand;
+            _subscription = source.SubscribeWithId(
+                onAdd: (id, x) => operand.Add(id, (T)x),
+                onRemove: (id, _) => operand.Remove(id),
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CastListObservable<T> : IDisposable
+    {
+        private ObservableList<T> _operand;
+        private IDisposable _subscription;
+
+        public CastListObservable(IListObservable source, ObservableList<T> operand)
+        {
+            _operand = operand;
+            _subscription = source.Subscribe(
+                onAdd: (index, x) => operand.Insert(index, (T)x),
+                onRemove: (index, _) => operand.RemoveAt(index),
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CastSetObservable<T> : IDisposable
+    {
+        private ObservableSet<T> _operand;
+        private IDisposable _subscription;
+
+        public CastSetObservable(ISetObservable source, ObservableSet<T> operand)
+        {
+            _operand = operand;
+            _subscription = source.Subscribe(
+                onAdd: x => operand.Add((T)x),
+                onRemove: x => operand.Remove((T)x),
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CastDictionaryObservable<TKey, TValue> : IDisposable
+    {
+        private ObservableDictionary<TKey, TValue> _operand;
+        private IDisposable _subscription;
+
+        public CastDictionaryObservable(IDictionaryObservable source, ObservableDictionary<TKey, TValue> operand)
+        {
+            _operand = operand;
+            _subscription = source.Subscribe(
+                onAdd: x => operand.Add((TKey)x.Key, (TValue)x.Value),
+                onRemove: x => operand.Remove((TKey)x.Key),
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/CastObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b01a22250763ab34aa632028afe67ef7

package/Runtime/Observables/CombineObservable.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class CombineObservable<T> : IInitializationOperationsProvider<T> where T : IOperation
+    {
+        private ISetObservable<IObservable<T>> _source;
+        private Observable<T> _operand;
+        private bool _disposeOnSourceEmpty;
+        private uint _elementPriority;
+        private Dictionary<IObservable<T>, IDisposable> _observables = new Dictionary<IObservable<T>, IDisposable>();
+        private IDisposable _subscriptions;
+        private bool _disposed;
+
+        public CombineObservable(ISetObservable<IObservable<T>> source, Observable<T> operand, bool disposeOnSourceEmpty = false)
+        {
+            _source = source;
+            _operand = operand;
+            _disposeOnSourceEmpty = disposeOnSourceEmpty;
+            _elementPriority = _source.context.AllocateObserverPriority();
+            _subscriptions = _source.Subscribe(new SetObserver<IObservable<T>>(
+                onAdd: HandleElementAdded,
+                onRemove: HandleElementRemoved,
+                onError: _operand.OnError,
+                onDispose: Dispose
+            ), immediate: true);
+        }
+
+        public IEnumerable<T> GetInitializationOperations()
+        {
+            List<T> initOps = new List<T>();
+
+            foreach (var element in _observables.Keys)
+            {
+                var subscription = element.Subscribe(new Observer<T>(x => initOps.Add(x)));
+                subscription.Dispose();
+            }
+
+            foreach (var op in initOps)
+                yield return op;
+        }
+
+        private void HandleElementAdded(uint _, IObservable<T> observable)
+        {
+            _observables.Add(
+                observable,
+                observable.Subscribe(new Observer<T>(
+                    onNext: HandleElementChanged,
+                    onError: _operand.OnError,
+                    onDispose: () =>
+                    {
+                        if (_disposed)
+                            return;
+
+                        HandleElementRemoved(0, observable);
+                    }
+                ), immediate: true, priority: _elementPriority)
+            );
+        }
+
+        private void HandleElementRemoved(uint _, IObservable<T> observable)
+        {
+            if (!_observables.TryGetValue(observable, out var subscription))
+                return;
+
+            _observables.Remove(observable);
+            subscription.Dispose();
+
+            if (_disposeOnSourceEmpty && _observables.Count == 0)
+                Dispose();
+        }
+
+        protected void HandleElementChanged(T operation)
+        {
+            _operand.EnqueueOperation(operation);
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            _disposed = true;
+
+            _source.context.DeallocateObserverPriority(_elementPriority);
+
+            foreach (var subscription in _observables.Values)
+                subscription.Dispose();
+
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/CombineObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: df42ce7c86dad2e42966e8238165aa40