PHP Iterator::current方法代码示例

 /**
  * Lazily append the next iterator to the chain
  */
 private function lazyAppend()
 {
     if (!parent::valid() and $this->iterators->valid()) {
         $this->append($this->iterators->current());
         $this->iterators->next();
     }
 }

	public function current(){
		if ($this->innerHasItems === true){
			return $this->innerIterator->current();
		} else {
			return $this->defaultValue;
		}
	}

 /**
  * {@inheritdoc}
  */
 public function current()
 {
     if (!$this->iterableResult) {
         $this->rewind();
     }
     return $this->iterableResult->current();
 }

 private function getCurrentIterator()
 {
     if (null === $this->currentIterator) {
         $this->currentIterator = $this->mainIterator->current();
     }
     return $this->currentIterator;
 }

 /**
  * @param ObserverInterface $observer
  * @param SchedulerInterface|null $scheduler
  * @return \Rx\Disposable\CompositeDisposable|\Rx\DisposableInterface
  */
 public function subscribe(ObserverInterface $observer, SchedulerInterface $scheduler = null)
 {
     $scheduler = $scheduler ?: new ImmediateScheduler();
     $key = 0;
     return $scheduler->scheduleRecursive(function ($reschedule) use(&$observer, &$key) {
         try {
             //HHVM requires you to call next() before current()
             if (defined('HHVM_VERSION')) {
                 $this->items->next();
                 $key = $this->items->key();
             }
             if (null === $key) {
                 $observer->onCompleted();
                 return;
             }
             $current = $this->items->current();
             $observer->onNext($current);
             if (!defined('HHVM_VERSION')) {
                 $this->items->next();
                 $key = $this->items->key();
             }
             $reschedule();
         } catch (\Exception $e) {
             $observer->onError($e);
         }
     });
 }

 public function valid()
 {
     get_next:
     // Return true if this function has already been called for iteration.
     if ($this->currentRequest) {
         return true;
     }
     // Return false if we are at the end of the provided commands iterator.
     if (!$this->commands->valid()) {
         return false;
     }
     $command = $this->commands->current();
     if (!$command instanceof CommandInterface) {
         throw new \RuntimeException('All commands provided to the ' . __CLASS__ . ' must implement GuzzleHttp\\Command\\CommandInterface.' . ' Encountered a ' . Core::describeType($command) . ' value.');
     }
     $command->setFuture('lazy');
     $this->attachListeners($command, $this->eventListeners);
     // Prevent transfer exceptions from throwing.
     $command->getEmitter()->on('process', function (ProcessEvent $e) {
         if ($e->getException()) {
             $e->setResult(null);
         }
     }, RequestEvents::LATE);
     $builder = $this->requestBuilder;
     $result = $builder($command);
     // Skip commands that were intercepted with a result.
     if (isset($result['result'])) {
         $this->commands->next();
         goto get_next;
     }
     $this->currentRequest = $result['request'];
     return true;
 }

 public function current()
 {
     if (!$this->usingCache) {
         $this->array[$this->position] = $this->innerIterator->current();
     }
     return $this->array[$this->position];
 }

 /**
  * @return Mixed|null Returns null if out of range
  */
 public function current()
 {
     if (!$this->baseIterator->valid()) {
         return null;
         // out of range
     }
     return call_user_func_array($this->vCallback, array($this->baseIterator->current()));
 }

 /**
  * Returns the current element.
  *
  * @return \SplFileInfo
  *
  * @throws FileSystemException If called after the last element has been returned.
  */
 public function current()
 {
     try {
         return $this->iterator->current();
     } catch (\RuntimeException $e) {
         throw FileSystemException::wrap($e);
     }
 }

 private function memo()
 {
     if (!$this->it->valid()) {
         return;
     }
     array_push($this->cache, array($this->it->key(), $this->it->current()));
     $this->cacheSize++;
 }

 private function fetch()
 {
     if ($this->it->valid()) {
         $this->v = $this->it->current();
         $this->k = $this->it->key();
         $fn = $this->fn;
         $fn($this->v, $this->k);
     }
 }

 private function fetch()
 {
     if ($this->it->valid()) {
         $v = $this->it->current();
         $k = $this->it->key();
         $this->v = $this->valueSelector->select($v, $k);
         $this->k = $this->keySelector->select($v, $k);
     }
 }

 public function fetch($fetchMode = null)
 {
     if (!$this->currentIterator) {
         $this->currentIterator = $this->getIterator();
     }
     $data = $this->currentIterator->current();
     $this->currentIterator->next();
     return $data;
 }

 public function current()
 {
     if ($this->projectionNeeded) {
         $projection = $this->projection;
         $this->current = $projection($this->innerIterator->current(), $this->innerIterator->key(), $this->innerIterator);
         $this->projectionNeeded = false;
     }
     return $this->current;
 }

 public function current()
 {
     $current = $this->iterator->current();
     $fileCrate = new \HQ\ErrorMonitorinq\FileCrate();
     $fileCrate->name = $current["Key"];
     $fileCrate->size = $current["Size"];
     $fileCrate->lastModified = new \DateTime($current["LastModified"]);
     return $fileCrate;
 }