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

package/Runtime/Operators/{ValueOperator.cs → Factories/ValueOperator.cs}

@@ -2,9 +2,9 @@ using System;
 
 namespace ObserveThing
 {
-    public class ValueOperator<T> : Operator<ObservableValue<T>>, IValueObservable<T>
+    public class ValueOperatorFactory<T> : OperatorFactory<ObservableValue<T>>, IValueObservable<T>
     {
-        public ValueOperator(ObservationContext context, Func<ObservableValue<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+        public ValueOperatorFactory(ObservationContext context, Func<ObservableValue<T>, IDisposable> factory) : base(context, factory) { }
 
         public IDisposable Subscribe(IValueObserver<T> observer, bool immediate = false, uint? priority = null)
         {
@@ -19,12 +19,5 @@ namespace ObserveThing
             var subscription = ((IValueObservable)_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/{Implementations.meta → Operators/Factories.meta}

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

package/Runtime/{Observables/FirstObservable.cs → Operators/FirstOperator.cs}

@@ -3,14 +3,14 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class FirstObservable<T> : IDisposable
+    public class FirstOperator<T> : IDisposable
     {
         private ObservableValue<(bool found, T value)> _operand;
         private List<(uint id, T value)> _sortedList = new List<(uint id, T value)>();
         private (uint id, T value) _latest;
         private IDisposable _subscriptions;
 
-        public FirstObservable(ICollectionObservable<T> source, Func<T, IValueObservable<bool>> validate, ObservableValue<(bool found, T value)> operand)
+        public FirstOperator(ICollectionObservable<T> source, Func<T, IValueObservable<bool>> validate, ObservableValue<(bool found, T value)> operand)
         {
             _operand = operand;
             _subscriptions = source.ObservableWhere(x => validate(x)).SubscribeWithId(

package/Runtime/{Observables/IndexOfObservable.cs → Operators/IndexOfOperator.cs}

@@ -3,14 +3,14 @@ using System.Collections.Generic;
 
 namespace ObserveThing
 {
-    public class IndexOfObservable<T> : IDisposable
+    public class IndexOfOperator<T> : IDisposable
     {
         private ObservableValue<(bool found, int index)> _operand;
         private T _latest = default;
         private List<T> _list = new List<T>();
         private IDisposable _subscriptions;
 
-        public IndexOfObservable(IListObservable<T> source, IValueObservable<T> value, ObservableValue<(bool found, int index)> operand)
+        public IndexOfOperator(IListObservable<T> source, IValueObservable<T> value, ObservableValue<(bool found, int index)> operand)
         {
             _operand = operand;
             _subscriptions = new ComposedDisposable(

package/Runtime/Operators/OperationStreamOperator.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ValueEventStreamOperator<T, TOperation> : IInitializationOperationsProvider<TOperation>, IDisposable
+    {
+        private IValueObservable<T> _source;
+        private Func<T, TOperation> _constructOperation;
+        private ObservableEventStream<TOperation> _operand;
+        private IDisposable _subscriptions;
+
+        public ValueEventStreamOperator(IValueObservable<T> source, Func<T, TOperation> constructOperation, ObservableEventStream<TOperation> operand)
+        {
+            _source = source;
+            _constructOperation = constructOperation;
+            _operand = operand;
+
+            _subscriptions = _source.Subscribe(
+                onNext: x => operand.EnqueueOperation(_constructOperation(x)),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<TOperation> GetInitializationOperations()
+        {
+            var initOperations = new List<TOperation>();
+            var subscription = _source.Subscribe(x => initOperations.Add(_constructOperation(x)));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CollectionEventStreamOperator<T, TOperation> : IInitializationOperationsProvider<TOperation>, IDisposable
+    {
+        private ICollectionObservable<T> _source;
+        private Func<uint, T, TOperation> _constructAddOperation;
+        private Func<uint, T, TOperation> _constructRemoveOperation;
+        private ObservableEventStream<TOperation> _operand;
+        private IDisposable _subscriptions;
+
+        public CollectionEventStreamOperator(ICollectionObservable<T> source, Func<uint, T, TOperation> constructAddOperation, Func<uint, T, TOperation> constructRemoveOperation, ObservableEventStream<TOperation> operand)
+        {
+            _source = source;
+            _constructAddOperation = constructAddOperation;
+            _constructRemoveOperation = constructRemoveOperation;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) => operand.EnqueueOperation(_constructAddOperation(id, element)),
+                onRemove: (id, element) => operand.EnqueueOperation(_constructRemoveOperation(id, element)),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<TOperation> GetInitializationOperations()
+        {
+            var initOperations = new List<TOperation>();
+            var subscription = _source.SubscribeWithId((id, element) => initOperations.Add(_constructAddOperation(id, element)));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class ListEventStreamOperator<T, TOperation> : IInitializationOperationsProvider<TOperation>, IDisposable
+    {
+        private IListObservable<T> _source;
+        private Func<uint, int, T, TOperation> _constructAddOperation;
+        private Func<uint, int, T, TOperation> _constructRemoveOperation;
+        private ObservableEventStream<TOperation> _operand;
+        private IDisposable _subscriptions;
+
+        public ListEventStreamOperator(IListObservable<T> source, Func<uint, int, T, TOperation> constructAddOperation, Func<uint, int, T, TOperation> constructRemoveOperation, ObservableEventStream<TOperation> operand)
+        {
+            _source = source;
+            _constructAddOperation = constructAddOperation;
+            _constructRemoveOperation = constructRemoveOperation;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, index, element) => operand.EnqueueOperation(_constructAddOperation(id, index, element)),
+                onRemove: (id, index, element) => operand.EnqueueOperation(_constructRemoveOperation(id, index, element)),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<TOperation> GetInitializationOperations()
+        {
+            var initOperations = new List<TOperation>();
+            var subscription = _source.SubscribeWithId((id, index, element) => initOperations.Add(_constructAddOperation(id, index, element)));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class DictionaryEventStreamOperator<TKey, TValue, TOperation> : IInitializationOperationsProvider<TOperation>, IDisposable
+    {
+        private IDictionaryObservable<TKey, TValue> _source;
+        private Func<uint, KeyValuePair<TKey, TValue>, TOperation> _constructAddOperation;
+        private Func<uint, KeyValuePair<TKey, TValue>, TOperation> _constructRemoveOperation;
+        private ObservableEventStream<TOperation> _operand;
+        private IDisposable _subscriptions;
+
+        public DictionaryEventStreamOperator(IDictionaryObservable<TKey, TValue> source, Func<uint, KeyValuePair<TKey, TValue>, TOperation> constructAddOperation, Func<uint, KeyValuePair<TKey, TValue>, TOperation> constructRemoveOperation, ObservableEventStream<TOperation> operand)
+        {
+            _source = source;
+            _constructAddOperation = constructAddOperation;
+            _constructRemoveOperation = constructRemoveOperation;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, kvp) => operand.EnqueueOperation(_constructAddOperation(id, kvp)),
+                onRemove: (id, kvp) => operand.EnqueueOperation(_constructRemoveOperation(id, kvp)),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<TOperation> GetInitializationOperations()
+        {
+            var initOperations = new List<TOperation>();
+            var subscription = _source.SubscribeWithId((id, kvp) => initOperations.Add(_constructAddOperation(id, kvp)));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class SetEventStreamOperator<T, TOperation> : IInitializationOperationsProvider<TOperation>, IDisposable
+    {
+        private ISetObservable<T> _source;
+        private Func<uint, T, TOperation> _constructAddOperation;
+        private Func<uint, T, TOperation> _constructRemoveOperation;
+        private ObservableEventStream<TOperation> _operand;
+        private IDisposable _subscriptions;
+
+        public SetEventStreamOperator(ISetObservable<T> source, Func<uint, T, TOperation> constructAddOperation, Func<uint, T, TOperation> constructRemoveOperation, ObservableEventStream<TOperation> operand)
+        {
+            _source = source;
+            _constructAddOperation = constructAddOperation;
+            _constructRemoveOperation = constructRemoveOperation;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) => operand.EnqueueOperation(_constructAddOperation(id, element)),
+                onRemove: (id, element) => operand.EnqueueOperation(_constructRemoveOperation(id, element)),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<TOperation> GetInitializationOperations()
+        {
+            var initOperations = new List<TOperation>();
+            var subscription = _source.SubscribeWithId((id, element) => initOperations.Add(_constructAddOperation(id, element)));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}