Current File : //home2/selectio/www/limpiar.in.net/updates/vendor/aws/aws-sdk-php/src/ResultPaginator.php
<?php
namespace Aws;
use GuzzleHttp\Promise;
/**
* Iterator that yields each page of results of a pageable operation.
*/
class ResultPaginator implements \Iterator
{
/** @var AwsClientInterface Client performing operations. */
private $client;
/** @var string Name of the operation being paginated. */
private $operation;
/** @var array Args for the operation. */
private $args;
/** @var array Configuration for the paginator. */
private $config;
/** @var Result Most recent result from the client. */
private $result;
/** @var string|array Next token to use for pagination. */
private $nextToken;
/** @var int Number of operations/requests performed. */
private $requestCount = 0;
/**
* @param AwsClientInterface $client
* @param string $operation
* @param array $args
* @param array $config
*/
public function __construct(
AwsClientInterface $client,
$operation,
array $args,
array $config
) {
$this->client = $client;
$this->operation = $operation;
$this->args = $args;
$this->config = $config;
}
/**
* Runs a paginator asynchronously and uses a callback to handle results.
*
* The callback should have the signature: function (Aws\Result $result).
* A non-null return value from the callback will be yielded by the
* promise. This means that you can return promises from the callback that
* will need to be resolved before continuing iteration over the remaining
* items, essentially merging in other promises to the iteration. The last
* non-null value returned by the callback will be the result that fulfills
* the promise to any downstream promises.
*
* @param callable $handleResult Callback for handling each page of results.
* The callback accepts the result that was
* yielded as a single argument. If the
* callback returns a promise, the promise
* will be merged into the coroutine.
*
* @return Promise\Promise
*/
public function each(callable $handleResult)
{
return Promise\Coroutine::of(function () use ($handleResult) {
$nextToken = null;
do {
$command = $this->createNextCommand($this->args, $nextToken);
$result = (yield $this->client->executeAsync($command));
$nextToken = $this->determineNextToken($result);
$retVal = $handleResult($result);
if ($retVal !== null) {
yield Promise\Create::promiseFor($retVal);
}
} while ($nextToken);
});
}
/**
* Returns an iterator that iterates over the values of applying a JMESPath
* search to each result yielded by the iterator as a flat sequence.
*
* @param string $expression JMESPath expression to apply to each result.
*
* @return \Iterator
*/
public function search($expression)
{
// Apply JMESPath expression on each result, but as a flat sequence.
return flatmap($this, function (Result $result) use ($expression) {
return (array) $result->search($expression);
});
}
/**
* @return Result
*/
#[\ReturnTypeWillChange]
public function current()
{
return $this->valid() ? $this->result : false;
}
#[\ReturnTypeWillChange]
public function key()
{
return $this->valid() ? $this->requestCount - 1 : null;
}
#[\ReturnTypeWillChange]
public function next()
{
$this->result = null;
}
#[\ReturnTypeWillChange]
public function valid()
{
if ($this->result) {
return true;
}
if ($this->nextToken || !$this->requestCount) {
//Forward/backward paging can result in a case where the last page's nextforwardtoken
//is the same as the one that came before it. This can cause an infinite loop.
$hasBidirectionalPaging = $this->config['output_token'] === 'nextForwardToken';
if ($hasBidirectionalPaging && $this->nextToken) {
$tokenKey = $this->config['input_token'];
$previousToken = $this->nextToken[$tokenKey];
}
$this->result = $this->client->execute(
$this->createNextCommand($this->args, $this->nextToken)
);
$this->nextToken = $this->determineNextToken($this->result);
if (isset($previousToken)
&& $previousToken === $this->nextToken[$tokenKey]
) {
return false;
}
$this->requestCount++;
return true;
}
return false;
}
#[\ReturnTypeWillChange]
public function rewind()
{
$this->requestCount = 0;
$this->nextToken = null;
$this->result = null;
}
private function createNextCommand(array $args, array $nextToken = null)
{
return $this->client->getCommand($this->operation, array_merge($args, ($nextToken ?: [])));
}
private function determineNextToken(Result $result)
{
if (!$this->config['output_token']) {
return null;
}
if ($this->config['more_results']
&& !$result->search($this->config['more_results'])
) {
return null;
}
$nextToken = is_scalar($this->config['output_token'])
? [$this->config['input_token'] => $this->config['output_token']]
: array_combine($this->config['input_token'], $this->config['output_token']);
return array_filter(array_map(function ($outputToken) use ($result) {
return $result->search($outputToken);
}, $nextToken));
}
}
Mini Shell