com.fofx.observething 1.0.0

package/Runtime/Observables/CombineValueObservable.cs

@@ -0,0 +1,319 @@
+using System;
+
+namespace ObserveThing
+{
+    public class CombineValueObservable<T1, T2> : IDisposable
+    {
+        private ObservableValue<(T1, T2)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, ObservableValue<(T1, T2)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CombineValueObservable<T1, T2, T3> : IDisposable
+    {
+        private ObservableValue<(T1, T2, T3)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, ObservableValue<(T1, T2, T3)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2, operand.value.Item3),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x, operand.value.Item3),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source3.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CombineValueObservable<T1, T2, T3, T4> : IDisposable
+    {
+        private ObservableValue<(T1, T2, T3, T4)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, ObservableValue<(T1, T2, T3, T4)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2, operand.value.Item3, operand.value.Item4),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x, operand.value.Item3, operand.value.Item4),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source3.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, x, operand.value.Item4),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source4.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CombineValueObservable<T1, T2, T3, T4, T5> : IDisposable
+    {
+        private ObservableValue<(T1, T2, T3, T4, T5)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, ObservableValue<(T1, T2, T3, T4, T5)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x, operand.value.Item3, operand.value.Item4, operand.value.Item5),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source3.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, x, operand.value.Item4, operand.value.Item5),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source4.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, x, operand.value.Item5),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source5.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CombineValueObservable<T1, T2, T3, T4, T5, T6> : IDisposable
+    {
+        private ObservableValue<(T1, T2, T3, T4, T5, T6)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, ObservableValue<(T1, T2, T3, T4, T5, T6)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5, operand.value.Item6),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x, operand.value.Item3, operand.value.Item4, operand.value.Item5, operand.value.Item6),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source3.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, x, operand.value.Item4, operand.value.Item5, operand.value.Item6),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source4.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, x, operand.value.Item5, operand.value.Item6),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source5.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, x, operand.value.Item6),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source6.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+
+    public class CombineValueObservable<T1, T2, T3, T4, T5, T6, T7> : IDisposable
+    {
+        private ObservableValue<(T1, T2, T3, T4, T5, T6, T7)> _operand;
+        private IDisposable _subscriptions;
+
+        public CombineValueObservable(IValueObservable<T1> source1, IValueObservable<T2> source2, IValueObservable<T3> source3, IValueObservable<T4> source4, IValueObservable<T5> source5, IValueObservable<T6> source6, IValueObservable<T7> source7, ObservableValue<(T1, T2, T3, T4, T5, T6, T7)> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source1.Subscribe(
+                    onNext: x => operand.value = new(x, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5, operand.value.Item6, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, x, operand.value.Item3, operand.value.Item4, operand.value.Item5, operand.value.Item6, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source3.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, x, operand.value.Item4, operand.value.Item5, operand.value.Item6, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source4.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, x, operand.value.Item5, operand.value.Item6, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source5.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, x, operand.value.Item6, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source6.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5, x, operand.value.Item7),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source7.Subscribe(
+                    onNext: x => operand.value = new(operand.value.Item1, operand.value.Item2, operand.value.Item3, operand.value.Item4, operand.value.Item5, operand.value.Item6, x),
+                    onError: operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/CombineValueObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 874d12647ce3e0c4d9391a224a9c1a44

package/Runtime/Observables/ConcatObservable.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ConcatObservable<T> : IDisposable
+    {
+        private ObservableCollection<T> _operand;
+        private CollectionIdProvider _idProvider;
+        private Dictionary<uint, uint> _source1IdMap = new Dictionary<uint, uint>();
+        private Dictionary<uint, uint> _source2IdMap = new Dictionary<uint, uint>();
+
+        private IDisposable _subscription;
+
+        public ConcatObservable(ICollectionObservable<T> source1, ICollectionObservable<T> source2, ObservableCollection<T> operand)
+        {
+            _idProvider = new CollectionIdProvider(x => !_source1IdMap.ContainsValue(x) && !_source2IdMap.ContainsValue(x));
+            _operand = operand;
+            _subscription = new ComposedDisposable(
+
+                source1.SubscribeWithId(
+                    onAdd: Source1HandleAdd,
+                    onRemove: Source1HandleRemove,
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                source2.SubscribeWithId(
+                    onAdd: Source2HandleAdd,
+                    onRemove: Source2HandleRemove,
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        private void Source1HandleAdd(uint id, T value)
+        {
+            var newId = _idProvider.GetUnusedId();
+            _source1IdMap.Add(id, newId);
+            _operand.Add(newId, value);
+        }
+
+        private void Source1HandleRemove(uint id, T value)
+        {
+            var newId = _source1IdMap[id];
+            _source1IdMap.Remove(id);
+            _operand.Remove(newId);
+        }
+
+        private void Source2HandleAdd(uint id, T value)
+        {
+            var newId = _idProvider.GetUnusedId();
+            _source2IdMap.Add(id, newId);
+            _operand.Add(newId, value);
+        }
+
+        private void Source2HandleRemove(uint id, T value)
+        {
+            var newId = _source2IdMap[id];
+            _source2IdMap.Remove(id);
+            _operand.Remove(newId);
+        }
+
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _subscription = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/ConcatObservable.cs.meta

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

package/Runtime/Observables/ContainsObservable.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ContainsObservable<T> : IDisposable
+    {
+        private ObservableValue<bool> _operand;
+        private List<T> _list = new List<T>();
+        private T _latest = default;
+        private IDisposable _subscriptions;
+
+        public ContainsObservable(ICollectionObservable<T> source, IValueObservable<T> value, ObservableValue<bool> operand)
+        {
+            _operand = operand;
+            _subscriptions = new ComposedDisposable(
+
+                source.Subscribe(
+                    onAdd: HandleAdd,
+                    onRemove: HandleRemove,
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                ),
+
+                value.Subscribe(
+                    onNext: HandleNext,
+                    onError: _operand.OnError,
+                    onDispose: Dispose,
+                    immediate: true
+                )
+
+            );
+        }
+
+        private void HandleAdd(T element)
+        {
+            _list.Add(element);
+
+            if (_operand.value)
+                return;
+
+            if (Equals(element, _latest))
+                _operand.value = true;
+        }
+
+        private void HandleRemove(T element)
+        {
+            _list.Remove(element);
+
+            if (!_operand.value)
+                return;
+
+            if (Equals(element, _latest) && !_list.Contains(element))
+                _operand.value = false;
+        }
+
+        private void HandleNext(T value)
+        {
+            _latest = value;
+            _operand.value = _list.Contains(value);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/ContainsObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8007fd4897c313b408cb6a42f4583fe8

package/Runtime/Observables/CountObservable.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace ObserveThing
+{
+    public class CountObservable<T> : IDisposable
+    {
+        private ObservableValue<int> _operand;
+        private IDisposable _subscriptions;
+
+        public CountObservable(ICollectionObservable<T> source, ObservableValue<int> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onAdd: _ => operand.value = operand.value + 1,
+                onRemove: _ => operand.value = operand.value - 1,
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/CountObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 453d787470b6b564da4b522d2a6741e1

package/Runtime/Observables/DistinctObservable.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class DistinctObservable<T> : IDisposable
+    {
+        private ObservableSet<T> _operand;
+        private Dictionary<T, int> _countByElement = new Dictionary<T, int>();
+        private IDisposable _subscriptions;
+
+        public DistinctObservable(ICollectionObservable<T> source, ObservableSet<T> operand)
+        {
+            _operand = operand;
+            _subscriptions = source.Subscribe(
+                onAdd: HandleAdd,
+                onRemove: HandleRemove,
+                onError: _operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private void HandleAdd(T value)
+        {
+            bool isNew = !_countByElement.TryGetValue(value, out var count);
+            _countByElement[value] = count + 1;
+
+            if (isNew)
+                _operand.Add(value);
+        }
+
+        private void HandleRemove(T value)
+        {
+            var count = _countByElement[value];
+
+            if (count > 1)
+            {
+                _countByElement[value] = count - 1;
+            }
+            else
+            {
+                _countByElement.Remove(value);
+                _operand.Remove(value);
+            }
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/DistinctObservable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7863e890c2633d14bafff06edee0e7c6

package/Runtime/Observables/FirstObservable.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class FirstObservable<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)
+        {
+            _operand = operand;
+            _subscriptions = source.ObservableWhere(x => validate(x)).SubscribeWithId(
+                onAdd: (id, value) =>
+                {
+                    _sortedList.Add(new(id, value));
+                    _sortedList.Sort((x, y) => x.id.CompareTo(y.id));
+                    SetValueIfNecessary();
+                },
+                onRemove: (id, value) =>
+                {
+                    _sortedList.Remove(new(id, value));
+                    SetValueIfNecessary();
+                },
+                onError: operand.OnError,
+                onDispose: Dispose,
+                immediate: true
+            );
+        }
+
+        private void SetValueIfNecessary()
+        {
+            bool found = _sortedList.Count != 0;
+            var next = _sortedList.Count == 0 ? new(0, default) : _sortedList[0];
+
+            if (_latest.id == next.id && Equals(_latest.value, next.value))
+                return;
+
+            _latest = next;
+            _operand.value = new(found, _latest.value);
+        }
+
+        public void Dispose()
+        {
+            _subscriptions?.Dispose();
+            _subscriptions = null;
+            _operand.Dispose();
+        }
+    }
+}

package/Runtime/Observables/FirstObservable.cs.meta

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