{@inheritdoc}

@since [*next-version*]
421595
protected function _normalizeErrorList($errorList)
    {
        $listIterator = new AppendIterator();
        foreach ($errorList as $_error) {
            $listIterator->append($this->_normalizeIterator($_error));
        }

        return $listIterator;
    }
281120
@Override
	public Date next() {
		if (!hasNext()) {
			throw new NoSuchElementException(toString() + " ended");
		}

		current = next;
		computeNext();

		return current();
	}
1087581
@Override
  public T next() {
    Assert.isTrue(hasNext(), new NoSuchElementException("The iteration has no more elements!"));
    T nextValue = iteratorList.get(currentIteratorIndex).next();
    currentIteratorIndex = (++currentIteratorIndex % iteratorList.size());
    nextCalled.set(true);
    return nextValue;
  }
851858
public function next()
    {
        $this->key++;
        if (\PDO::FETCH_COLUMN !== $this->fetchMode) {
            $this->current = $this->queryResult->fetch(
                    $this->fetchMode,
                    $this->driverOptions
            );
        } else {
            $this->current = $this->queryResult->fetchOne(
                    $this->driverOptions['columnIndex'] ?? 0
            );
        }
    }
211485
protected function NextItem()
	{
		$keys = array_keys( $this->itemSet );

		while ( $this->elementIndex < count( $keys ) )
		{
			/**
			 * @var array $elements
			 */
			$elements = $this->itemSet[ $keys[ $this->elementIndex ] ];

			while ( $this->index < count( $elements ) )
			{
				/**
				 * @var XPathItem $item
				 */
				$item = $elements[ $this->index++ ] ;

				if ( $item instanceof XPathNavigator )
				{
					/**
					 * @var XPathNavigator $node
					 */
					$node = $item;

					if ( ! is_null( $this->lastNode ) )
					{
						if ( $this->lastNode->IsSamePosition( $node ) )
						{
							continue;
						}
					}
					$this->lastNode = $node->CloneInstance();
				}

				return $item;
			}

			$this->elementIndex++;
			$this->index = 0;
			$this->lastNode = null;
		}
		return null;
	}
760884
private function findSibling(Collection $elements, SortableInterface $current, $next = false)
    {
        if ($next) {
            $sibling = $elements->filter(function (SortableInterface $s) use ($current) {
                return $s->getPosition() > $current->getPosition();
            })->first();
        } else {
            $sibling = $elements->filter(function (SortableInterface $s) use ($current) {
                return $s->getPosition() < $current->getPosition();
            })->last();
        }

        return $sibling ?: null;
    }
3113
public function execute($n)
    {
        $stack = array();
        $i = 0;
        $total = count($this->tokens);
        while ($i < $total) {
            $next = $this->tokens[$i];
            $i++;
            if ($next[0] === 'var') {
                $stack[] = $n;
                continue;
            } elseif ($next[0] === 'value') {
                $stack[] = $next[1];
                continue;
            }

            // Only operators left.
            switch ($next[1]) {
                case '%':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 % $v2;
                    break;

                case '||':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 || $v2;
                    break;

                case '&&':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 && $v2;
                    break;

                case '<':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 < $v2;
                    break;

                case '<=':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 <= $v2;
                    break;

                case '>':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 > $v2;
                    break;

                case '>=':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 >= $v2;
                    break;

                case '!=':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 != $v2;
                    break;

                case '==':
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 == $v2;
                    break;

                case '?:':
                    $v3 = array_pop($stack);
                    $v2 = array_pop($stack);
                    $v1 = array_pop($stack);
                    $stack[] = $v1 ? $v2 : $v3;
                    break;

                default:
                    throw new Exception(sprintf('Unknown operator "%s"', $next[1]));
            }
        }

        if (count($stack) !== 1) {
            throw new Exception('Too many values remaining on the stack');
        }

        return (int) $stack[0];
    }
1157931
public function next()
    {

        $this->index++;

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

        return $this;
    }
469335
final public function next()
    {
        if (!$this->hasNext()) {
            return null;
        }

        $result = $this->client->performHttpCallToFullUrl(MollieApiClient::HTTP_GET, $this->_links->next->href);

        $collection = new static($this->client, $result->count, $result->_links);

        foreach ($result->_embedded->{$collection->getCollectionResourceName()} as $dataResult) {
            $collection[] = ResourceFactory::createFromApiResult($dataResult, $this->createResourceObject());
        }

        return $collection;
    }
1334421
protected function NextItem()
	{
		if ( $this->_index <= $this->_max )
			return XPath2Item::fromValue( $this->_index++ );
		return null;
	}
488393
@Override
	public void nextPage() {
		if (!paged) {			
			this.firstPage();
			paged = true;
		} else if (!isLast()) {
			offset = (getPageNumber() + 1) * pageSize;

			execute();
		}
	}
133121
public function next()
    {
        if ($this->x + 1 < $this->width) {
            $this->x++;
        } else {
            $this->x = 0;
            $this->y++;
        }

        $this->index++;
    }
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;
        }
    }
1008357
public function next()
    {
        parent::next();
        if ($this->_validValues) {
            $this->_values->next();
        }
        $this->_validValues = $this->_values->valid();
    }
730479
@Override
    public DataStreamingEvent<E> next() throws DataSourceReadException {
        lockChain();
        updateCurrentIterator();
        lastUsedIterator = currentIterator;
        return currentIterator.next();
    }
513119
@Override
	public AbstractMessage nextElement()
	{
		if (endOfQueueReached)
			throw new NoSuchElementException();
			
		try
		{
			checkNotClosed();
			AbstractMessage msg = fetchNext();
			if (msg != null)
			{
				nextMessage = null; // Consume fetched message

				// Make sure the message is fully deserialized and marked as read-only
				msg.ensureDeserializationLevel(MessageSerializationLevel.FULL);
				msg.markAsReadOnly();
				
				return msg;
			}
			
			throw new NoSuchElementException();
		}
		catch (NoSuchElementException e)
		{
			throw e;
		}
		catch (JMSException e)
		{
			throw new IllegalStateException(e.toString());
		}
	}
116856
@Override
    public E next()
    {
        if (results != null && !results.isEmpty() && count < results.size())
        {
            current = results.get(count++);
            return current;
        }
        else
        {
            throw new NoSuchElementException(
                    "No object found in the iterator... Use hasNext() to check for valid next()");
        }
    }