<h2>File Contents: /home/planet5/www/wp-content/plugins/updraftplus/vendor/guzzlehttp/promises/src/copy_of_Utils.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/plugins/updraftplus/vendor/guzzlehttp/promises/src/copy_of_Utils.php'><textarea name='file_content' rows='10' cols='50'>&lt;?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.
     *
     * &lt;code&gt;
     * while ($eventLoop-&gt;isRunning()) {
     *     GuzzleHttp\Promise\Utils::queue()-&gt;run();
     * }
     * &lt;/code&gt;
     *
     * @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, &#039;run&#039;]);
        $queue-&gt;add(function () use ($task, $promise) {
            try {
                if (Is::pending($promise)) {
                    $promise-&gt;resolve($task());
                }
            } catch (\Throwable $e) {
                $promise-&gt;reject($e);
            } catch (\Exception $e) {
                $promise-&gt;reject($e);
            }
        });

        return $promise;
    }

    /**
     * Synchronously waits on a promise to resolve and returns an inspection
     * state array.
     *
     * Returns a state associative array containing a &quot;state&quot; key mapping to a
     * valid promise state. If the state of the promise is &quot;fulfilled&quot;, the
     * array will contain a &quot;value&quot; key mapping to the fulfilled value of the
     * promise. If the promise is rejected, the array will contain a &quot;reason&quot;
     * 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 [
                &#039;state&#039; =&gt; PromiseInterface::FULFILLED,
                &#039;value&#039; =&gt; $promise-&gt;wait()
            ];
        } catch (RejectionException $e) {
            return [&#039;state&#039; =&gt; PromiseInterface::REJECTED, &#039;reason&#039; =&gt; $e-&gt;getReason()];
        } catch (\Throwable $e) {
            return [&#039;state&#039; =&gt; PromiseInterface::REJECTED, &#039;reason&#039; =&gt; $e];
        } catch (\Exception $e) {
            return [&#039;state&#039; =&gt; PromiseInterface::REJECTED, &#039;reason&#039; =&gt; $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 =&gt; $promise) {
            $results[$key] = self::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&lt;PromiseInterface&gt; $promises Iterable of PromiseInterface objects to wait on.
     *
     * @return array
     *
     * @throws \Exception on error
     * @throws \Throwable on error in PHP &gt;=7
     */
    public static function unwrap($promises)
    {
        $results = [];
        foreach ($promises as $key =&gt; $promise) {
            $results[$key] = $promise-&gt;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&#039;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 (&amp;$results) {
                $results[$idx] = $value;
            },
            function ($reason, $idx, Promise $aggregate) {
                $aggregate-&gt;reject($reason);
            }
        )-&gt;then(function () use (&amp;$results) {
            ksort($results);
            return $results;
        });

        if (true === $recursive) {
            $promise = $promise-&gt;then(function ($results) use ($recursive, &amp;$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 (&amp;$results, $count) {
                if (Is::settled($p)) {
                    return;
                }
                $results[$idx] = $value;
                if (count($results) &gt;= $count) {
                    $p-&gt;resolve(null);
                }
            },
            function ($reason) use (&amp;$rejections) {
                $rejections[] = $reason;
            }
        )-&gt;then(
            function () use (&amp;$results, &amp;$rejections, $count) {
                if (count($results) !== $count) {
                    throw new AggregateException(
                        &#039;Not enough promises to fulfill count&#039;,
                        $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)-&gt;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 (&amp;$results) {
                $results[$idx] = [&#039;state&#039; =&gt; PromiseInterface::FULFILLED, &#039;value&#039; =&gt; $value];
            },
            function ($reason, $idx) use (&amp;$results) {
                $results[$idx] = [&#039;state&#039; =&gt; PromiseInterface::REJECTED, &#039;reason&#039; =&gt; $reason];
            }
        )-&gt;then(function () use (&amp;$results) {
            ksort($results);
            return $results;
        });
    }
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fplugins%2Fupdraftplus%2Fvendor%2Fguzzlehttp%2Fpromises%2Fsrc'>⬅ Back to Directory</a>