(non-PHPdoc)
@see Iterator::next()
3324
function next() {
        $this->unmoved = false;
        if ($this->valid()) {
            $this->currentInstance++;
            if (!isset($this->instanceCache[$this->currentInstance])) {
                // try to load next block (unless we know it's empty)
                $remainingInstances = !$this->endOfResource && $this->load($this->resourceIterator->current(), $this->currentInstance);

                // endOfClass or failed loading
                if (!$remainingInstances) {
                    $this->resourceIterator->next();
                    $this->ensureNotEmpty();
                }
            }
            $this->ensureValidResult();
        }
    }
203603
public function setNext($next)
    {
        $this->_links[self::NEXT][self::HREF] = $next;
        $this->removeEmptyLinks();

        return $this;
    }
572246
public function next()
    {
        if ($this->current === null) {
            $this->rewind();
        }

        if ($this->validationResult !== static::END_ITERATION) {
            $this->key++;

            $this->incrementCurrentDateUntilValid();
        }
    }
1357771
public function next() {
    // the current oid was processed
    $this->processedOidList[] = $this->currentOid->__toString();

    $node = $this->persistenceFacade->load($this->currentOid);

    // collect navigable children for the given aggregation kinds
    $childOIDs = [];
    $mapper = $node->getMapper();
    $relations = $mapper->getRelations('child');
    $followAll = sizeof($this->aggregationKinds) == 0;
    foreach ($relations as $relation) {
      $aggregationKind = $relation->getOtherAggregationKind();
      if ($relation->getOtherNavigability() && ($followAll || in_array($aggregationKind, $this->aggregationKinds))) {
        $childValue = $node->getValue($relation->getOtherRole());
        if ($childValue != null) {
          $children = $relation->isMultiValued() ? $childValue : [$childValue];
          foreach ($children as $child) {
            $childOIDs[] = $child->getOID();
          }
        }
      }
    }
    $this->addToQueue($childOIDs, ++$this->currentDepth);

    // set current node
    if (sizeof($this->oidList) != 0) {
      list($oid, $depth) = array_pop($this->oidList);
      $oidStr = $oid->__toString();
      // not the last node -> search for unprocessed nodes
      while (sizeof($this->oidList) > 0 && in_array($oidStr, $this->processedOidList)) {
        list($oid, $depth) = array_pop($this->oidList);
        $oidStr = $oid->__toString();
      }
      // last node found, but it was processed already
      if (sizeof($this->oidList) == 0 && in_array($oidStr, $this->processedOidList)) {
        $this->end = true;
      }
      $this->currentOid = $oid;
      $this->currentDepth = $depth;
    }
    else {
      $this->end = true;
    }
    return $this;
  }
980952
function next(){
		if( ! $this->length ){
			return false;
		}
		$p = $this->p + 1;
		if( !isset($this->children[$p]) ){
			$this->p = 0;
			return false;
		}
		$this->p = $p;
		return $this->children[$p];
	}
1125017
public function next() {
        if (is_int($this->current)) {
            return $this->get($this->current + 1);
        }

        return $this->first;
    }
1067280
public function next()
    {
        $this->peek = 0;
        if (isset($this->tokens[$this->current])) {
            return $this->tokens[$this->current++];
        }
    }
736927
public function next()
    {
        if (!isset($this->buffer[++$this->position])
            && $this->position != $this->resultSet->key() // Avoid calling next() when
                                                          // a complete iteration was already done
        ) {
            $this->resultSet->next();
        }
    }
571454
public function next()
    {
        $callStack = $this->finding->getCallStack();

        $callable = $callStack->getNextCallable();

        if($callable->hasDependencies())
        {
            $args = array();

            foreach($callable->getDependencies() as $injectable)
                $args[] = $this->tokenResolve($injectable);

            $context = $this;

            // $next callable
            $next = function() use($context, &$next)
            {
                $args = func_get_args();

                $args[] = $next;

                return call_user_func_array(array($context, 'next'), $args);
            };

            $args[] = $next;

            return call_user_func_array($callable, $args);
        }

        return call_user_func_array($callable, func_get_args());
    }
1157931
public function next()
    {

        $this->index++;

        if ($this->className) {
            $this->value = $this->query->getObject($this->className);
        } else {
            $this->value = $this->query->getRow();
        }

        return $this;
    }
352756
public function next($offset = 1)
    {
        $offset = (null === $offset) ? 1 : $offset % $this->count();
        $this->rotation = \array_merge(
            \array_slice(
                $this->rotation,
                $offset
            ),
            \array_slice(
                $this->rotation,
                0,
                $offset
            )
        );
    }
608960
public function next() {
		if ($this->currentRecord < count($this->files)) {
			$file = $this->files[$this->currentRecord];
			$this->currentRecord++;
			return $file;
		} else {
			return false;
		}
	}
1329978
public function next()
    {
        if ((int) $this->current()->query->getValue('o') >= $this->nbPages) {
            return null;
        }

        return $this->getIndexUrl(+1);
    }
987883
public function next()
    {
        if ($this->cacheFilesIterator === null) {
            $this->rewind();
        }
        $this->cacheFilesIterator->next();
        while ($this->cacheFilesIterator->isDot() && $this->cacheFilesIterator->valid()) {
            $this->cacheFilesIterator->next();
        }
    }
1030508
function next() {
        if ($this->valid()) {
            $last = $this->key();
            $this->currentResult++;
            if (!isset($this->cache[$this->currentResult])) {
                $this->load($last+1);
            }
        }
    }
1177710
public function next()
    {
        if (count($this->data) > 0) {
            array_shift($this->data);
        }
        ++$this->position;

        if (count($this->data) == 0 && !is_null($this->resumptionToken)) {
            $this->fetchMore();
        }

        if (count($this->data) == 0) {
            return null;
        }
    }
1194781
public function next()
    {
        $keys  = array_keys($this->items);
        $index = array_search($this->currentKey, $keys);

        $index++;

        $this->currentKey = array_key_exists($index, $keys) ? $keys[$index] : null;
    }