webshell

Ghost Exploiter Team Official

Directory >> /home/whitjouh/public_html/core/vendor/guzzlehttp/promises/src/

File / Folder	Size	Action
.	-
AggregateException.php	0.403KB	edt ren
CancellationException.php	0.204KB	edt ren
Coroutine.php	4.063KB	edt ren
Create.php	1.964KB	edt ren
Each.php	2.597KB	edt ren
EachPromise.php	7.415KB	edt ren
FulfilledPromise.php	1.995KB	edt ren
Is.php	0.919KB	edt ren
Promise.php	8.747KB	edt ren
PromiseInterface.php	2.757KB	edt ren
PromisorInterface.php	0.243KB	edt ren
RejectedPromise.php	2.213KB	edt ren
RejectionException.php	1.211KB	edt ren
TaskQueue.php	1.967KB	edt ren
TaskQueueInterface.php	0.439KB	edt ren
Utils.php	8.18KB	edt ren

<?php

declare(strict_types=1);

namespace GuzzleHttp\Promise;

/**
 * A promise that has been rejected.
 *
 * Thenning off of this promise will invoke the onRejected callback
 * immediately and ignore other callbacks.
 *
 * @final
 */
class RejectedPromise implements PromiseInterface
{
    private $reason;

/**
     * @param mixed $reason
     */
    public function __construct($reason)
    {
        if (is_object($reason) && method_exists($reason, 'then')) {
            throw new \InvalidArgumentException(
                'You cannot create a RejectedPromise with a promise.'
            );
        }

$this->reason = $reason;
    }

public function then(
        callable $onFulfilled = null,
        callable $onRejected = null
    ): PromiseInterface {
        // If there's no onRejected callback then just return self.
        if (!$onRejected) {
            return $this;
        }

$queue = Utils::queue();
        $reason = $this->reason;
        $p = new Promise([$queue, 'run']);
        $queue->add(static function () use ($p, $reason, $onRejected): void {
            if (Is::pending($p)) {
                try {
                    // Return a resolved promise if onRejected does not throw.
                    $p->resolve($onRejected($reason));
                } catch (\Throwable $e) {
                    // onRejected threw, so return a rejected promise.
                    $p->reject($e);
                }
            }
        });

return $p;
    }

public function otherwise(callable $onRejected): PromiseInterface
    {
        return $this->then(null, $onRejected);
    }

public function wait(bool $unwrap = true)
    {
        if ($unwrap) {
            throw Create::exceptionFor($this->reason);
        }

return null;
    }

public function getState(): string
    {
        return self::REJECTED;
    }

public function resolve($value): void
    {
        throw new \LogicException('Cannot resolve a rejected promise');
    }

public function reject($reason): void
    {
        if ($reason !== $this->reason) {
            throw new \LogicException('Cannot reject a rejected promise');
        }
    }

public function cancel(): void
    {
        // pass
    }
}

<=Back