PHP SplQueue::setIteratorMode方法代码示例

 /**
  * Implements the when() method of the Promise interface.
  * 
  * @param callable $onResolved
  */
 public function when(callable $onResolved)
 {
     switch ($this->state) {
         case Awaitable::RESOLVED:
             try {
                 $onResolved(null, ...$this->result);
             } catch (\Throwable $ex) {
                 Loop::defer(function () use($ex) {
                     throw $ex;
                 });
             }
             break;
         case Awaitable::FAILED:
             try {
                 $onResolved($this->result);
             } catch (\Throwable $ex) {
                 Loop::defer(function () use($ex) {
                     throw $ex;
                 });
             }
             break;
         default:
             if (!$this->callbacks) {
                 $this->callbacks = new \SplQueue();
                 $this->callbacks->setIteratorMode(\SplQueue::IT_MODE_FIFO | \SplQueue::IT_MODE_DELETE);
             }
             $this->callbacks->enqueue($onResolved);
     }
 }

 public function __construct()
 {
     parent::__construct();
     $this->scope = new EventEmitter();
     $this->queue = new \SplQueue();
     $this->queue->setIteratorMode(\SplQueue::IT_MODE_DELETE);
 }

 public function __construct(\Iterator $it)
 {
     $this->it = $it;
     $this->statement = new \SplQueue();
     $this->statement->setIteratorMode(\SplDoublyLinkedList::IT_MODE_DELETE);
     $this->blocks = new \SplStack();
 }

 /**
  * @param Zend_Log_Writer_Abstract $writer
  * @param int $flushPriority
  * @param int $limit - If greater than 0 will only buffer that many events
  */
 public function __construct(Zend_Log_Writer_Abstract $writer, $flushPriority = Zend_Log::DEBUG, $limit = 0)
 {
     $this->writer = $writer;
     $this->flushPriority = $flushPriority;
     $this->limit = $limit;
     $this->buffer = new SplQueue();
     $this->buffer->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO | SplDoublyLinkedList::IT_MODE_DELETE);
     $this->flushed = false;
 }

 /**
  * Copies for the audits and audits_logs table into the elastic search storage.
  *
  * @return bool
  */
 public function main()
 {
     $table = $this->loadModel('Audits');
     $table->hasMany('AuditDeltas');
     $table->schema()->columnType('created', 'string');
     $map = [];
     $meta = [];
     $featureList = function ($element) {
         list($k, $v) = explode(':', $element);
         (yield $k => $v);
     };
     if (!empty($this->params['type-map'])) {
         $map = explode(',', $this->params['type-map']);
         $map = collection($map)->unfold($featureList)->toArray();
     }
     if (!empty($this->params['extra-meta'])) {
         $meta = explode(',', $this->params['extra-meta']);
         $meta = collection($meta)->unfold($featureList)->toArray();
     }
     $from = (new Time($this->params['from']))->modify('midnight');
     $until = (new Time($this->params['until']))->modify('23:59:59');
     $currentId = null;
     $buffer = new \SplQueue();
     $buffer->setIteratorMode(\SplDoublyLinkedList::IT_MODE_DELETE);
     $queue = new \SplQueue();
     $queue->setIteratorMode(\SplDoublyLinkedList::IT_MODE_DELETE);
     $index = ConnectionManager::get('auditlog_elastic')->getConfig('index');
     $eventsFormatter = function ($audit) use($index, $meta) {
         return $this->eventFormatter($audit, $index, $meta);
     };
     $changesExtractor = [$this, 'changesExtractor'];
     $query = $table->find()->where(function ($exp) use($from, $until) {
         return $exp->between('Audits.created', $from, $until, 'datetime');
     })->where(function ($exp) {
         if (!empty($this->params['exclude-models'])) {
             $exp->notIn('Audits.model', explode(',', $this->params['exclude-models']));
         }
         if (!empty($this->params['models'])) {
             $exp->in('Audits.model', explode(',', $this->params['models']));
         }
         return $exp;
     })->matching('AuditDeltas')->order(['Audits.created', 'AuditDeltas.audit_id'])->bufferResults(false)->hydrate(false)->unfold(function ($audit) use($buffer, &$currentId) {
         if ($currentId && $currentId !== $audit['id']) {
             (yield collection($buffer)->toList());
         }
         $currentId = $audit['id'];
         $buffer->enqueue($audit);
     })->map($changesExtractor)->map($eventsFormatter)->unfold(function ($audit) use($queue) {
         $queue->enqueue($audit);
         if ($queue->count() >= 50) {
             (yield collection($queue)->toList());
         }
     });
     $query->each([$this, 'persistBulk']);
     // There are probably some un-yielded results, let's flush them
     $rest = collection(count($buffer) ? [collection($buffer)->toList()] : [])->map($changesExtractor)->map($eventsFormatter)->append($queue);
     $this->persistBulk($rest->toList());
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function __construct($queue = null)
 {
     parent::setIteratorMode(\SplDoublyLinkedList::IT_MODE_FIFO & \SplDoublyLinkedList::IT_MODE_DELETE);
     if (null !== $queue) {
         foreach ($queue as $item) {
             $this->enqueue($item);
         }
     }
 }

 /**
  * Create a new uv loop.
  * 
  * @param LoopConfig $config
  */
 public function __construct(LoopConfig $config = null)
 {
     parent::__construct($config);
     //         $this->loop = $loop ?? \uv_loop_new();
     // TODO: Investigate why new uv loops cannot be deleted (segfault) and leak file descriptors...
     $this->loop = \uv_default_loop();
     $this->dispose = new \SplQueue();
     $this->dispose->setIteratorMode(\SplQueue::IT_MODE_FIFO | \SplQueue::IT_MODE_DELETE);
     $this->config->setHostResolver(new Resolver($this));
     $this->config->setFilesystem(new Filesystem($this, $this->config->getFilesystemObserver()));
     if (\defined('PHP_ZTS') && \PHP_ZTS) {
         // TODO: Implement a pool based on uv_queue_work() if ZTS is enabled (unusable: "zend_mm_heap corrupted").
     }
     $this->delayCallback = function ($event) {
         $watcher = $this->timerWatchers[(int) $event] ?? null;
         if ($watcher) {
             $this->info[Watcher::TYPE_DELAY]--;
             unset($this->timerWatchers[(int) $event], $this->watchers[$watcher->id], $this->enable[$watcher->id]);
             if ($watcher->referenced) {
                 $this->watchersReferenced--;
             }
             $watcher->event = null;
             $this->dispose->enqueue($event);
             ($watcher->callback)($watcher->id, $watcher->data);
         }
     };
     $this->repeatCallback = function ($event) {
         $watcher = $this->timerWatchers[(int) $event] ?? null;
         if ($watcher) {
             ($watcher->callback)($watcher->id, $watcher->data);
         }
     };
     $this->streamCallback = function ($event, int $status, int $events) {
         $id = (int) $event;
         if (($events === 0 || $events & \UV::READABLE) && isset($this->readWatchers[$id])) {
             foreach ($this->readWatchers[$id] as $watcher) {
                 ($watcher->callback)($watcher->id, $watcher->stream, $watcher->data);
             }
         }
         if (($events === 0 || $events & \UV::WRITABLE) && isset($this->writeWatchers[$id])) {
             foreach ($this->writeWatchers[$id] as $watcher) {
                 ($watcher->callback)($watcher->id, $watcher->stream, $watcher->data);
             }
         }
     };
     $this->signalCallback = function ($event, int $signo) {
         if (isset($this->signalWatchers[$signo])) {
             foreach ($this->signalWatchers[$signo] as $watcher) {
                 ($watcher->callback)($watcher->id, $watcher->signo, $watcher->data);
             }
         }
     };
 }

function iterate_queue_with_mode($mode)
{
    $x = new SplQueue();
    $x->setIteratorMode($mode);
    $x->push(1);
    $x->push(2);
    $x->push(3);
    foreach ($x as $y) {
        var_dump($y);
    }
    var_dump(count($x));
}

 /**
  * Load memberOf for the current user - 1 LDAP query
  *
  * @param Manager $ldap
  * @param array $userData
  * @param array $allowedGroups
  * @return array (groupDn => groupName)
  */
 protected function getUserMemberOf(Manager $ldap, array $userData, array $allowedGroups)
 {
     $memberOf = array();
     $processed = array();
     $iterator = new \SplQueue();
     $iterator->setIteratorMode(\SplQueue::IT_MODE_DELETE);
     // Load membership
     $raw = $ldap->search(null, Utils::getUserLookup($userData['username']), true, array('memberof'));
     if (!$raw->current() instanceof Node) {
         return array();
     }
     $attrs = $raw->current()->getAttributes();
     if (!array_key_exists('memberOf', $attrs) || !$attrs['memberOf'] instanceof NodeAttribute) {
         return array();
     }
     // Post process all groups into memberOf array, put them into iterator for inheritance loading
     foreach ($attrs['memberOf'] as $groupDn) {
         $memberOf[$groupDn] = Utils::loadNameFromDn($groupDn);
         if (isset($processed[$groupDn])) {
             continue;
         }
         $iterator->enqueue($groupDn);
         $processed[$groupDn] = true;
     }
     // Loop iterator & load all inherits
     while (!$iterator->isEmpty()) {
         $groupDn = $iterator->dequeue();
         $inherits = $this->getGroupMemberOf($ldap, $groupDn);
         foreach ($inherits as $one) {
             /** @var Node $one */
             if (isset($processed[$one->getDn()])) {
                 continue;
             }
             $processed[$one->getDn()] = true;
             $iterator->enqueue($one->getDn());
             $memberOf[$one->getDn()] = Utils::loadNameFromDn($one->getDn());
         }
     }
     return $memberOf;
 }

<?php

$queue = new SplQueue();
try {
    $queue->setIteratorMode(SplDoublyLinkedList::IT_MODE_LIFO);
} catch (Exception $e) {
    echo $e->getMessage();
}

/* SPL QUEUE  */
$qoperatingsystems = new SplQueue();
$qoperatingsystems->push(array('Windows 7', 'desktop', 'NT', 56.11));
$qoperatingsystems->push(array('Windows XP', 'desktop', 'NT', 10.59));
$qoperatingsystems->push(array('Windows 8', 'desktop', 'NT', 2.88));
$qoperatingsystems->push(array('Windows 8.1', 'desktop', 'NT', 11.15));
$qoperatingsystems->push(array('Windows 10', 'desktop', 'NT', 9));
$qoperatingsystems->push(array('Windows Vista', 'desktop', 'NT', 0));
$qoperatingsystems->push(array('Mac OS X 11', 'desktop', 'Unix', 2.66));
$qoperatingsystems->push(array('Mac OS X 10', 'desktop', 'Unix', 2.45));
$qoperatingsystems->push(array('Linux Mint', 'desktop', 'Linux', 0));
$qoperatingsystems->push(array('Linux Debian', 'desktop', 'Linux', 0));
$qoperatingsystems->push(array('Android', 'mobile', 'Linux', 48.12));
$qoperatingsystems->push(array('iOS', 'mobile', 'Unix', 34.71));
echo "\nSPL QUEUE ARRAY FOR LOOP: FIFO\n";
$qoperatingsystems->setIteratorMode(SplDoublyLinkedList::IT_MODE_FIFO);
for ($qoperatingsystems->rewind(); $qoperatingsystems->valid(); $qoperatingsystems->next()) {
    echo $qoperatingsystems->current()[0] . "\n";
    echo $qoperatingsystems->current()[1] . "\n";
    echo $qoperatingsystems->current()[2] . "\n";
    echo $qoperatingsystems->current()[3] . "\n";
}
/* ------------------BASIC OPERATIONS------------------ */
// SORT
// BY LANGUAGE RANKING
usort($nlanguages, function ($a, $b) {
    return $b[2] - $a[2];
});
// FILTER
// BY DATABASE SIZE
function serveronly($var)

<?php

$queue = new SplQueue();
$queue->push(1);
$queue->push(2);
$queue->push(4);
$queue->push(3);
$queue->setIteratorMode(SplQueue::IT_MODE_DELETE);
foreach ($queue as $k => $v) {
    printf("%s => %s\n", $k, $v);
}

/**
 * Return n independent iterators from a single iterable, useful when you
 * dealing with no rewind iterator, but need to traverse more that 1 time.
 */
function tee($iterable, $n = 2)
{
    $iter = iter($iterable);
    $deques = array_map(function ($_) {
        $queue = new \SplQueue();
        $queue->setIteratorMode(\SplQueue::IT_MODE_DELETE);
        return $queue;
    }, \range(0, $n - 1));
    return \array_map(function ($locdeque) use($iter, $deques) {
        while (true) {
            // in case the local deque is empty we will fecth data from
            // original iterator, and pass them to all dequeues.
            if ($locdeque->isEmpty()) {
                if (!$iter->valid()) {
                    return;
                }
                $newval = $iter->current();
                foreach ($deques as $d) {
                    $d->enqueue($newval);
                }
                $iter->next();
            }
            (yield $locdeque->dequeue());
        }
    }, $deques);
}

 public function __construct()
 {
     $this->handlers = [];
     $this->signalQueue = new \SplQueue();
     $this->signalQueue->setIteratorMode(\SplQueue::IT_MODE_DELETE);
 }

 /**
  * executes the container a optional array may be passed to this method that keeps additional parameters
  * which will be passed after the actor as parameters to each entity call.
  *
  * @param array $executeArguments
  * @throws QueueException|FatalQueueException
  */
 public function execute(array $executeArguments = [])
 {
     $priorities = array_combine(array_keys($this->items), array_column($this->items, 'priority'));
     $priorityStack = new \SplQueue();
     $priorityStack->setIteratorMode(\SplQueue::IT_MODE_DELETE);
     array_map([$priorityStack, 'enqueue'], array_keys($priorities));
     foreach ($priorityStack as $dequeuedItem) {
         if (is_int($priorities[$dequeuedItem])) {
             continue;
         }
         if (!array_key_exists(current($priorities[$dequeuedItem]), $priorities)) {
             throw new QueueException(sprintf('Foundry container item with name `%s` points to an unavailable container item with name `%s`', $dequeuedItem, current($priorities[$dequeuedItem])));
         }
         if (current($priorities[$dequeuedItem]) === $dequeuedItem) {
             throw new QueueException(sprintf('Foundry container item with name `%s` points to `%s`, self-recursion detected', $dequeuedItem, current($priorities[$dequeuedItem])));
         }
         if (is_array($priorities[current($priorities[$dequeuedItem])]) && current($priorities[current($priorities[$dequeuedItem])]) === $dequeuedItem) {
             throw new QueueException(sprintf('Foundry container item with name `%s` points to `%s` which points to `%s`, recursion detected', $dequeuedItem, current($priorities[$dequeuedItem]), current($priorities[current($priorities[$dequeuedItem])])));
         }
         if (!is_int($priorities[current($priorities[$dequeuedItem])])) {
             $priorityStack->enqueue($dequeuedItem);
             continue;
         }
         if ('before' === key($priorities[$dequeuedItem])) {
             $priorities[$dequeuedItem] = $priorities[current($priorities[$dequeuedItem])] - 1;
         } else {
             if ('after' === key($priorities[$dequeuedItem])) {
                 $priorities[$dequeuedItem] = $priorities[current($priorities[$dequeuedItem])] + 1;
             }
         }
     }
     asort($priorities);
     $priorityStack->setIteratorMode(\SplQueue::IT_MODE_KEEP);
     array_map([$priorityStack, 'enqueue'], array_keys($priorities));
     array_unshift($executeArguments, new Actor($priorityStack));
     foreach ($priorityStack as $current) {
         if (false !== $this->closureBinding && $this->items[$current]['callable'] instanceof \Closure) {
             $callable = call_user_func_array([$this->items[$current]['callable'], 'bindTo'], $this->closureBinding);
         } else {
             $callable = $this->items[$current]['callable'];
         }
         try {
             call_user_func_array($callable, $executeArguments);
         } catch (\LogicException $exception) {
             throw new QueueException('Callable logic execution failed', 0, $exception);
         } catch (\RuntimeException $exception) {
             throw new FatalQueueException('Callable logic ends in fatal state', 500, $exception);
         }
     }
 }