com.fofx.observething 1.0.0

package/Runtime/Observables/IndexOfObservable.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class IndexOfObservable<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)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                value.Subscribe(
+                    onNext: HandleNext,
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source.Subscribe(
+                    onAdd: HandleAdd,
+                    onRemove: HandleRemove,
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        private void HandleAdd(int index, T element)
+        {
+            _list.Insert(index, element);
+            UpdateIndexIfNecessary();
+        }
+
+        private void HandleRemove(int index, T element)
+        {
+            _list.RemoveAt(index);
+            UpdateIndexIfNecessary();
+        }
+
+        private void HandleNext(T value)
+        {
+            _latest = value;
+            UpdateIndexIfNecessary();
+        }
+
+        private void UpdateIndexIfNecessary()
+        {
+            var newIndex = -1;
+
+            for (int i = 0; i < _list.Count; i++)
+            {
+                if (Equals(_latest, _list[i]))
+                {
+                    newIndex = i;
+                    break;
+                }
+            }
+
+            if (newIndex == -1)
+            {
+                _operand.value = default;
+                return;
+            }
+
+            _operand.value = new(true, newIndex);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/IndexOfObservable.cs.meta

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

package/Runtime/Observables/OperationStreamObservable.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ValueOperationStreamObservable<T> : IInitializationOperationsProvider<ValueOp<T>>, IDisposable
+    {
+        private IValueObservable<T> _source;
+        private Observable<ValueOp<T>> _operand;
+        private IDisposable _subscriptions;
+
+        public ValueOperationStreamObservable(IValueObservable<T> source, Observable<ValueOp<T>> operand)
+        {
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = _source.Subscribe(
+                onNext: x => operand.EnqueueOperation(new() { source = _source, value = x }),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<ValueOp<T>> GetInitializationOperations()
+        {
+            var initOperations = new List<ValueOp<T>>();
+            var subscription = _source.Subscribe(x => initOperations.Add(new ValueOp<T>() { source = _source, value = x }));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CollectionOperationStreamObservable<T> : IInitializationOperationsProvider<CollectionOp<T>>, IDisposable
+    {
+        private ICollectionObservable<T> _source;
+        private Observable<CollectionOp<T>> _operand;
+        private IDisposable _subscriptions;
+
+        public CollectionOperationStreamObservable(ICollectionObservable<T> source, Observable<CollectionOp<T>> operand)
+        {
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, element = element, isRemove = false }),
+                onRemove: (id, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, element = element, isRemove = true }),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<CollectionOp<T>> GetInitializationOperations()
+        {
+            var initOperations = new List<CollectionOp<T>>();
+            var subscription = _source.SubscribeWithId((id, element) => initOperations.Add(new CollectionOp<T>() { source = _source, elementId = id, element = element }));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class ListOperationStreamObservable<T> : IInitializationOperationsProvider<ListOp<T>>, IDisposable
+    {
+        private IListObservable<T> _source;
+        private Observable<ListOp<T>> _operand;
+        private IDisposable _subscriptions;
+
+        public ListOperationStreamObservable(IListObservable<T> source, Observable<ListOp<T>> operand)
+        {
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, index, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, index = index, element = element, isRemove = false }),
+                onRemove: (id, index, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, index = index, element = element, isRemove = true }),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<ListOp<T>> GetInitializationOperations()
+        {
+            var initOperations = new List<ListOp<T>>();
+            var subscription = _source.SubscribeWithId((id, index, element) => initOperations.Add(new ListOp<T>() { source = _source, elementId = id, index = index, element = element }));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class DictionaryOperationStreamObservable<TKey, TValue> : IInitializationOperationsProvider<DictionaryOp<TKey, TValue>>, IDisposable
+    {
+        private IDictionaryObservable<TKey, TValue> _source;
+        private Observable<DictionaryOp<TKey, TValue>> _operand;
+        private IDisposable _subscriptions;
+
+        public DictionaryOperationStreamObservable(IDictionaryObservable<TKey, TValue> source, Observable<DictionaryOp<TKey, TValue>> operand)
+        {
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, kvp) => operand.EnqueueOperation(new() { source = _source, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = false }),
+                onRemove: (id, kvp) => operand.EnqueueOperation(new() { source = _source, elementId = id, key = kvp.Key, value = kvp.Value, isRemove = true }),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<DictionaryOp<TKey, TValue>> GetInitializationOperations()
+        {
+            var initOperations = new List<DictionaryOp<TKey, TValue>>();
+            var subscription = _source.SubscribeWithId((id, kvp) => initOperations.Add(new DictionaryOp<TKey, TValue>() { source = _source, elementId = id, key = kvp.Key, value = kvp.Value }));
+            subscription.Dispose();
+ 
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class SetOperationStreamObservable<T> : IInitializationOperationsProvider<SetOp<T>>, IDisposable
+    {
+        private ISetObservable<T> _source;
+        private Observable<SetOp<T>> _operand;
+        private IDisposable _subscriptions;
+
+        public SetOperationStreamObservable(ISetObservable<T> source, Observable<SetOp<T>> operand)
+        {
+            _source = source;
+            _operand = operand;
+
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, element = element, isRemove = false }),
+                onRemove: (id, element) => operand.EnqueueOperation(new() { source = _source, elementId = id, element = element, isRemove = true }),
+                onDispose: Dispose,
+                onError: operand.OnError,
+                immediate: true
+            );
+        }
+
+        public IEnumerable<SetOp<T>> GetInitializationOperations()
+        {
+            var initOperations = new List<SetOp<T>>();
+            var subscription = _source.SubscribeWithId((id, element) => initOperations.Add(new SetOp<T>() { source = _source, elementId = id, element = element }));
+            subscription.Dispose();
+
+            foreach (var op in initOperations)
+                yield return op;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/OperationStreamObservable.cs.meta

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

package/Runtime/Observables/OrderByObservable.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace ObserveThing
+{
+    public class OrderByObservable<T, U> : IDisposable
+    {
+        private ObservableList<T> _operand;
+        private Func<T, IValueObservable<U>> _orderBy;
+        private Func<U, U, int> _compare;
+        private Dictionary<uint, EntryData> _dataById = new Dictionary<uint, EntryData>();
+        private List<EntryData> _order = new List<EntryData>();
+        private IDisposable _subscriptions;
+
+        private class EntryData
+        {
+            public uint id;
+            public T element;
+            public U orderBy;
+            public IDisposable subscription;
+        }
+
+        public OrderByObservable(ICollectionObservable<T> source, Func<T, IValueObservable<U>> orderBy, bool descending, ObservableList<T> operand)
+        {
+            _orderBy = orderBy;
+            _compare = descending ? DescendingCompare : AscendingCompare;
+            _operand = operand;
+            _subscriptions = source.SubscribeWithId(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private int DescendingCompare(U v1, U v2)
+            => Comparer<U>.Default.Compare(v2, v1);
+
+        private int AscendingCompare(U v1, U v2)
+            => Comparer<U>.Default.Compare(v1, v2);
+
+        private void HandleAdd(uint id, T element)
+        {
+            var data = new EntryData()
+            {
+                id = id,
+                element = element
+            };
+
+            _dataById.Add(id, data);
+            data.subscription = _orderBy(element).Subscribe(
+                onNext: x =>
+                {
+                    data.orderBy = x;
+                    Resort(data);
+                },
+                onError: _operand.OnError,
+                immediate: true
+            );
+        }
+
+        private void HandleRemove(uint id, T element)
+        {
+            var data = _dataById[id];
+            int index = _order.IndexOf(data);
+            _dataById.Remove(id);
+            _order.RemoveAt(index);
+            data.subscription.Dispose();
+            _operand.RemoveAt(index);
+        }
+
+        private void Resort(EntryData data)
+        {
+            var originalIndex = _order.IndexOf(data);
+
+            if (originalIndex != -1)
+                _order.RemoveAt(originalIndex);
+
+            int newIndex = -1;
+
+            for (int i = 0; i < _order.Count; i++)
+            {
+                var compareTo = _order[i];
+
+                if (_compare(data.orderBy, compareTo.orderBy) > 0)
+                    continue;
+
+                newIndex = i;
+                break;
+            }
+
+            if (newIndex == -1)
+                newIndex = _order.Count;
+
+            _order.Insert(newIndex, data);
+
+            if (originalIndex != newIndex)
+            {
+                if (originalIndex != -1)
+                    _operand.RemoveAt(originalIndex);
+
+                _operand.Insert(newIndex, data.element);
+            }
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/OrderByObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9767c296c184882418b155dcf5bbabe7

package/Runtime/Observables/SelectCollectionObservable.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace ObserveThing
+{
+    public class SelectCollectionObservable<T, U> : IDisposable
+    {
+        private ObservableCollection<U> _operand;
+        private IDisposable _subscriptions;
+
+        public SelectCollectionObservable(ICollectionObservable<T> source, Func<T, U> select, ObservableCollection<U> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.SubscribeWithId(
+                onAdd: (id, value) => operand.Add(id, select(value)),
+                onRemove: (id, _) => operand.Remove(id),
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/SelectCollectionObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7df358d544ba60a4fbaafcaab5597e92

package/Runtime/Observables/SelectListObservable.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace ObserveThing
+{
+    public class SelectListObservable<T, U> : IDisposable
+    {
+        private ObservableList<U> _operand;
+        private IDisposable _subscriptions;
+
+        public SelectListObservable(IListObservable<T> source, Func<T, U> select, ObservableList<U> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onAdd: (index, value) => _operand.Insert(index, select(value)),
+                onRemove: (index, _) => _operand.RemoveAt(index),
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/SelectListObservable.cs.meta

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

package/Runtime/Observables/SelectManyObservable.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ObserveThing
+{
+    public class SelectManyObservable<T, U> : IDisposable
+    {
+        private class ElementData
+        {
+            public IDisposable subscription;
+            public Dictionary<uint, uint> elementIds = new Dictionary<uint, uint>();
+        }
+
+        private ObservableCollection<U> _operand;
+        private Func<T, ICollectionObservable<U>> _select;
+        private Dictionary<uint, ElementData> _dataById = new Dictionary<uint, ElementData>();
+        private CollectionIdProvider _idProvider;
+        private IDisposable _subscriptions;
+
+        public SelectManyObservable(ICollectionObservable<T> source, Func<T, ICollectionObservable<U>> select, ObservableCollection<U> operand)
+        {
+            _select = select;
+            _operand = operand;
+            _idProvider = new CollectionIdProvider(x => _dataById.Values.Any(y => y.elementIds.ContainsKey(x)));
+            _subscriptions = source.SubscribeWithId(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private void HandleAdd(uint id, T element)
+        {
+            var data = new ElementData();
+            _dataById.Add(id, data);
+            data.subscription = _select(element).SubscribeWithId(
+                onAdd: (subId, subElement) =>
+                {
+                    var newId = _idProvider.GetUnusedId();
+                    data.elementIds.Add(subId, newId);
+                    _operand.Add(newId, subElement);
+                },
+                onRemove: (subId, subElement) =>
+                {
+                    var elementId = data.elementIds[subId];
+                    data.elementIds.Remove(subId);
+                    _operand.Remove(elementId);
+                },
+                onError: _operand.OnError,
+                immediate: true
+            );
+        }
+
+        private void HandleRemove(uint id, T element)
+        {
+            var data = _dataById[id];
+            _dataById.Remove(id);
+            data.subscription.Dispose();
+
+            foreach (var elementId in data.elementIds.Values)
+                _operand.Remove(elementId);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            foreach (var data in _dataById.Values)
+                data.subscription.Dispose();
+
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/SelectManyObservable.cs.meta

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

package/Runtime/Observables/SelectValueObservable.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace ObserveThing
+{
+    public class SelectValueOperator<T, U> : IDisposable
+    {
+        private ObservableValue<U> _operand;
+        private IDisposable _subscriptions;
+
+        public SelectValueOperator(IValueObservable<T> source, Func<T, U> select, ObservableValue<U> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onNext: x => operand.value = select(x),
+                onError: operand.OnError,
+                onDispose: operand.Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/SelectValueObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 11e1e51b831c1e34abed3453cd15be99

package/Runtime/Observables/SkipWhileObservable.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace ObserveThing
+{
+    public class SkipWhileObservable<T> : IDisposable
+    {
+        private ObservableValue<T> _operand;
+        private IDisposable _subscriptions;
+
+        public SkipWhileObservable(IValueObservable<T> source, Func<bool> skipWhile, ObservableValue<T> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onNext: value =>
+                {
+                    if (!skipWhile())
+                        _operand.value = value;
+                },
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/SkipWhileObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7827b68ec45cef44992f41375a48de42