- Added support for IEnumerator<T>

- Added helper static class Awaiters

Author: svermeulen

UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/Awaiters.cs

@@ -0,0 +1,45 @@
+using System;
+using UnityEngine;
+
+// TODO: Remove the allocs here, use a static memory pool?
+public static class Awaiters
+{
+    readonly static WaitForUpdate _waitForUpdate = new WaitForUpdate();
+    readonly static WaitForFixedUpdate _waitForFixedUpdate = new WaitForFixedUpdate();
+    readonly static WaitForEndOfFrame _waitForEndOfFrame = new WaitForEndOfFrame();
+
+    public static WaitForUpdate NextFrame
+    {
+        get { return _waitForUpdate; }
+    }
+
+    public static WaitForFixedUpdate FixedUpdate
+    {
+        get { return _waitForFixedUpdate; }
+    }
+
+    public static WaitForEndOfFrame EndOfFrame
+    {
+        get { return _waitForEndOfFrame; }
+    }
+
+    public static WaitForSeconds Seconds(float seconds)
+    {
+        return new WaitForSeconds(seconds);
+    }
+
+    public static WaitForSecondsRealtime SecondsRealtime(float seconds)
+    {
+        return new WaitForSecondsRealtime(seconds);
+    }
+
+    public static WaitUntil Until(Func<bool> predicate)
+    {
+        return new WaitUntil(predicate);
+    }
+
+    public static WaitWhile While(Func<bool> predicate)
+    {
+        return new WaitWhile(predicate);
+    }
+}

UnityProject/Assets/Plugins/AsyncAwaitUtil/Source/Awaiters.cs.meta

@@ -87,11 +87,19 @@ public static SimpleCoroutineAwaiter<AssetBundle> GetAwaiter(this AssetBundleCre
         return awaiter;
     }
 
+    public static SimpleCoroutineAwaiter<T> GetAwaiter<T>(this IEnumerator<T> coroutine)
+    {
+        var awaiter = new SimpleCoroutineAwaiter<T>();
+        RunOnUnityScheduler(() => AsyncCoroutineRunner.Instance.StartCoroutine(
+            new CoroutineWrapper<T>(coroutine, awaiter).Run()));
+        return awaiter;
+    }
+
     public static SimpleCoroutineAwaiter<object> GetAwaiter(this IEnumerator coroutine)
     {
         var awaiter = new SimpleCoroutineAwaiter<object>();
         RunOnUnityScheduler(() => AsyncCoroutineRunner.Instance.StartCoroutine(
-            new CoroutineWrapper(coroutine, awaiter).Run()));
+            new CoroutineWrapper<object>(coroutine, awaiter).Run()));
         return awaiter;
     }
 
@@ -225,13 +233,13 @@ void INotifyCompletion.OnCompleted(Action continuation)
         }
     }
 
-    class CoroutineWrapper
+    class CoroutineWrapper<T>
     {
-        readonly SimpleCoroutineAwaiter<object> _awaiter;
+        readonly SimpleCoroutineAwaiter<T> _awaiter;
         readonly Stack<IEnumerator> _processStack;
 
         public CoroutineWrapper(
-            IEnumerator coroutine, SimpleCoroutineAwaiter<object> awaiter)
+            IEnumerator coroutine, SimpleCoroutineAwaiter<T> awaiter)
         {
             _processStack = new Stack<IEnumerator>();
             _processStack.Push(coroutine);
@@ -252,7 +260,7 @@ public IEnumerator Run()
                 }
                 catch (Exception e)
                 {
-                    _awaiter.Complete(null, e);
+                    _awaiter.Complete(default(T), e);
                     yield break;
                 }
 
@@ -262,7 +270,7 @@ public IEnumerator Run()
 
                     if (_processStack.Count == 0)
                     {
-                        _awaiter.Complete(topWorker.Current, null);
+                        _awaiter.Complete((T)topWorker.Current, null);
                         yield break;
                     }
                 }