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/RepeatSafe.cs
+++ b/Gameton-06/Assets/Plugins/UniRx/Scripts/Operators/RepeatSafe.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UniRx.Operators
+{
+    internal class RepeatSafeObservable<T> : OperatorObservableBase<T>
+    {
+        readonly IEnumerable<IObservable<T>> sources;
+
+        public RepeatSafeObservable(IEnumerable<IObservable<T>> sources, bool isRequiredSubscribeOnCurrentThread)
+            : base(isRequiredSubscribeOnCurrentThread)
+        {
+            this.sources = sources;
+        }
+
+        protected override IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
+        {
+            return new RepeatSafe(this, observer, cancel).Run();
+        }
+
+        class RepeatSafe : OperatorObserverBase<T, T>
+        {
+            readonly RepeatSafeObservable<T> parent;
+            readonly object gate = new object();
+
+            IEnumerator<IObservable<T>> e;
+            SerialDisposable subscription;
+            Action nextSelf;
+            bool isDisposed;
+            bool isRunNext;
+
+            public RepeatSafe(RepeatSafeObservable<T> parent, IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
+            {
+                this.parent = parent;
+            }
+
+            public IDisposable Run()
+            {
+                isDisposed = false;
+                isRunNext = false;
+                e = parent.sources.GetEnumerator();
+                subscription = new SerialDisposable();
+
+                var schedule = Scheduler.DefaultSchedulers.TailRecursion.Schedule(RecursiveRun);
+
+                return StableCompositeDisposable.Create(schedule, subscription, Disposable.Create(() =>
+                {
+                    lock (gate)
+                    {
+                        isDisposed = true;
+                        e.Dispose();
+                    }
+                }));
+            }
+
+            void RecursiveRun(Action self)
+            {
+                lock (gate)
+                {
+                    this.nextSelf = self;
+                    if (isDisposed) return;
+
+                    var current = default(IObservable<T>);
+                    var hasNext = false;
+                    var ex = default(Exception);
+
+                    try
+                    {
+                        hasNext = e.MoveNext();
+                        if (hasNext)
+                        {
+                            current = e.Current;
+                            if (current == null) throw new InvalidOperationException("sequence is null.");
+                        }
+                        else
+                        {
+                            e.Dispose();
+                        }
+                    }
+                    catch (Exception exception)
+                    {
+                        ex = exception;
+                        e.Dispose();
+                    }
+
+                    if (ex != null)
+                    {
+                        try { observer.OnError(ex); }
+                        finally { Dispose(); }
+                        return;
+                    }
+
+                    if (!hasNext)
+                    {
+                        try { observer.OnCompleted(); }
+                        finally { Dispose(); }
+                        return;
+                    }
+
+                    var source = e.Current;
+                    var d = new SingleAssignmentDisposable();
+                    subscription.Disposable = d;
+                    d.Disposable = source.Subscribe(this);
+                }
+            }
+
+            public override void OnNext(T value)
+            {
+                isRunNext = true;
+                base.observer.OnNext(value);
+            }
+            public override void OnError(Exception error)
+            {
+                try { observer.OnError(error); }
+                finally { Dispose(); }
+            }
+
+            public override void OnCompleted()
+            {
+                if (isRunNext && !isDisposed)
+                {
+                    isRunNext = false;
+                    this.nextSelf();
+                }
+                else
+                {
+                    e.Dispose();
+                    if (!isDisposed)
+                    {
+                        try { observer.OnCompleted(); }
+                        finally { Dispose(); }
+                    }
+                }
+            }
+        }
+    }
+}