com.fofx.observething 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# Welcome!
+**TODO**

package/README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 848bacb72b0b36c4b8729fa367a09396
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/CollectionIdProvider.cs

@@ -0,0 +1,72 @@
+using System;
+
+namespace ObserveThing
+{
+    public class CollectionIdProvider
+    {
+        private Func<uint, bool> _validateId;
+        private bool _validateBeforeFirstLoop;
+        private uint _nextId = 0;
+        private bool _looped;
+
+        public CollectionIdProvider(Func<uint, bool> validateId, bool validateBeforeFirstLoop = false)
+        {
+            _validateId = validateId;
+            _validateBeforeFirstLoop = validateBeforeFirstLoop;
+        }
+
+        public uint GetUnusedId()
+        {
+            uint id = _nextId;
+
+            if (_looped || _validateBeforeFirstLoop)
+            {
+                bool found = false;
+
+                for (uint i = _nextId; i < uint.MaxValue; i++)
+                {
+                    if (_validateId(i))
+                    {
+                        id = i;
+                        found = true;
+                        break;
+                    }
+                }
+
+                if (!found)
+                {
+                    for (uint i = 0; i < _nextId; i++)
+                    {
+                        if (_validateId(i))
+                        {
+                            id = i;
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if (!found)
+                        throw new Exception("No valid ID found!");
+                }
+            }
+
+            if (id == uint.MaxValue)
+            {
+                _nextId = 0;
+                _looped = true;
+            }
+            else
+            {
+                _nextId = id + 1;
+            }
+
+            return id;
+        }
+
+        public void Reset()
+        {
+            _looped = false;
+            _nextId = 0;
+        }
+    }
+}

package/Runtime/CollectionIdProvider.cs.meta

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

package/Runtime/IObservable.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public interface IObservable<out T> where T : IOperation
+    {
+        ObservationContext context { get; }
+        IDisposable Subscribe(IObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IValueObservable : IObservable<IOperation>
+    {
+        IDisposable Subscribe(IValueObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IValueObservable<out T> : IValueObservable
+    {
+        IDisposable Subscribe(IValueObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface ICollectionObservable : IObservable<IOperation>
+    {
+        IDisposable Subscribe(ICollectionObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface ICollectionObservable<out T> : ICollectionObservable
+    {
+        IDisposable Subscribe(ICollectionObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IListObservable : ICollectionObservable
+    {
+        IDisposable Subscribe(IListObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IListObservable<out T> : IListObservable, ICollectionObservable<T>
+    {
+        IDisposable Subscribe(IListObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface ISetObservable : ICollectionObservable
+    {
+        IDisposable Subscribe(ISetObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface ISetObservable<out T> : ISetObservable, ICollectionObservable<T>
+    {
+        IDisposable Subscribe(ISetObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IDictionaryObservable : ICollectionObservable
+    {
+        IDisposable Subscribe(IDictionaryObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IDictionaryObservable<TKey, TValue> : IDictionaryObservable, ICollectionObservable<KeyValuePair<TKey, TValue>>
+    {
+        IDisposable Subscribe(IDictionaryObserver<TKey, TValue> observer, bool immediate = default, uint? priority = default);
+    }
+
+    // public interface IBatchObservable<out T> : IObservable<IOperation> where T : IOperation
+    // {
+    //     public IDisposable Subscribe(IBatchObserver<T> observer, bool immediate = false, uint? priority = default);
+    // }
+}

package/Runtime/IObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3b1531a1eddae4c4790263212a4adfb5

package/Runtime/Implementations/Observable.cs

@@ -0,0 +1,30 @@
+
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class Observable<T> : ObservableBase<IObserver<T>, T> where T : IOperation
+    {
+        private IInitializationOperationsProvider<T> _initializationOperationsProvider;
+
+        public Observable(ObservationContext context, IInitializationOperationsProvider<T> initializationOperationsProvider) : base(context)
+        {
+            _initializationOperationsProvider = initializationOperationsProvider;
+        }
+
+        protected override IEnumerable<T> GetInitializationOperations()
+        {
+            if (_initializationOperationsProvider == null)
+                yield break;
+
+            foreach (var op in _initializationOperationsProvider.GetInitializationOperations())
+                yield return op;
+        }
+
+        protected override void SendOperation(IObserver<T> observer, T operation)
+            => observer.OnNext(operation);
+
+        public void EnqueueOperation(T operation)
+            => EnqueuePendingOperation(operation);
+    }
+}

package/Runtime/Implementations/Observable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9e6b02c6340fb034384039c77d32f7a3

package/Runtime/Implementations/ObservableBase.cs

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

package/Runtime/Implementations/ObservableBase.cs.meta

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

package/Runtime/Implementations/ObservableCollection.cs

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

package/Runtime/Implementations/ObservableCollection.cs.meta

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

package/Runtime/Implementations/ObservableDictionary.cs

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

package/Runtime/Implementations/ObservableDictionary.cs.meta

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