complete except trigger

Assets/UniRx.Async/Triggers/AsyncTriggerBase.cs

@@ -15,46 +15,6 @@ namespace UniRx.Async.Triggers
         bool TrySetCanceled();
     }
 
-    public class AsyncTriggerPromise<T> : ReusablePromise<T>, IPromise<T>, ICancelablePromise
-    {
-        public CancellationToken RegisteredCancellationToken { get; private set; }
-
-        public AsyncTriggerPromise()
-            : this(CancellationToken.None)
-        {
-        }
-
-        public AsyncTriggerPromise(CancellationToken cancellationToken)
-        {
-            this.RegisteredCancellationToken = cancellationToken;
-            TaskTracker.TrackActiveTask(this);
-        }
-
-        public override T GetResult()
-        {
-            if (Status == UniTaskStatus.Pending) return RawResult;
-            return base.GetResult();
-        }
-
-        public override bool TrySetResult(T result)
-        {
-            if (Status == UniTaskStatus.Pending)
-            {
-                // keep status as Pending.
-                this.ForceSetResult(result);
-                TryInvokeContinuation();
-                return true;
-            }
-            return false;
-        }
-
-        public override bool TrySetCanceled()
-        {
-            if (Status == UniTaskStatus.Canceled) return false;
-            TaskTracker.RemoveTracking(this);
-            return base.TrySetCanceled();
-        }
-    }
 
     public interface ICancellationTokenKeyDictionary
     {
@@ -62,7 +22,7 @@ namespace UniRx.Async.Triggers
     }
 
     public class AsyncTriggerPromiseDictionary<TPromiseType> :
-        Dictionary<CancellationToken, AsyncTriggerPromise<TPromiseType>>,
+        Dictionary<CancellationToken, AutoResetUniTaskCompletionSource<TPromiseType>>,
         ICancellationTokenKeyDictionary,
         IEnumerable<ICancelablePromise>
     {
@@ -73,7 +33,9 @@ namespace UniRx.Async.Triggers
 
         IEnumerator<ICancelablePromise> IEnumerable<ICancelablePromise>.GetEnumerator()
         {
-            return Values.GetEnumerator();
+            // TODO:
+            throw new NotImplementedException();
+            //return Values.GetEnumerator();
         }
 
         void ICancellationTokenKeyDictionary.Remove(CancellationToken token)

Assets/UniRx.Async/Triggers/AsyncUpdateTrigger.cs

@@ -2,8 +2,11 @@
 #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
+using UniRx.Async.Internal;
 using UnityEngine;
 using UnityEngine.EventSystems;
 
@@ -35,6 +38,162 @@ namespace UniRx.Async.Triggers
 
 
     }
+
+
+
+    // TODO:remove 2.
+    public abstract class AsyncTriggerBase2 : MonoBehaviour
+    {
+        static readonly Action<object> Callback = CancelCallback;
+
+        bool calledAwake = false;
+        bool destroyCalled = false;
+        CancellationTokenRegistration[] registeredCancellations;
+        int registeredCancellationsCount;
+
+        protected abstract IEnumerable<ICancelablePromise> GetPromises();
+
+        void Awake()
+        {
+            calledAwake = true;
+        }
+
+        void OnDestroy()
+        {
+            if (destroyCalled) return;
+            destroyCalled = true;
+            foreach (var item in GetPromises())
+            {
+                item.TrySetCanceled();
+            }
+            if (registeredCancellations != null)
+            {
+                for (int i = 0; i < registeredCancellationsCount; i++)
+                {
+                    registeredCancellations[i].Dispose();
+                    registeredCancellations[i] = default(CancellationTokenRegistration);
+                }
+                ArrayPool<CancellationTokenRegistration>.Shared.Return(registeredCancellations);
+            }
+        }
+
+        protected void TrySetResult<T>(MinimumQueue<UniTaskCompletionSource<AsyncUnit>> promise, AsyncTriggerPromiseDictionary<T> promises, T result)
+        {
+            if (promise != null)
+            {
+                // TODO:
+            }
+
+            if (promises != null)
+            {
+                PromiseHelper.TrySetResultAll(promises.Values, result);
+            }
+        }
+
+        public UniTask<T> CreatePromise<T>(ref MinimumQueue<AutoResetUniTaskCompletionSource<T>> promise, ref AsyncTriggerPromiseDictionary<T> promises, CancellationToken cancellationToken)
+        {
+            if (destroyCalled) return UniTask.FromCanceled<T>();
+
+            if (!calledAwake)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+
+            if (!cancellationToken.CanBeCanceled)
+            {
+                if (promise == null)
+                {
+                    promise = new MinimumQueue<AutoResetUniTaskCompletionSource<T>>(4); // kakko kari.(ArrayPool?)
+                }
+
+                var tcs = AutoResetUniTaskCompletionSource<T>.Create();
+                promise.Enqueue(tcs);
+                return tcs.Task;
+            }
+
+
+            CancellationTokenRegistration registrationToken = default;
+            // TODO:atode.
+            // var registrationToken = cancellationToken.RegisterWithoutCaptureExecutionContext(Callback, Tuple.Create((ICancellationTokenKeyDictionary)promises, (ICancelablePromise)cancellablePromise));
+            if (registeredCancellations == null)
+            {
+                registeredCancellations = ArrayPool<CancellationTokenRegistration>.Shared.Rent(4);
+            }
+
+            ArrayPoolUtil.EnsureCapacity(ref registeredCancellations, registeredCancellationsCount + 1, ArrayPool<CancellationTokenRegistration>.Shared);
+            registeredCancellations[registeredCancellationsCount++] = registrationToken;
+
+            // TODO:<3A><>use at registration
+            {
+                if (promises == null)
+                {
+                    promises = new AsyncTriggerPromiseDictionary<T>();
+                }
+
+                var tcs = AutoResetUniTaskCompletionSource<T>.Create();
+                promises.Add(cancellationToken, tcs);
+                return tcs.Task;
+            }
+        }
+
+        static void CancelCallback(object state)
+        {
+            // TODO:nantokasuru.
+
+            //var tuple = (Tuple<ICancellationTokenKeyDictionary, ICancelablePromise>)state;
+            //var dict = tuple.Item1;
+            //var promise = tuple.Item2;
+
+            //promise.TrySetCanceled();
+            //dict.Remove(promise.RegisteredCancellationToken);
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncTriggerBase2 trigger;
+
+            public AwakeMonitor(AsyncTriggerBase2 trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.calledAwake) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+
+
+    // TODO:remove 2.
+    [DisallowMultipleComponent]
+    public class AsyncUpdateTrigger2 : AsyncTriggerBase2
+    {
+        MinimumQueue<UniTaskCompletionSource<AsyncUnit>> promise;
+        AsyncTriggerPromiseDictionary<AsyncUnit> promises;
+
+        protected override IEnumerable<ICancelablePromise> GetPromises()
+        {
+            // TODO:
+            throw new NotImplementedException();
+        }
+
+        void Update()
+        {
+            // TrySetResult
+        }
+
+        public UniTask UpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return CreatePromise<AsyncUnit>(ref promise, ref promises, cancellationToken).AsUniTask();
+        }
+    }
 }
 
 #endif