Fiber.WhenAll.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace SpicyPixel.Threading
{
    public partial class Fiber
    {
        public static Fiber WhenAll (params Fiber [] fibers)
        {
            return WhenAll (fibers, Timeout.Infinite, CancellationToken.None);
        }

        public static Fiber WhenAll (Fiber [] fibers, CancellationToken cancellationToken)
        {
            return WhenAll (fibers, Timeout.Infinite, cancellationToken);
        }

        public static Fiber WhenAll (Fiber [] fibers, TimeSpan timeout)
        {
            return WhenAll (fibers, CheckTimeout (timeout), CancellationToken.None);
        }

        public static Fiber WhenAll (Fiber [] fibers, int millisecondsTimeout)
        {
            return WhenAll (fibers, millisecondsTimeout, CancellationToken.None);
        }

        public static Fiber WhenAll (Fiber [] fibers, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            return WhenAll (fibers, millisecondsTimeout, cancellationToken, FiberScheduler.Current);
        }

        public static Fiber WhenAll (Fiber [] fibers, int millisecondsTimeout, CancellationToken cancellationToken, FiberScheduler scheduler)
        {
            if (fibers == null)
                throw new ArgumentNullException ("fibers");

            foreach (var fiber in fibers) {
                if (fiber == null)
                    throw new ArgumentException ("fibers", "the fibers argument contains a null element");
            }

            return Fiber.Factory.StartNew (WhenAllFibersCoroutine (fibers, millisecondsTimeout, cancellationToken), cancellationToken, scheduler);
        }

        public static Fiber WhenAll (IEnumerable<Fiber> fibers, int millisecondsTimeout, CancellationToken cancellationToken, FiberScheduler scheduler)
        {
            return WhenAll (fibers.ToArray (), millisecondsTimeout, cancellationToken, scheduler);
        }

        static IEnumerator WhenAllFibersCoroutine (IEnumerable<Fiber> fibers, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            var startWait = DateTime.Now;
            while (true) {
                if ((millisecondsTimeout != Timeout.Infinite 
                     && (DateTime.Now - startWait).TotalMilliseconds >= millisecondsTimeout)) {
                    throw new TimeoutException ();
                }

                cancellationToken.ThrowIfCancellationRequested ();

                if (fibers.All (f => f.IsCompleted)) {
                    if (fibers.Any (f => f.IsCanceled)) {
                        throw new System.Threading.OperationCanceledException ();
                    }
                    if (fibers.Any (f => f.IsFaulted)) {
                        throw new AggregateException (
                            fibers.Where (f => f.IsFaulted).Select (f => f.Exception));
                    }
                    yield break;
                }

                yield return FiberInstruction.YieldToAnyFiber;
            }
        }

        public static Fiber WhenAll (params Task [] tasks)
        {
            return WhenAll (tasks, Timeout.Infinite, CancellationToken.None);
        }

        public static Fiber WhenAll (Task [] tasks, CancellationToken cancellationToken)
        {
            return WhenAll (tasks, Timeout.Infinite, cancellationToken);
        }

        public static Fiber WhenAll (Task [] tasks, TimeSpan timeout)
        {
            return WhenAll (tasks, CheckTimeout (timeout), CancellationToken.None);
        }

        public static Fiber WhenAll (Task [] tasks, int millisecondsTimeout)
        {
            return WhenAll (tasks, millisecondsTimeout, CancellationToken.None);
        }

        public static Fiber WhenAll (Task [] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            return WhenAll (tasks, millisecondsTimeout, cancellationToken, FiberScheduler.Current);
        }

        public static Fiber WhenAll (Task [] tasks, int millisecondsTimeout, CancellationToken cancellationToken, FiberScheduler scheduler)
        {
            if (tasks == null)
                throw new ArgumentNullException ("tasks");

            foreach (var fiber in tasks) {
                if (fiber == null)
                    throw new ArgumentException ("tasks", "the tasks argument contains a null element");
            }

            return Fiber.Factory.StartNew (WhenAllTasksCoroutine (tasks, millisecondsTimeout, cancellationToken), cancellationToken, scheduler);
        }

        public static Fiber WhenAll (IEnumerable<Task> tasks, int millisecondsTimeout, CancellationToken cancellationToken, FiberScheduler scheduler)
        {
            return WhenAll (tasks.ToArray (), millisecondsTimeout, cancellationToken, scheduler);
        }

        static IEnumerator WhenAllTasksCoroutine (IEnumerable<Task> tasks, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            var startWait = DateTime.Now;
            while (true) {
                if ((millisecondsTimeout != Timeout.Infinite
                     && (DateTime.Now - startWait).TotalMilliseconds >= millisecondsTimeout)) {
                    throw new TimeoutException ();
                }

                cancellationToken.ThrowIfCancellationRequested ();

                if (tasks.All (t => t.IsCompleted)) {
                    if (tasks.Any (t => t.IsCanceled)) {
                        throw new System.Threading.OperationCanceledException ();
                    }
                    if (tasks.Any (t => t.IsFaulted)) {
                        throw new AggregateException (
                            tasks.Where (t => t.IsFaulted).SelectMany (t => t.Exception.InnerExceptions));
                    }
                    yield break;
                }

                yield return FiberInstruction.YieldToAnyFiber;
            }
        }
    }
}