Proyectos de Subversion Moodle

<?php

namespace GuzzleHttp\Promise;

final class Utils

{

    /**

     * Get the global task queue used for promise resolution.

     *

     * This task queue MUST be run in an event loop in order for promises to be

     * settled asynchronously. It will be automatically run when synchronously

     * waiting on a promise.

     *

     * <code>

     * while ($eventLoop->isRunning()) {

     *     GuzzleHttp\Promise\Utils::queue()->run();

     * }

     * </code>

     *

     * @param TaskQueueInterface $assign Optionally specify a new queue instance.

     *

     * @return TaskQueueInterface

     */

    public static function queue(TaskQueueInterface $assign = null)

    {

        static $queue;

        if ($assign) {

            $queue = $assign;

        } elseif (!$queue) {

            $queue = new TaskQueue();

        }

        return $queue;

    }

    /**

     * Adds a function to run in the task queue when it is next `run()` and

     * returns a promise that is fulfilled or rejected with the result.

     *

     * @param callable $task Task function to run.

     *

     * @return PromiseInterface

     */

    public static function task(callable $task)

    {

        $queue = self::queue();

        $promise = new Promise([$queue, 'run']);

        $queue->add(function () use ($task, $promise) {

            try {

                if (Is::pending($promise)) {

                    $promise->resolve($task());

                }

            } catch (\Throwable $e) {

                $promise->reject($e);

            } catch (\Exception $e) {

                $promise->reject($e);

            }

        });

        return $promise;

    }

    /**

     * Synchronously waits on a promise to resolve and returns an inspection

     * state array.

     *

     * Returns a state associative array containing a "state" key mapping to a

     * valid promise state. If the state of the promise is "fulfilled", the

     * array will contain a "value" key mapping to the fulfilled value of the

     * promise. If the promise is rejected, the array will contain a "reason"

     * key mapping to the rejection reason of the promise.

     *

     * @param PromiseInterface $promise Promise or value.

     *

     * @return array

     */

    public static function inspect(PromiseInterface $promise)

    {

        try {

            return [

                'state' => PromiseInterface::FULFILLED,

                'value' => $promise->wait()

            ];

        } catch (RejectionException $e) {

            return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];

        } catch (\Throwable $e) {

            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];

        } catch (\Exception $e) {

            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];

        }

    }

    /**

     * Waits on all of the provided promises, but does not unwrap rejected

     * promises as thrown exception.

     *

     * Returns an array of inspection state arrays.

     *

     * @see inspect for the inspection state array format.

     *

     * @param PromiseInterface[] $promises Traversable of promises to wait upon.

     *

     * @return array

     */

    public static function inspectAll($promises)

    {

        $results = [];

        foreach ($promises as $key => $promise) {

            $results[$key] = inspect($promise);

        }

        return $results;

    }

    /**

     * Waits on all of the provided promises and returns the fulfilled values.

     *

     * Returns an array that contains the value of each promise (in the same

     * order the promises were provided). An exception is thrown if any of the

     * promises are rejected.

     *

     * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.

     *

     * @return array

     *

     * @throws \Exception on error

     * @throws \Throwable on error in PHP >=7

     */

    public static function unwrap($promises)

    {

        $results = [];

        foreach ($promises as $key => $promise) {

            $results[$key] = $promise->wait();

        }

        return $results;

    }

    /**

     * Given an array of promises, return a promise that is fulfilled when all

     * the items in the array are fulfilled.

     *

     * The promise's fulfillment value is an array with fulfillment values at

     * respective positions to the original array. If any promise in the array

     * rejects, the returned promise is rejected with the rejection reason.

     *

     * @param mixed $promises  Promises or values.

     * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.

     *

     * @return PromiseInterface

     */

    public static function all($promises, $recursive = false)

    {

        $results = [];

        $promise = Each::of(

            $promises,

            function ($value, $idx) use (&$results) {

                $results[$idx] = $value;

            },

            function ($reason, $idx, Promise $aggregate) {

                $aggregate->reject($reason);

            }

        )->then(function () use (&$results) {

            ksort($results);

            return $results;

        });

        if (true === $recursive) {

            $promise = $promise->then(function ($results) use ($recursive, &$promises) {

                foreach ($promises as $promise) {

                    if (Is::pending($promise)) {

                        return self::all($promises, $recursive);

                    }

                }

                return $results;

            });

        }

        return $promise;

    }

    /**

     * Initiate a competitive race between multiple promises or values (values

     * will become immediately fulfilled promises).

     *

     * When count amount of promises have been fulfilled, the returned promise

     * is fulfilled with an array that contains the fulfillment values of the

     * winners in order of resolution.

     *

     * This promise is rejected with a {@see AggregateException} if the number

     * of fulfilled promises is less than the desired $count.

     *

     * @param int   $count    Total number of promises.

     * @param mixed $promises Promises or values.

     *

     * @return PromiseInterface

     */

    public static function some($count, $promises)

    {

        $results = [];

        $rejections = [];

        return Each::of(

            $promises,

            function ($value, $idx, PromiseInterface $p) use (&$results, $count) {

                if (Is::settled($p)) {

                    return;

                }

                $results[$idx] = $value;

                if (count($results) >= $count) {

                    $p->resolve(null);

                }

            },

            function ($reason) use (&$rejections) {

                $rejections[] = $reason;

            }

        )->then(

            function () use (&$results, &$rejections, $count) {

                if (count($results) !== $count) {

                    throw new AggregateException(

                        'Not enough promises to fulfill count',

                        $rejections

                    );

                }

                ksort($results);

                return array_values($results);

            }

        );

    }

    /**

     * Like some(), with 1 as count. However, if the promise fulfills, the

     * fulfillment value is not an array of 1 but the value directly.

     *

     * @param mixed $promises Promises or values.

     *

     * @return PromiseInterface

     */

    public static function any($promises)

    {

        return self::some(1, $promises)->then(function ($values) {

            return $values[0];

        });

    }

    /**

     * Returns a promise that is fulfilled when all of the provided promises have

     * been fulfilled or rejected.

     *

     * The returned promise is fulfilled with an array of inspection state arrays.

     *

     * @see inspect for the inspection state array format.

     *

     * @param mixed $promises Promises or values.

     *

     * @return PromiseInterface

     */

    public static function settle($promises)

    {

        $results = [];

        return Each::of(

            $promises,

            function ($value, $idx) use (&$results) {

                $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];

            },

            function ($reason, $idx) use (&$results) {

                $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];

            }

        )->then(function () use (&$results) {

            ksort($results);

            return $results;

        });

    }

}