com.fofx.observething 1.0.0

package/Runtime/Observables/ThenObservable.cs

@@ -0,0 +1,209 @@
+using System;
+
+namespace ObserveThing
+{
+    public class ThenValueObservable<T> : IDisposable
+    {
+        private IValueObservable<T> _source;
+        private IValueObserver<T> _then;
+        private ObservableValue<T> _operand;
+        private IDisposable _subscriptions;
+
+        public ThenValueObservable(IValueObservable<T> source, IValueObserver<T> then, ObservableValue<T> operand)
+        {
+            _source = source;
+            _then = then;
+            _operand = operand;
+            _subscriptions = _source.Subscribe(
+                onNext: x =>
+                {
+                    _then.OnNext(x);
+                    _operand.value = x;
+                },
+                onError: exc =>
+                {
+                    _then.OnError(exc);
+                    _operand.OnError(exc);
+                },
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _then.OnDispose();
+            _operand.Dispose();
+        }
+    }
+
+    public class ThenCollectionObservable<T> : IDisposable
+    {
+        private ICollectionObservable<T> _source;
+        private ICollectionObserver<T> _then;
+        private ObservableCollection<T> _operand;
+        private IDisposable _subscriptions;
+
+        public ThenCollectionObservable(ICollectionObservable<T> source, ICollectionObserver<T> then, ObservableCollection<T> operand)
+        {
+            _source = source;
+            _then = then;
+            _operand = operand;
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) =>
+                {
+                    then.OnAdd(id, element);
+                    operand.Add(id, element);
+                },
+                onRemove: (id, element) =>
+                {
+                    then.OnRemove(id, element);
+                    operand.Remove(id);
+                },
+                onError: exc =>
+                {
+                    _then.OnError(exc);
+                    _operand.OnError(exc);
+                },
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _then.OnDispose();
+            _operand.Dispose();
+        }
+    }
+
+    public class ThenListObservable<T> : IDisposable
+    {
+        private IListObservable<T> _source;
+        private IListObserver<T> _then;
+        private ObservableList<T> _operand;
+        private IDisposable _subscriptions;
+
+        public ThenListObservable(IListObservable<T> source, IListObserver<T> then, ObservableList<T> operand)
+        {
+            _source = source;
+            _then = then;
+            _operand = operand;
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, index, element) =>
+                {
+                    then.OnAdd(id, index, element);
+                    operand.Insert(index, element);
+                },
+                onRemove: (id, index, element) =>
+                {
+                    then.OnRemove(id, index, element);
+                    operand.RemoveAt(index);
+                },
+                onError: exc =>
+                {
+                    _then.OnError(exc);
+                    _operand.OnError(exc);
+                },
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _then.OnDispose();
+            _operand.Dispose();
+        }
+    }
+
+    public class ThenSetObservable<T> : IDisposable
+    {
+        private ISetObservable<T> _source;
+        private ISetObserver<T> _then;
+        private ObservableSet<T> _operand;
+        private IDisposable _subscriptions;
+
+        public ThenSetObservable(ISetObservable<T> source, ISetObserver<T> then, ObservableSet<T> operand)
+        {
+            _source = source;
+            _then = then;
+            _operand = operand;
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, element) =>
+                {
+                    then.OnAdd(id, element);
+                    operand.Add(element);
+                },
+                onRemove: (id, element) =>
+                {
+                    then.OnRemove(id, element);
+                    operand.Remove(element);
+                },
+                onError: exc =>
+                {
+                    _then.OnError(exc);
+                    _operand.OnError(exc);
+                },
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _then.OnDispose();
+            _operand.Dispose();
+        }
+    }
+
+    public class ThenDictionaryObservable<TKey, TValue> : IDisposable
+    {
+        private IDictionaryObservable<TKey, TValue> _source;
+        private IDictionaryObserver<TKey, TValue> _then;
+        private ObservableDictionary<TKey, TValue> _operand;
+        private IDisposable _subscriptions;
+
+        public ThenDictionaryObservable(IDictionaryObservable<TKey, TValue> source, IDictionaryObserver<TKey, TValue> then, ObservableDictionary<TKey, TValue> operand)
+        {
+            _source = source;
+            _then = then;
+            _operand = operand;
+            _subscriptions = _source.SubscribeWithId(
+                onAdd: (id, kvp) =>
+                {
+                    then.OnAdd(id, kvp);
+                    operand.Add(kvp.Key, kvp.Value);
+                },
+                onRemove: (id, kvp) =>
+                {
+                    then.OnRemove(id, kvp);
+                    operand.Remove(kvp.Key);
+                },
+                onError: exc =>
+                {
+                    _then.OnError(exc);
+                    _operand.OnError(exc);
+                },
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _then.OnDispose();
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/ThenObservable.cs.meta

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

package/Runtime/Observables/ToDictionaryObservable.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ToDictionaryObservable<T, TKey, TValue> : IDisposable
+    {
+        private IDisposable _subscription;
+        private ObservableDictionary<TKey, TValue> _operand;
+
+        public ToDictionaryObservable(ICollectionObservable<T> source, Func<T, IValueObservable<TKey>> selectKey, Func<T, IValueObservable<TValue>> selectValue, ObservableDictionary<TKey, TValue> operand)
+        {
+            _operand = operand;
+            _subscription = source.ObservableSelect(
+                x => Observables.ObservableCombineValues(
+                    selectKey(x),
+                    selectValue(x),
+                    (key, value) => new KeyValuePair<TKey, TValue>(key, value)
+                )
+            ).Subscribe(
+                onAdd: kvp => _operand.Add(kvp.Key, kvp.Value),
+                onRemove: kvp => _operand.Remove(kvp.Key),
+                onError: operand.OnError,
+                onDispose: Dispose
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/ToDictionaryObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 684b042b1e76a7342b93df51ad9c7e49

package/Runtime/Observables/TrackObservable.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class TrackObservable<TKey, TValue> : IDisposable
+    {
+        private ObservableValue<(bool keyPresent, TValue value)> _operand;
+        private Dictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();
+        private TKey _key = default;
+        private bool _present = false;
+
+        private IDisposable _subscriptions;
+
+        public TrackObservable(IDictionaryObservable<TKey, TValue> source, IValueObservable<TKey> key, ObservableValue<(bool keyPresent, TValue value)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source.Subscribe(
+                    onAdd: kvp =>
+                    {
+                        _dict.Add(kvp.Key, kvp.Value);
+                        if (Equals(kvp.Key, _key))
+                        {
+                            _present = true;
+                            _operand.value = new(_present, kvp.Value);
+                        }
+                    },
+                    onRemove: kvp =>
+                    {
+                        if (_dict.Remove(kvp.Key) && Equals(kvp.Key, _key))
+                        {
+                            _present = false;
+                            _operand.value = new(_present, default);
+                        }
+                    },
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                key.Subscribe(
+                    onNext: key =>
+                    {
+                        _key = key;
+
+                        if (_dict.TryGetValue(_key, out var value))
+                        {
+                            _present = true;
+                            _operand.value = new(_present, value);
+                        }
+                        else
+                        {
+                            _present = false;
+                            _operand.value = new(_present, default);
+                        }
+                    },
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/TrackObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 784847fbcbcf661478ba0c44c0fa1e72

package/Runtime/Observables/UnwrapCollectionObservable.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class UnwrapCollectionObservable<T> : IDisposable
+    {
+        private ObservableCollection<T> _operand;
+        private Dictionary<uint, EntryData> _dataById = new Dictionary<uint, EntryData>();
+        private IDisposable _subscriptions;
+
+        private class EntryData
+        {
+            public IDisposable subscription;
+            public bool initialized;
+        }
+
+        public UnwrapCollectionObservable(ICollectionObservable<IValueObservable<T>> source, ObservableCollection<T> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(new CollectionObserver<IValueObservable<T>>(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onError: operand.OnError,
+                onDispose: Dispose
+            ), immediate: true);
+        }
+
+        private void HandleAdd(uint id, IValueObservable<T> observable)
+        {
+            var data = new EntryData();
+            _dataById.Add(id, data);
+            data.subscription = observable.Subscribe(new ValueObserver<T>(
+                onNext: x =>
+                {
+                    if (data.initialized)
+                        _operand.Remove(id);
+
+                    data.initialized = true;
+                    _operand.Add(id, x);
+                },
+                onError: _operand.OnError
+            ), immediate: true);
+        }
+
+        private void HandleRemove(uint id, IValueObservable<T> observable)
+        {
+            var data = _dataById[id];
+            _dataById.Remove(id);
+            data.subscription.Dispose();
+            _operand.Remove(id);
+        }
+
+        public void Dispose()
+        {
+            foreach (var data in _dataById.Values)
+                data.subscription.Dispose();
+
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/UnwrapCollectionObservable.cs.meta

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

package/Runtime/Observables/UnwrapListObservable.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class UnwrapListObservable<T> : IDisposable
+    {
+        private ObservableList<T> _operand;
+        private List<EntryData> _data = new List<EntryData>();
+        private IDisposable _subscriptions;
+
+        private class EntryData
+        {
+            public IDisposable subscription;
+            public bool initialized;
+        }
+
+        public UnwrapListObservable(IListObservable<IValueObservable<T>> source, ObservableList<T> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private void HandleAdd(int index, IValueObservable<T> element)
+        {
+            var data = new EntryData();
+            _data.Insert(index, data);
+            data.subscription = element.Subscribe(
+                onNext: x =>
+                {
+                    var index = _data.IndexOf(data);
+
+                    if (data.initialized)
+                        _operand.RemoveAt(index);
+
+                    data.initialized = true;
+                    _operand.Insert(index, x);
+                },
+                onError: _operand.OnError,
+                immediate: true
+            );
+        }
+
+        private void HandleRemove(int index, IValueObservable<T> element)
+        {
+            var data = _data[index];
+            _data.RemoveAt(index);
+            data.subscription.Dispose();
+            _operand.RemoveAt(index);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            foreach (var data in _data)
+                data.subscription.Dispose();
+
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/UnwrapListObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 593009250a2863d479f8ea8a62598f91

package/Runtime/Observables/UnwrapValueObservable.cs

@@ -0,0 +1,56 @@
+using System;
+
+namespace ObserveThing
+{
+    public class UnwrapValueObservable<T> : IDisposable
+    {
+        private ObservableValue<T> _operand;
+        private ValueObserver<T> _nestedObserver;
+        private IDisposable _nestedSubscription;
+        private IDisposable _subscriptions;
+
+        public UnwrapValueObservable(IValueObservable<IValueObservable<T>> source, ObservableValue<T> operand)
+        {
+            _operand = operand;
+
+            _nestedObserver = new ValueObserver<T>(
+                onNext: x => operand.value = x,
+                onError: operand.OnError
+            );
+
+            _subscriptions = source.Subscribe(
+                new ValueObserver<IValueObservable<T>>(
+                    onNext: HandleNext,
+                    onDispose: Dispose,
+                    onError: operand.OnError
+                ),
+                immediate: true
+            );
+        }
+
+        private void HandleNext(IValueObservable<T> value)
+        {
+            _nestedSubscription?.Dispose();
+            _nestedSubscription = null;
+
+            if (value == null)
+            {
+                _operand.value = default;
+                return;
+            }
+
+            _nestedSubscription = value.Subscribe(_nestedObserver, immediate: true);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+
+            _nestedSubscription?.Dispose();
+            _nestedSubscription = null;
+
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/UnwrapValueObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 70a4ad018a097bf4494e0ae83c700b8d

package/Runtime/Observables/WhereObservable.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class WhereObservable<T> : IDisposable
+    {
+        private ObservableCollection<T> _operand;
+        private Func<T, IValueObservable<bool>> _where;
+        private Dictionary<uint, EntryData> _dataById = new Dictionary<uint, EntryData>();
+        private IDisposable _subscriptions;
+
+        private class EntryData
+        {
+            public bool initialized;
+            public T value;
+            public bool included;
+            public IDisposable subscription;
+        }
+
+        public WhereObservable(ICollectionObservable<T> source, Func<T, IValueObservable<bool>> where, ObservableCollection<T> operand)
+        {
+            _operand = operand;
+            _where = where;
+            _subscriptions = source.SubscribeWithId(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onDispose: Dispose,
+                onError: _operand.OnError,
+                immediate: true
+            );
+        }
+
+        private void HandleAdd(uint id, T value)
+        {
+            var data = new EntryData() { value = value };
+            _dataById.Add(id, data);
+            data.subscription = _where(value).Subscribe(
+                onNext: included =>
+                {
+                    data.included = included;
+
+                    if (!data.initialized)
+                    {
+                        data.initialized = true;
+
+                        if (!included)
+                            return;
+                    }
+
+                    if (included)
+                    {
+                        _operand.Add(id, data.value);
+                    }
+                    else if (data.initialized)
+                    {
+                        _operand.Remove(id);
+                    }
+                },
+                onError: _operand.OnError,
+                immediate: true
+            );
+        }
+
+        private void HandleRemove(uint id, T value)
+        {
+            var data = _dataById[id];
+            data.subscription.Dispose();
+            _dataById.Remove(id);
+
+            if (data.included)
+                _operand.Remove(id);
+        }
+
+        public void Dispose()
+        {
+            foreach (var data in _dataById.Values)
+                data.subscription.Dispose();
+
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/WhereObservable.cs.meta

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

package/Runtime/Observables/WithPreviousObservable.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace ObserveThing
+{
+    public class WithPreviousObservable<T> : IDisposable
+    {
+        private ObservableValue<(T previous, T current)> _operand;
+        private T _previousValue;
+        private IDisposable _subscriptions;
+
+        public WithPreviousObservable(IValueObservable<T> source, ObservableValue<(T previous, T current)> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onNext: HandleNext,
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private void HandleNext(T value)
+        {
+            var pair = (value, _previousValue);
+            _previousValue = value;
+            _operand.value = pair;
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/WithPreviousObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 899825cfd315d304f8ac10fcd96ff36a