class Promise

Same name in this branch

11.1.x vendor/react/promise/src/Promise.php \React\Promise\Promise
11.1.x vendor/guzzlehttp/promises/src/Promise.php \GuzzleHttp\Promise\Promise

Wrapper around Guzzle promises.

@author Joel Wurtz <joel.wurtz@gmail.com>

Hierarchy

class \Http\Adapter\Guzzle7\Promise implements \Http\Promise\Promise

Expanded class hierarchy of Promise

File

vendor/php-http/guzzle7-adapter/src/Promise.php, line 20

Namespace

Http\Adapter\Guzzle7

View source

final class Promise implements HttpPromise {
    
    /**
     * @var PromiseInterface
     */
    private $promise;
    
    /**
     * @var string State of the promise
     */
    private $state;
    
    /**
     * @var ResponseInterface
     */
    private $response;
    
    /**
     * @var HttplugException
     */
    private $exception;
    
    /**
     * @var RequestInterface
     */
    private $request;
    public function __construct(PromiseInterface $promise, RequestInterface $request) {
        $this->request = $request;
        $this->state = self::PENDING;
        $this->promise = $promise->then(function ($response) {
            $this->response = $response;
            $this->state = self::FULFILLED;
            return $response;
        }, function ($reason) {
            $this->state = self::REJECTED;
            if ($reason instanceof HttplugException) {
                $this->exception = $reason;
            }
            elseif ($reason instanceof GuzzleExceptions\GuzzleException) {
                $this->exception = $this->handleException($reason);
            }
            elseif ($reason instanceof \Throwable) {
                $this->exception = new HttplugException\TransferException('Invalid exception returned from Guzzle7', 0, $reason);
            }
            else {
                $this->exception = new UnexpectedValueException('Reason returned from Guzzle7 must be an Exception');
            }
            throw $this->exception;
        });
    }
    public function then(?callable $onFulfilled = null, ?callable $onRejected = null) {
        return new static($this->promise
            ->then($onFulfilled, $onRejected), $this->request);
    }
    public function getState() {
        return $this->state;
    }
    public function wait($unwrap = true) {
        $this->promise
            ->wait(false);
        if ($unwrap) {
            if (self::REJECTED === $this->getState()) {
                throw $this->exception;
            }
            return $this->response;
        }
    }
    
    /**
     * Converts a Guzzle exception into an Httplug exception.
     *
     * @return HttplugException
     */
    private function handleException(GuzzleExceptions\GuzzleException $exception) {
        if ($exception instanceof GuzzleExceptions\ConnectException) {
            return new HttplugException\NetworkException($exception->getMessage(), $exception->getRequest(), $exception);
        }
        if ($exception instanceof GuzzleExceptions\RequestException) {
            // Make sure we have a response for the HttpException
            if ($exception->hasResponse()) {
                return new HttplugException\HttpException($exception->getMessage(), $exception->getRequest(), $exception->getResponse(), $exception);
            }
            return new HttplugException\RequestException($exception->getMessage(), $exception->getRequest(), $exception);
        }
        return new HttplugException\TransferException($exception->getMessage(), 0, $exception);
    }

}

Members

Title Sort descending	Modifiers	Object type	Summary	Overriden Title
Promise::$exception	private	property
Promise::$promise	private	property
Promise::$request	private	property
Promise::$response	private	property
Promise::$state	private	property
Promise::FULFILLED		constant	Promise has been fulfilled.
Promise::getState	public	function	Returns the state of the promise, one of PENDING, FULFILLED or REJECTED.	Overrides Promise::getState
Promise::handleException	private	function	Converts a Guzzle exception into an Httplug exception.
Promise::PENDING		constant	Promise has not been fulfilled or rejected.
Promise::REJECTED		constant	Promise has been rejected.
Promise::then	public	function	Adds behavior for when the promise is resolved or rejected (response will be available, or error happens).	Overrides Promise::then
Promise::wait	public	function	Wait for the promise to be fulfilled or rejected.	Overrides Promise::wait
Promise::__construct	public	function