com.fofx.observething 1.0.0

package/Runtime/Operators/ObservableOperator.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class ObservableOperator<T> : IObservable<T>, IInitializationOperationsProvider<T> where T : IOperation
+    {
+        public ObservationContext context { get; }
+
+        private Func<Observable<T>, IInitializationOperationsProvider<T>> _generateOperator;
+        protected Observable<T> _observable { get; private set; }
+        private IInitializationOperationsProvider<T> _operator;
+        private bool _active = false;
+        private List<IObserverBase> _observers = new List<IObserverBase>();
+        private bool _disposed;
+
+        public ObservableOperator(ObservationContext context, Func<Observable<T>, IInitializationOperationsProvider<T>> generateOperator)
+        {
+            this.context = context;
+            _generateOperator = generateOperator;
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            _disposed = true;
+
+            _operator?.Dispose();
+            _operator = default;
+
+            _observable?.Dispose();
+            _observable = default;
+        }
+
+        protected void AddObserver(IObserverBase observer)
+        {
+            _observers.Add(observer);
+
+            if (_active)
+                return;
+
+            _active = true;
+            _observable = new Observable<T>(context, this);
+            _operator = _generateOperator(_observable);
+        }
+
+        protected void RemoveObserver(IObserverBase observer)
+        {
+            _observers.Remove(observer);
+
+            if (_active && _observers.Count == 0)
+            {
+                _active = false;
+
+                _operator.Dispose();
+                _operator = default;
+
+                _observable.Dispose();
+                _observable = default;
+            }
+        }
+
+        public IDisposable Subscribe(IObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = _observable.Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IEnumerable<T> GetInitializationOperations()
+            => _operator.GetInitializationOperations();
+    }
+}

package/Runtime/Operators/ObservableOperator.cs.meta

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

package/Runtime/Operators/Operator.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+
+namespace ObserveThing
+{
+    public class Operator<T> where T : class, IDisposable, new()
+    {
+        public ObservationContext context { get; }
+
+        private Func<T, IDisposable> _generateOperator;
+        protected T _observable { get; private set; }
+        private IDisposable _operator;
+        private bool _active = false;
+        private List<IObserverBase> _observers = new List<IObserverBase>();
+        private bool _disposed;
+
+        public Operator(ObservationContext context, Func<T, IDisposable> generateOperator)
+        {
+            this.context = context;
+            _generateOperator = generateOperator;
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            _disposed = true;
+
+            _operator?.Dispose();
+            _operator = default;
+
+            _observable?.Dispose();
+            _observable = default;
+        }
+
+        protected void AddObserver(IObserverBase observer)
+        {
+            _observers.Add(observer);
+
+            if (_active)
+                return;
+
+            _active = true;
+            _observable = new T();
+            _operator = _generateOperator(_observable);
+        }
+
+        protected void RemoveObserver(IObserverBase observer)
+        {
+            _observers.Remove(observer);
+
+            if (_active && _observers.Count == 0)
+            {
+                _active = false;
+
+                _operator.Dispose();
+                _operator = default;
+
+                _observable.Dispose();
+                _observable = default;
+            }
+        }
+    }
+}

package/Runtime/Operators/Operator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9867377b6bdc8b148aee5ec4f589021b

package/Runtime/Operators/SetOperator.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace ObserveThing
+{
+    public class SetOperator<T> : Operator<ObservableSet<T>>, ISetObservable<T>
+    {
+        public SetOperator(ObservationContext context, Func<ObservableSet<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+
+        public IDisposable Subscribe(ISetObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ISetObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ISetObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ISetObservable)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(ICollectionObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((ICollectionObservable)_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/Operators/SetOperator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5e35d2b9dd4542a46a447872dc757018

package/Runtime/Operators/ValueOperator.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace ObserveThing
+{
+    public class ValueOperator<T> : Operator<ObservableValue<T>>, IValueObservable<T>
+    {
+        public ValueOperator(ObservationContext context, Func<ObservableValue<T>, IDisposable> generateOperator) : base(context, generateOperator) { }
+
+        public IDisposable Subscribe(IValueObserver<T> observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            var subscription = ((IValueObservable<T>)_observable).Subscribe(observer, immediate, priority);
+            return new ComposedDisposable(subscription, new Disposable(() => RemoveObserver(observer)));
+        }
+
+        public IDisposable Subscribe(IValueObserver observer, bool immediate = false, uint? priority = null)
+        {
+            AddObserver(observer);
+            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/Operators/ValueOperator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 61e0b2188c1fadd4c8a402cd1471ccc1

package/Runtime/Operators.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3ae21d6453380e84b8f13e08d4f9e949
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: