com.fofx.observething 1.0.0

package/Runtime/Observers.cs

@@ -0,0 +1,403 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public static class Settings
+    {
+        public static Action<Exception> DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        public static ObservationContext DefaultObservationContext = new ObservationContext();
+    }
+
+    public interface IObserverBase
+    {
+        void OnError(Exception exc);
+        void OnDispose();
+    }
+
+    public interface IObserver<in T> : IObserverBase where T : IOperation
+    {
+        void OnNext(T operation);
+    }
+
+    public class Observer<T> : IObserver<T> where T : IOperation
+    {
+        private Action<T> _onNext;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public Observer(Action<T> onNext = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onNext = onNext;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnNext(T operation)
+        {
+            try
+            {
+                _onNext?.Invoke(operation);
+            }
+            catch (Exception exc)
+            {
+                OnError(exc);
+            }
+        }
+
+        public void OnDispose() => _onDispose?.Invoke();
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IValueObserver : IObserverBase
+    {
+        void OnNext(object value);
+    }
+
+    public class ValueObserver : IValueObserver
+    {
+        private Action<object> _onNext;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public ValueObserver(Action<object> onNext = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onNext = onNext;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnNext(object value)
+            => _onNext?.Invoke(value);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IValueObserver<in T> : IObserverBase
+    {
+        void OnNext(T value);
+    }
+
+    public class ValueObserver<T> : IValueObserver<T>
+    {
+        private Action<T> _onNext;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public ValueObserver(Action<T> onNext = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onNext = onNext;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnNext(T value)
+            => _onNext?.Invoke(value);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface ICollectionObserver : IObserverBase
+    {
+        void OnAdd(uint elementId, object element);
+        void OnRemove(uint elementId, object element);
+    }
+
+    public class CollectionObserver : ICollectionObserver
+    {
+        private Action<uint, object> _onAdd;
+        private Action<uint, object> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public CollectionObserver(Action<uint, object> onAdd = default, Action<uint, object> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, object element)
+            => _onAdd?.Invoke(elementId, element);
+
+        public void OnRemove(uint elementId, object element)
+            => _onRemove?.Invoke(elementId, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface ICollectionObserver<in T> : IObserverBase
+    {
+        void OnAdd(uint elementId, T element);
+        void OnRemove(uint elementId, T element);
+    }
+
+    public class CollectionObserver<T> : ICollectionObserver<T>
+    {
+        private Action<uint, T> _onAdd;
+        private Action<uint, T> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public CollectionObserver(Action<uint, T> onAdd = default, Action<uint, T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, T element)
+            => _onAdd?.Invoke(elementId, element);
+
+        public void OnRemove(uint elementId, T element)
+            => _onRemove?.Invoke(elementId, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IListObserver : IObserverBase
+    {
+        void OnAdd(uint elementId, int index, object element);
+        void OnRemove(uint elementId, int index, object element);
+    }
+
+    public class ListObserver : IListObserver
+    {
+        private Action<uint, int, object> _onAdd;
+        private Action<uint, int, object> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public ListObserver(Action<uint, int, object> onAdd = default, Action<uint, int, object> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, int index, object element)
+            => _onAdd?.Invoke(elementId, index, element);
+
+        public void OnRemove(uint elementId, int index, object element)
+            => _onRemove?.Invoke(elementId, index, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IListObserver<in T> : IObserverBase
+    {
+        void OnAdd(uint elementId, int index, T element);
+        void OnRemove(uint elementId, int index, T element);
+    }
+
+    public class ListObserver<T> : IListObserver<T>
+    {
+        private Action<uint, int, T> _onAdd;
+        private Action<uint, int, T> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public ListObserver(Action<uint, int, T> onAdd = default, Action<uint, int, T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, int index, T element)
+            => _onAdd?.Invoke(elementId, index, element);
+
+        public void OnRemove(uint elementId, int index, T element)
+            => _onRemove?.Invoke(elementId, index, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface ISetObserver : IObserverBase
+    {
+        void OnAdd(uint elementId, object element);
+        void OnRemove(uint elementId, object element);
+    }
+
+    public class SetObserver : ISetObserver
+    {
+        private Action<uint, object> _onAdd;
+        private Action<uint, object> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public SetObserver(Action<uint, object> onAdd = default, Action<uint, object> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, object element)
+            => _onAdd?.Invoke(elementId, element);
+
+        public void OnRemove(uint elementId, object element)
+            => _onRemove?.Invoke(elementId, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface ISetObserver<in T> : IObserverBase
+    {
+        void OnAdd(uint elementId, T element);
+        void OnRemove(uint elementId, T element);
+    }
+
+    public class SetObserver<T> : ISetObserver<T>
+    {
+        private Action<uint, T> _onAdd;
+        private Action<uint, T> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public SetObserver(Action<uint, T> onAdd = default, Action<uint, T> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, T element)
+            => _onAdd?.Invoke(elementId, element);
+
+        public void OnRemove(uint elementId, T element)
+            => _onRemove?.Invoke(elementId, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IDictionaryObserver : IObserverBase
+    {
+        void OnAdd(uint elementId, KeyValuePair<object, object> kvp);
+        void OnRemove(uint elementId, KeyValuePair<object, object> kvp);
+    }
+
+    public class DictionaryObserver : IDictionaryObserver
+    {
+        private Action<uint, KeyValuePair<object, object>> _onAdd;
+        private Action<uint, KeyValuePair<object, object>> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public DictionaryObserver(Action<uint, KeyValuePair<object, object>> onAdd = default, Action<uint, KeyValuePair<object, object>> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, KeyValuePair<object, object> kvp)
+            => _onAdd?.Invoke(elementId, kvp);
+
+        public void OnRemove(uint elementId, KeyValuePair<object, object> kvp)
+            => _onRemove?.Invoke(elementId, kvp);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IDictionaryObserver<TKey, TValue> : IObserverBase
+    {
+        void OnAdd(uint elementId, KeyValuePair<TKey, TValue> kvp);
+        void OnRemove(uint elementId, KeyValuePair<TKey, TValue> kvp);
+    }
+
+    public class DictionaryObserver<TKey, TValue> : IDictionaryObserver<TKey, TValue>
+    {
+        private Action<uint, KeyValuePair<TKey, TValue>> _onAdd;
+        private Action<uint, KeyValuePair<TKey, TValue>> _onRemove;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public DictionaryObserver(Action<uint, KeyValuePair<TKey, TValue>> onAdd = default, Action<uint, KeyValuePair<TKey, TValue>> onRemove = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onAdd = onAdd;
+            _onRemove = onRemove;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnAdd(uint elementId, KeyValuePair<TKey, TValue> element)
+            => _onAdd?.Invoke(elementId, element);
+
+        public void OnRemove(uint elementId, KeyValuePair<TKey, TValue> element)
+            => _onRemove?.Invoke(elementId, element);
+
+        public void OnDispose()
+            => _onDispose?.Invoke();
+
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IBatchObserver<in T> : IObserverBase where T : IOperation
+    {
+        void OnNext(IReadOnlyList<T> operations);
+    }
+
+    public class BatchObserver<T> : IBatchObserver<T> where T : IOperation
+    {
+        private Action<IReadOnlyList<T>> _onNext;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public BatchObserver(Action<IReadOnlyList<T>> onNext = default, Action onDispose = default, Action<Exception> onError = default)
+        {
+            _onNext = onNext;
+            _onDispose = onDispose;
+            _onError = onError;
+        }
+
+        public void OnNext(IReadOnlyList<T> args)
+        {
+            try
+            {
+                _onNext?.Invoke(args);
+            }
+            catch (Exception exc)
+            {
+                OnError(exc);
+            }
+        }
+
+        public void OnDispose() => _onDispose?.Invoke();
+        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+    }
+}

package/Runtime/Observers.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4e4260e3c4032c642bec85861a525538

package/Runtime/Operators/BatchOperator.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public interface IBatchOp<T> : IOperation where T : IOperation
+    {
+        IReadOnlyList<T> operations { get; set; }
+    }
+
+    public struct BatchOp<T> : IBatchOp<T> where T : IOperation
+    {
+        public IObservable<T> source { get; set; }
+        public IReadOnlyList<T> operations { get; set; }
+
+        IObservable<IOperation> IOperation.source => (IObservable<IOperation>)source;
+    }
+
+    // public class BatchOperator<T> : ObservableBase<IBatchObserver<T>, BatchOp<T>>, IBatchOperand<T>, IBatchObservable<T> where T : IOperation
+    // {
+    //     private Func<IBatchOperand<T>, IInitializationOperationsProvider<T>> _generateOperator;
+    //     private IInitializationOperationsProvider<T> _operator;
+    //     private bool _active = false;
+
+    //     public BatchOperator(ObservationContext context, Func<IBatchOperand<T>, IInitializationOperationsProvider<T>> generateOperator) : base(context)
+    //     {
+    //         _generateOperator = generateOperator;
+    //     }
+
+    //     protected override void OnFirstObserverAdded()
+    //     {
+    //         _active = true;
+    //         _operator = _generateOperator.Invoke(this);
+    //     }
+
+    //     protected override void OnLastObserverRemoved()
+    //     {
+    //         _active = false;
+    //         _operator?.Dispose();
+    //         _operator = null;
+    //     }
+
+    //     protected override void DisposeInternal()
+    //     {
+    //         _operator?.Dispose();
+    //         _operator = null;
+    //     }
+
+    //     void IBatchOperand<T>.EnqueuePendingOperation(IReadOnlyList<T> operation)
+    //         => EnqueuePendingOperation(new() { source = this, operations = operation });
+
+    //     void IOperand.OnError(Exception error)
+    //         => OnError(error);
+
+    //     void IOperand.OnDisposed()
+    //     {
+    //         if (!_active)
+    //             return;
+
+    //         Dispose();
+    //     }
+
+    //     protected override IEnumerable<BatchOp<T>> GetInitializationOperations()
+    //     {
+    //         yield return new BatchOp<T>() { source = this, operations = _operator.GetInitializationOperations() };
+    //     }
+
+    //     protected override void SendOperation(IBatchObserver<T> observer, BatchOp<T> operation)
+    //         => observer.OnNext(operation.operations);
+    // }
+}

package/Runtime/Operators/BatchOperator.cs.meta

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

package/Runtime/Operators/CollectionOperator.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace ObserveThing
+{
+    public class CollectionOperator<T> : Operator<ObservableCollection<T>>, ICollectionObservable<T>
+    {
+        public CollectionOperator(ObservationContext context, Func<ObservableCollection<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+
+        public IDisposable Subscribe(ICollectionObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+    }
+}

package/Runtime/Operators/CollectionOperator.cs.meta

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

package/Runtime/Operators/DictionaryOperator.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class DictionaryOperator<TKey, TValue> : Operator<ObservableDictionary<TKey, TValue>>, IDictionaryObservable<TKey, TValue>
+    {
+        public DictionaryOperator(ObservationContext context, Func<ObservableDictionary<TKey, TValue>, IDisposable> generateOperator) : base(context, generateOperator) { }
+
+        public IDisposable Subscribe(IDictionaryObserver<TKey, TValue> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IDictionaryObservable<TKey, TValue>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IDictionaryObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IDictionaryObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver<KeyValuePair<TKey, TValue>> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable<KeyValuePair<TKey, TValue>>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+    }
+}

package/Runtime/Operators/DictionaryOperator.cs.meta

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

package/Runtime/Operators/IInitializationOperationsProvider.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public interface IInitializationOperationsProvider<T> : IDisposable where T : IOperation
+    {
+        IEnumerable<T> GetInitializationOperations();
+    }
+}

package/Runtime/Operators/IInitializationOperationsProvider.cs.meta

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

package/Runtime/Operators/ListOperator.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace ObserveThing
+{
+    public class ListOperator<T> : Operator<ObservableList<T>>, IListObservable<T>
+    {
+        public ListOperator(ObservationContext context, Func<ObservableList<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+
+        public IDisposable Subscribe(IListObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IListObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IListObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IListObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IObserver<IOperation> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IObservable<IOperation>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+    }
+}

package/Runtime/Operators/ListOperator.cs.meta

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