UniRx 에셋 추가

2025-06-02 00:27:36 +09:00
parent 915f292d7d
commit 8a54d47b56
510 changed files with 42973 additions and 0 deletions
--- a/Gameton-06/Assets/Plugins/UniRx/Scripts/Operators/Create.cs
+++ b/Gameton-06/Assets/Plugins/UniRx/Scripts/Operators/Create.cs
@@ -0,0 +1,156 @@
+using System;
+
+namespace UniRx.Operators
+{
+    internal class CreateObservable<T> : OperatorObservableBase<T>
+    {
+        readonly Func<IObserver<T>, IDisposable> subscribe;
+
+        public CreateObservable(Func<IObserver<T>, IDisposable> subscribe)
+            : base(true) // fail safe
+        {
+            this.subscribe = subscribe;
+        }
+
+        public CreateObservable(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
+            : base(isRequiredSubscribeOnCurrentThread)
+        {
+            this.subscribe = subscribe;
+        }
+
+        protected override IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
+        {
+            observer = new Create(observer, cancel);
+            return subscribe(observer) ?? Disposable.Empty;
+        }
+
+        class Create : OperatorObserverBase<T, T>
+        {
+            public Create(IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
+            {
+            }
+
+            public override void OnNext(T value)
+            {
+                base.observer.OnNext(value);
+            }
+
+            public override void OnError(Exception error)
+            {
+                try { observer.OnError(error); }
+                finally { Dispose(); }
+            }
+
+            public override void OnCompleted()
+            {
+                try { observer.OnCompleted(); }
+                finally { Dispose(); }
+            }
+        }
+    }
+
+    internal class CreateObservable<T, TState> : OperatorObservableBase<T>
+    {
+        readonly TState state;
+        readonly Func<TState, IObserver<T>, IDisposable> subscribe;
+
+        public CreateObservable(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)
+            : base(true) // fail safe
+        {
+            this.state = state;
+            this.subscribe = subscribe;
+        }
+
+        public CreateObservable(TState state, Func<TState, IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
+            : base(isRequiredSubscribeOnCurrentThread)
+        {
+            this.state = state;
+            this.subscribe = subscribe;
+        }
+
+        protected override IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
+        {
+            observer = new Create(observer, cancel);
+            return subscribe(state, observer) ?? Disposable.Empty;
+        }
+
+        class Create : OperatorObserverBase<T, T>
+        {
+            public Create(IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
+            {
+            }
+
+            public override void OnNext(T value)
+            {
+                base.observer.OnNext(value);
+            }
+
+            public override void OnError(Exception error)
+            {
+                try { observer.OnError(error); }
+                finally { Dispose(); }
+            }
+
+            public override void OnCompleted()
+            {
+                try { observer.OnCompleted(); }
+                finally { Dispose(); }
+            }
+        }
+    }
+
+    internal class CreateSafeObservable<T> : OperatorObservableBase<T>
+    {
+        readonly Func<IObserver<T>, IDisposable> subscribe;
+
+        public CreateSafeObservable(Func<IObserver<T>, IDisposable> subscribe)
+            : base(true) // fail safe
+        {
+            this.subscribe = subscribe;
+        }
+
+        public CreateSafeObservable(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
+            : base(isRequiredSubscribeOnCurrentThread)
+        {
+            this.subscribe = subscribe;
+        }
+
+        protected override IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
+        {
+            observer = new CreateSafe(observer, cancel);
+            return subscribe(observer) ?? Disposable.Empty;
+        }
+
+        class CreateSafe : OperatorObserverBase<T, T>
+        {
+            public CreateSafe(IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
+            {
+            }
+
+            public override void OnNext(T value)
+            {
+                try
+                {
+                    base.observer.OnNext(value);
+                }
+                catch
+                {
+                    Dispose(); // safe
+                    throw;
+                }
+            }
+
+            public override void OnError(Exception error)
+            {
+                try { observer.OnError(error); }
+                finally { Dispose(); }
+            }
+
+            public override void OnCompleted()
+            {
+                try { observer.OnCompleted(); }
+                finally { Dispose(); }
+            }
+        }
+    }
+}