com.fofx.observething 1.1.0-dev.36048653905 → 1.1.1-dev.161

package/Runtime/{Operators/IInitializationOperationsProvider.cs → IInitializationOperationsProvider.cs}

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

package/Runtime/{IObservable.cs → Observables/IObservable.cs}

@@ -3,13 +3,22 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public interface IObservable<out T> where T : IOperation
+    public interface IObservable
     {
         ObservationContext context { get; }
-        IDisposable Subscribe(IObserver<T> observer, bool immediate = default, uint? priority = default);
     }
 
-    public interface IValueObservable : IObservable<IOperation>
+    public interface IEventStreamObservable : IObservable
+    {
+        IDisposable Subscribe(IEventStreamObserver observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IEventStreamObservable<out T> : IEventStreamObservable
+    {
+        IDisposable Subscribe(IEventStreamObserver<T> observer, bool immediate = default, uint? priority = default);
+    }
+
+    public interface IValueObservable : IObservable
     {
         IDisposable Subscribe(IValueObserver observer, bool immediate = default, uint? priority = default);
     }
@@ -19,7 +28,7 @@ namespace ObserveThing
         IDisposable Subscribe(IValueObserver<T> observer, bool immediate = default, uint? priority = default);
     }
 
-    public interface ICollectionObservable : IObservable<IOperation>
+    public interface ICollectionObservable : IObservable
     {
         IDisposable Subscribe(ICollectionObserver observer, bool immediate = default, uint? priority = default);
     }
@@ -58,9 +67,4 @@ namespace ObserveThing
     {
         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/{Implementations/ObservableBase.cs → Observables/Observable.cs}

@@ -4,18 +4,11 @@ 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
+    public abstract class Observable<TObserver, TOperation> : IObservable, IDisposable where TObserver : IObserver
     {
         private class ObserverData : IPendingObserver, IDisposable
         {
-            public IObserverBase observer { get; }
+            public IObserver observer { get; }
             public bool immediate { get; }
             public uint priority { get; }
             public bool priorityAllocated { get; }
@@ -25,7 +18,7 @@ namespace ObserveThing
             private Action<TOperation> _sendOperation;
             private Action<ObserverData> _onDispose;
 
-            public ObserverData(IObserverBase observer, bool immediate, uint priority, bool priorityAllocated, Action<TOperation> sendOperation, Action<ObserverData> onDispose)
+            public ObserverData(IObserver observer, bool immediate, uint priority, bool priorityAllocated, Action<TOperation> sendOperation, Action<ObserverData> onDispose)
             {
                 this.observer = observer;
                 this.immediate = immediate;
@@ -74,9 +67,9 @@ namespace ObserveThing
 
         private List<ObserverData> _observers = new List<ObserverData>();
 
-        public ObservableBase(ObservationContext context)
+        public Observable(ObservationContext context)
         {
-            this.context = context ?? Settings.DefaultObservationContext;
+            this.context = context ?? ObservationDefaults.DefaultObservationContext;
         }
 
         private void HandleObserverDisposed(ObserverData data)
@@ -118,10 +111,7 @@ namespace ObserveThing
 
         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)
+        private IDisposable AddObserverInternal(IObserver observer, bool immediate, uint? priority, Action<TOperation> sendOperation)
         {
             if (disposed)
                 throw new ObjectDisposedException(GetType().Name);
@@ -149,9 +139,6 @@ namespace ObserveThing
         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)

package/Runtime/{Implementations → Observables}/ObservableCollection.cs

@@ -5,24 +5,15 @@ using System.Linq;
 
 namespace ObserveThing
 {
-    public interface ICollectionOp : IOperation
+    public struct CollectionOp<T>
     {
-        object element { get; }
-        uint elementId { get; }
-        bool isRemove { get; }
+        public ICollectionObservable<T> source;
+        public T element;
+        public uint elementId;
+        public bool isRemove;
     }
 
-    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>
+    public class ObservableCollection<T> : Observable<ICollectionObserver<T>, CollectionOp<T>>, ICollectionObservable<T>, IEnumerable<T>
     {
         IEnumerator<T> IEnumerable<T>.GetEnumerator()
             => _collection.Values.GetEnumerator();

package/Runtime/{Implementations → Observables}/ObservableDictionary.cs

@@ -5,27 +5,16 @@ using System.Linq;
 
 namespace ObserveThing
 {
-    public interface IDictionaryOp : IOperation
+    public struct DictionaryOp<TKey, TValue>
     {
-        uint elementId { get; }
-        object key { get; }
-        object value { get; }
-        bool isRemove { get; }
+        public IDictionaryObservable<TKey, TValue> source;
+        public uint elementId;
+        public TKey key;
+        public TValue value;
+        public bool isRemove;
     }
 
-    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 class ObservableDictionary<TKey, TValue> : Observable<IDictionaryObserver<TKey, TValue>, DictionaryOp<TKey, TValue>>, IDictionaryObservable<TKey, TValue>, IEnumerable<KeyValuePair<TKey, TValue>>
     {
         public TValue this[TKey key]
         {

package/Runtime/{Implementations/Observable.cs → Observables/ObservableEventStream.cs}

@@ -1,13 +1,14 @@
 
+using System;
 using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class Observable<T> : ObservableBase<IObserver<T>, T> where T : IOperation
+    public class ObservableEventStream<T> : Observable<IEventStreamObserver<T>, T>, IEventStreamObservable<T>
     {
         private IInitializationOperationsProvider<T> _initializationOperationsProvider;
 
-        public Observable(ObservationContext context, IInitializationOperationsProvider<T> initializationOperationsProvider) : base(context)
+        public ObservableEventStream(ObservationContext context, IInitializationOperationsProvider<T> initializationOperationsProvider) : base(context)
         {
             _initializationOperationsProvider = initializationOperationsProvider;
         }
@@ -21,10 +22,17 @@ namespace ObserveThing
                 yield return op;
         }
 
-        protected override void SendOperation(IObserver<T> observer, T operation)
+        protected override void SendOperation(IEventStreamObserver<T> observer, T operation)
             => observer.OnNext(operation);
 
         public void EnqueueOperation(T operation)
             => EnqueuePendingOperation(operation);
+
+        public IDisposable Subscribe(IEventStreamObserver observer, bool immediate = false, uint? priority = null)
+            => Subscribe(new EventStreamObserver<T>(
+                onNext: x => observer.OnNext(x),
+                onDispose: observer.OnDispose,
+                onError: observer.OnError
+            ), immediate, priority);
     }
 }

package/Runtime/{Implementations → Observables}/ObservableList.cs

@@ -4,26 +4,16 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public interface IListOp : IOperation
+    public struct ListOp<T>
     {
-        uint elementId { get; }
-        int index { get; }
-        object element { get; }
-        bool isRemove { get; }
-    }
-
-    public struct ListOp<T> : IListOp
-    {
-        public IObservable<IOperation> source { get; set; }
+        public IListObservable<T> 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 class ObservableList<T> : Observable<IListObserver<T>, ListOp<T>>, IListObservable<T>, IEnumerable<T>
     {
         public T this[int index]
         {

package/Runtime/{Implementations → Observables}/ObservableSet.cs

@@ -5,24 +5,15 @@ using System.Linq;
 
 namespace ObserveThing
 {
-    public interface ISetOp : IOperation
+    public struct SetOp<T>
     {
-        uint elementId { get; }
-        object element { get; }
-        bool isRemove { get; }
+        public ISetObservable<T> source;
+        public uint elementId;
+        public T element;
+        public bool isRemove;
     }
 
-    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 class ObservableSet<T> : Observable<ISetObserver<T>, SetOp<T>>, ISetObservable<T>, IEnumerable<T>
     {
         public int count => _set.Count;
 

package/Runtime/{Implementations → Observables}/ObservableValue.cs

@@ -3,20 +3,13 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public interface IValueOp : IOperation
+    public struct ValueOp<T>
     {
-        object value { get; }
+        public IValueObservable<T> source;
+        public T value;
     }
 
-    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 class ObservableValue<T> : Observable<IValueObserver<T>, ValueOp<T>>, IValueObservable<T>
     {
         public T value
         {

package/Runtime/Observables.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9f93943471db6f8418590f3f7da7950f
+guid: e8d0c3cfd1121d2438fb3dc60ce9a8ba
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/ObservationDefaults.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace ObserveThing
+{
+    public static class ObservationDefaults
+    {
+        public static Action<Exception> DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        public static ObservationContext DefaultObservationContext = new ObservationContext();
+    }
+}

package/Runtime/ObservationDefaults.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 023bc9be187f816429b10e4e3ff95271

package/Runtime/Observers.cs

@@ -3,30 +3,51 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public static class Settings
+    public interface IObserver
     {
-        public static Action<Exception> DefaultExceptionHandler = UnityEngine.Debug.LogException;
-        public static ObservationContext DefaultObservationContext = new ObservationContext();
+        void OnError(Exception exc);
+        void OnDispose();
     }
 
-    public interface IObserverBase
+    public interface IEventStreamObserver : IObserver
     {
-        void OnError(Exception exc);
-        void OnDispose();
+        void OnNext(object value);
     }
 
-    public interface IObserver<in T> : IObserverBase where T : IOperation
+    public class EventStreamObserver : IValueObserver
+    {
+        private Action<object> _onNext;
+        private Action _onDispose;
+        private Action<Exception> _onError;
+
+        public EventStreamObserver(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 ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
+    }
+
+    public interface IEventStreamObserver<in T> : IObserver
     {
         void OnNext(T operation);
     }
 
-    public class Observer<T> : IObserver<T> where T : IOperation
+    public class EventStreamObserver<T> : IEventStreamObserver<T>
     {
         private Action<T> _onNext;
         private Action _onDispose;
         private Action<Exception> _onError;
 
-        public Observer(Action<T> onNext = default, Action onDispose = default, Action<Exception> onError = default)
+        public EventStreamObserver(Action<T> onNext = default, Action onDispose = default, Action<Exception> onError = default)
         {
             _onNext = onNext;
             _onDispose = onDispose;
@@ -46,10 +67,10 @@ namespace ObserveThing
         }
 
         public void OnDispose() => _onDispose?.Invoke();
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IValueObserver : IObserverBase
+    public interface IValueObserver : IObserver
     {
         void OnNext(object value);
     }
@@ -73,10 +94,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IValueObserver<in T> : IObserverBase
+    public interface IValueObserver<in T> : IObserver
     {
         void OnNext(T value);
     }
@@ -100,10 +121,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface ICollectionObserver : IObserverBase
+    public interface ICollectionObserver : IObserver
     {
         void OnAdd(uint elementId, object element);
         void OnRemove(uint elementId, object element);
@@ -133,10 +154,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface ICollectionObserver<in T> : IObserverBase
+    public interface ICollectionObserver<in T> : IObserver
     {
         void OnAdd(uint elementId, T element);
         void OnRemove(uint elementId, T element);
@@ -166,10 +187,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IListObserver : IObserverBase
+    public interface IListObserver : IObserver
     {
         void OnAdd(uint elementId, int index, object element);
         void OnRemove(uint elementId, int index, object element);
@@ -199,10 +220,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IListObserver<in T> : IObserverBase
+    public interface IListObserver<in T> : IObserver
     {
         void OnAdd(uint elementId, int index, T element);
         void OnRemove(uint elementId, int index, T element);
@@ -232,10 +253,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface ISetObserver : IObserverBase
+    public interface ISetObserver : IObserver
     {
         void OnAdd(uint elementId, object element);
         void OnRemove(uint elementId, object element);
@@ -265,10 +286,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface ISetObserver<in T> : IObserverBase
+    public interface ISetObserver<in T> : IObserver
     {
         void OnAdd(uint elementId, T element);
         void OnRemove(uint elementId, T element);
@@ -298,10 +319,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IDictionaryObserver : IObserverBase
+    public interface IDictionaryObserver : IObserver
     {
         void OnAdd(uint elementId, KeyValuePair<object, object> kvp);
         void OnRemove(uint elementId, KeyValuePair<object, object> kvp);
@@ -331,10 +352,10 @@ namespace ObserveThing
         public void OnDispose()
             => _onDispose?.Invoke();
 
-        public void OnError(Exception error) => (_onError ?? Settings.DefaultExceptionHandler)?.Invoke(error);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 
-    public interface IDictionaryObserver<TKey, TValue> : IObserverBase
+    public interface IDictionaryObserver<TKey, TValue> : IObserver
     {
         void OnAdd(uint elementId, KeyValuePair<TKey, TValue> kvp);
         void OnRemove(uint elementId, KeyValuePair<TKey, TValue> kvp);
@@ -364,40 +385,6 @@ namespace ObserveThing
         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);
+        public void OnError(Exception error) => (_onError ?? ObservationDefaults.DefaultExceptionHandler)?.Invoke(error);
     }
 }