com.fofx.observething 1.0.0 → 1.1.0

package/Runtime/Observables/OrderByObservable.cs

@@ -1,116 +1,115 @@
-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();
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+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

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

package/Runtime/Observables/SelectCollectionObservable.cs

@@ -1,29 +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();
-        }
-    }
+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

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

package/Runtime/Observables/SelectListObservable.cs

@@ -1,29 +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();
-        }
-    }
+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

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

package/Runtime/Observables/SelectManyObservable.cs

@@ -1,78 +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();
-        }
-    }
+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

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

package/Runtime/Observables/SelectValueObservable.cs

@@ -1,28 +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();
-        }
-    }
+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

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

package/Runtime/Observables/SkipWhileObservable.cs

@@ -1,32 +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();
-        }
-    }
+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

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