{@inheritdoc}

@since [*next-version*]
778423
protected function _calculateValue(Iterator $iterator)
    {
        $value = parent::_calculateValue($iterator);

        return $this->_dereferenceTokens($value);
    }
905986
public function next()
    {
        $iterator = $this->iterators[$this->index];
        $next = $iterator->next();

        if (false === $this->valid() && isset($this->iterators[$this->index + 1])) {
            $this->index++;
        }
    }
395470
public function next()
    {
        $this->index++;

        // Prefetch the next element
        if ($this->validOnNext) $this->prefetch();

        if ($this->uses_groups) {
            // Notify the grouping helper of the change
            $this->groups->reset();
        }
    }
989078
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->currentInstance);
            }
        }
    }
765012
@Override
    public Object next() {
        Object retVal = null;
        try {
            retVal = nextEvent();
        } catch (final XMLStreamException e) {
            retVal = null;
        }
        return retVal;
    }
730479
@Override
    public DataStreamingEvent<E> next() throws DataSourceReadException {
        lockChain();
        updateCurrentIterator();
        lastUsedIterator = currentIterator;
        return currentIterator.next();
    }
511830
@Override
    protected E findNext(){
        while(true){
            E elem = delegate.next();
            if(elem==null || filter.select(elem))
                return elem;
        }
    }
608739
@Override
	public T next() {

		validateState();

		if (!hasNext()) {
			throw new NoSuchElementException("No more elements available for cursor " + getCursorMark() + ".");
		}

		T next = moveNext(delegate);
		position++;
		return next;
	}
315756
@Override
    public List<Writable> next() {
        if(!hasNext()){ //Also triggers prefetch
            throw new NoSuchElementException("No next element");
        }
        List<Writable> out = next.getRecord();
        next = null;
        return out;
    }
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;
  }
205436
function next()
    {
        if (isset($this->_limit) && $this->offset >= $this->_limit)
        {
            return null;
        }
    
        if (!isset($this->data) || ($this->pos >= sizeof($this->data) && $this->truncated))
        {
            $this->loadNextPage();
        }
        
        if ($this->pos < sizeof($this->data))
        {
            $item_data = $this->data[$this->pos];
            $this->pos++;        
            $this->offset++;            
            $cls = $this->item_cls;
            return new $cls($this->api, $item_data, true);
        }
        else
        {
            return null;
        }
    }
158799
public function next()
    {
        if (isset($this->current->next)) {
            $this->current = $this->current->next;
        } else {
            $this->current->next = new ClassNode(null, $this->current);
            $this->current = $this->current->next;
        }
    }
523244
public function next() {
    // the current node was processed
    $this->processedOidList[] = $this->currentNode->getOID()->__toString();

    // collect navigable children for the given aggregation kinds
    $childrenArray = [];
    $mapper = $this->currentNode->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 = $this->currentNode->getValue($relation->getOtherRole());
        if ($childValue != null) {
          $children = $relation->isMultiValued() ? $childValue : [$childValue];
          foreach ($children as $child) {
            $childrenArray[] = $child;
          }
        }
      }
    }
    $this->addToQueue($childrenArray);

    // set current node
    if (sizeof($this->nodeList) != 0) {
      $node = array_pop($this->nodeList);
      $oidStr = $node->getOID()->__toString();
      // not the last node -> search for unprocessed nodes
      while (sizeof($this->nodeList) > 0 && in_array($oidStr, $this->processedOidList)) {
        $node = array_pop($this->nodeList);
        $oidStr = $node->getOID()->__toString();
      }
      // last node found, but it was processed already
      if (sizeof($this->nodeList) == 0 && in_array($oidStr, $this->processedOidList)) {
        $this->end = true;
      }
      $this->currentNode = $node;
    }
    else {
      $this->end = true;
    }
    return $this;
  }
259756
public function next()
    {
        $row = $this->getRow($this->pointer);
        if (!is_null($row)) {
            $this->pointer++;
        }
    }
1157931
public function next()
    {

        $this->index++;

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

        return $this;
    }
5029
public function next()
    {
        if (is_null($this->current)) {
            $this->current = current($this->children);

            return;
        }
        if ($this->current instanceof RecursiveLeafInterface) {
            $this->current->next();
            if ($this->current->valid()) {
                return;
            }
        }
        $this->current = next($this->children);
    }
438915
public function next()
    {
        $operation   = $this->operation;
        $this->value = $operation($this->value);
        $this->elementsGenerated++;
    }