Retrieve next node.

@return NodeContract|null
508095
public function next()
    {
        return $this->getParent() !== null ? $this->getParent()->getChildByIndex($this->getIndex() + 1) : null;
    }
1358580
public function getNext()
    {
        if ($this->currentToken !== null || strlen($this->currentInput) > 0) {
            $this->parseNextToken();

            return $this->currentToken;
        }

        return null;
    }
87842
public function getNext()
    {
        return is_null($this->next) ? null : new ViewFile($this->project, $this->next);
    }
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;
        }
    }
978811
protected function NextItem()
	{
		while (true)
		{
			if ( ! is_null( $this->childIter ) )
			{
				if ( $this->childIter->MoveNext() )
					return $this->childIter->getCurrent();
				else
					$this->childIter = null;
			}

			if ( $this->index == count( $this->nodes ) )
				return null;

			$res = $this->nodes[ $this->index++ ]->Execute( $this->provider, $this->dataPool );
			if ( $res instanceof Undefined ) continue;

			if ( $res instanceof XPath2NodeIterator )
			{
				// BMS 2018-02-28 Seems like this is necessary because if the iterator has been used before the index will be wrong
				$res->Reset();
				$this->childIter = $res;
			}
			else
			{
				if ( $res instanceof XPathItem )
					return $res;

				return XPath2Item::fromValue( $res );
			}
		}
	}
608331
public function getNextLine()
    {
        if ( $this->hasMoreMailData === false )
        {
            $this->nextMail();
        }
        // finished?
        if ( $this->fp == null || feof( $this->fp ) )
        {
            if ( $this->fp != null )
            {
                fclose( $this->fp );
                $this->fp = null;
            }
            return null;
        }

        // get one line
        $next = fgets( $this->fp );
        if ( $next == "" && feof( $this->fp ) )
        {
            return null;
        }
        return $next;
    }
1188180
public function getNext()
    {
        if (false === $this->pointer || !$this->count || $this->count == $this->pointer) {
            return null;
        }
        
        $pointer = $this->pointer + 1;
        
        return isset($this->ids[$pointer]) ? $this->ids[$pointer] : null;
    }
547870
protected function NextItem()
	{
		/**
		 * @var \XBRL_Instance $instance
		 */
		$instance = $this->context->xbrlInstance;

		while ( true )
		{
			if ( ! $this->iterator->MoveNext() )
			{
				return null;
			}

			$node = $this->iterator->getCurrent();

			if ( $this->nonNilOnly )
			{
				// Look for an xsi:nil and ignore the element if there is one
				$nodeTest = XmlQualifiedNameTest::create( "nil", SCHEMA_INSTANCE_NAMESPACE );
				$attributes = AttributeNodeIterator::fromNodeTest( $this->context, $nodeTest, XPath2NodeIterator::Create( $node ) );
				if ( $attributes->MoveNext() )
				{
					// There is an attrubute.  It is true?
					if ( filter_var( $attributes->getCurrent()->getValue(), FILTER_VALIDATE_BOOLEAN ) )
					{
						continue;
					}
				}
			}

			// Look up the node namespace in the instance taxonomy
			$taxonomy = $instance->getTaxonomyForNamespace( $node->getNamespaceURI() );
			if ( ! $taxonomy )
			{
				continue;
			}

			$prefix = $taxonomy->getPrefix();

			$taxonomyElement = $this->types->getElement( $node->getLocalName(), $prefix  );
			if ( ! $taxonomyElement )
			{
				continue;
			}

			// This node MUST have a substitution group attribute and the attribute MUST resolve to xbrli:tuple or xbrli:item
			if ( ! isset( $taxonomyElement['substitutionGroup'] ) )
			{
				continue;
			}

			if ( ! $this->types->resolveToSubstitutionGroup( $taxonomyElement['substitutionGroup'], $this->substitutionGroups ) )
			{
				continue;
			}

			// If the node value is empty themn apply the schema default (if there is one)
			if ( isset( $taxonomyElement['default'] ) && empty( $node->getUnderlyingObject()->nodeValue ) )
			{
				$node->getUnderlyingObject()->nodeValue = $taxonomyElement['default'];
			}

			return $node->CloneInstance();
		}

	}
338031
public function resolveNextNode(NodeContract $node, NodeContract $new_node)
    {
        if ($new_node->next() && $new_node->next() instanceof ComparableNodeContract) {
            $new_node->moveNodeAsChild($new_node->next());
        } else {
            throw new Exceptions\QuerySyntaxException($node->getRoot()->getValue());
        }
    }
1067280
public function next()
    {
        $this->peek = 0;
        if (isset($this->tokens[$this->current])) {
            return $this->tokens[$this->current++];
        }
    }
902861
public function next()
    {
        if ( ! $this->queryResult ||
             ! $this->queryResult->getAffectedRows() )
        {
            $this->currentSiteInfo = null;
            return null;
        }

        $this->restoreServices();
        $this->queryResult->next();
        return $this->createCurrentSiteInfo();
    }
423119
public function nextNews()
    {
        $next = $this->newsManager()->next();

        if (!$next) {
            return null;
        }

        return $this->newsFormatNav($next);
    }
1334421
protected function NextItem()
	{
		if ( $this->_index <= $this->_max )
			return XPath2Item::fromValue( $this->_index++ );
		return null;
	}
532090
public function moveNext()
    {
        $this->peek = 0;
        $this->token = $this->next;
        $this->next = isset($this->tokens[++$this->i]) ? $this->tokens[$this->i] : null;

        return null !== $this->next;
    }
42320
private function _continue() {
    $node = new ContinueStatementNode();
    $this->mustMatch(T_CONTINUE, $node);
    if ($this->tryMatch(';', $node, NULL, TRUE, TRUE) || $this->currentType === T_CLOSE_TAG) {
      return $node;
    }
    $this->parseLevel($node);
    $this->endStatement($node);
    return $node;
  }
899090
public function next()
    {
        $cls  = $this->_cls;
        $data = $this->_getCurrentData();

        if (!$data) {
            $this->_curval = null;
            return $this->_curval;
        } else {
            ++$this->_count;
            $this->_curval = $data;
            return new $this->_cls($this->_curval);
        }
    }
794661
public function getSiblingNode()
    {
        if ($this->siblingDomAddress === null) {
            return null;
        }

        if ($this->cachedSiblingNode === null) {
            $this->cachedSiblingNode = $this->nodeService->getNodeFromContextPath(
                $this->siblingDomAddress->getContextPath()
            );
        }

        return $this->cachedSiblingNode;
    }