NextItem
@return XPathItem
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();
		}

	}
902861
public function next()
    {
        if ( ! $this->queryResult ||
             ! $this->queryResult->getAffectedRows() )
        {
            $this->currentSiteInfo = null;
            return null;
        }

        $this->restoreServices();
        $this->queryResult->next();
        return $this->createCurrentSiteInfo();
    }
374747
public function nextSibling()
    {
        $node = $this->node->nextSibling;

        if ($node === null) {
            return null;
        }

        return new Element($node);
    }
1304522
def next(self):
        """"""
        item = six.next(self._item_iter)
        result = self._item_to_value(self._parent, item)
        # Since we've successfully got the next value from the
        # iterator, we update the number of remaining.
        self._remaining -= 1
        return result
316267
public function next()
    {
        if (!$this->hasError()) {
            $row = $this->_stmt->fetch($this->_schema['fetch']);
            $this->assign($row?:array_fill_keys(array_keys(
                $this->_properties['fields']), null));
        }

        return $this;
    }
127148
public function nextPortion(): Limiter
    {
        \assert('$this->limit > 0');
        if ($this->limit) {
            $this->offset = min($this->offset + $this->limit, $this->total);
            $this->limit = min($this->limit, $this->total - $this->offset);
        }
        return $this;
    }
1229336
public function next()
    {
        $this->hasFoundSheet = $this->xmlReader->readUntilNodeFound(self::XML_NODE_TABLE);

        if ($this->hasFoundSheet) {
            $this->currentSheetIndex++;
        }
    }
1259811
public function next()
    {
        $this->firstItemIdx++;

        if (isset($this->firstItems[$this->firstItemIdx])) {
            return $this->firstItems[$this->firstItemIdx][1];
        } else {
            if (!isset($this->firstItems[$this->firstItemIdx - 1])) {
                $this->items->next();
            }

            if ($this->excludedItems) {
                while (($c = $this->items->current()) && in_array($c->{$this->keyField}, $this->excludedItems, true)) {
                    $this->items->next();
                }
            }
        }

        if (!$this->items->valid()) {
            // iterator has passed the preface items, off the end of the items
            // list. Track through the end items to go through to the next
            if ($this->endItemIdx === null) {
                $this->endItemIdx = -1;
            }

            $this->endItemIdx++;

            if (isset($this->lastItems[$this->endItemIdx])) {
                return $this->lastItems[$this->endItemIdx];
            }

            return false;
        }
    }
708043
protected function &GetNextItem()
    {
        if (is_null($this->oNextItem)) {
            $oActiveItem = &$this->GetActiveItem();
            $oItemList = &$this->GetHotspotConfig()->GetFieldPkgImageHotspotItemList();
            if ($oItemList->Length() < 2) {
                $retValue = null; // write to variable to satisfy strict mode
                return $retValue;
            }
            $oItemList->GoToStart();
            while (is_null($this->oNextItem) && ($oItem = $oItemList->Next())) {
                if ($oItem->IsSameAs($oActiveItem)) {
                    $this->oNextItem = $oItemList->Next();
                    if (false == $this->oNextItem) {
                        $oItemList->GoToStart();
                        $this->oNextItem = $oItemList->Next();
                    }
                }
            }
            if (!is_null($this->oNextItem) && $this->oNextItem->IsSameAs($oActiveItem)) {
                $this->oNextItem = null;
            }
        }

        return $this->oNextItem;
    }
39801
public function nextAll()
    {
        if (!$this->nodes) {
            throw new \InvalidArgumentException('The current node list is empty.');
        }

        return $this->createSubCrawler($this->sibling($this->getNode(0)));
    }
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;
    }
761570
public function getNext(int $step = 1) : Token {
      $position = ($this->position + $step);
      return $this->items[$position] ?? new Token();
    }
1357993
public function next()
    {

        $index = $this->parent->indexOf($this) + 1;

        return isset($this->parent->children[$index]) ? $this->parent->children[$index] : null;
    }
894363
public function next()
    {
        // fetch next entry.
        // if we have no entrys anymore, we add false (which is
        // returned by shiftEntry()) so current() will complain.
        if (count($this->_iteratorCache) - 1 <= $this->count()) {
            $this->_iteratorCache[] = $this->shiftEntry();
        }

        // move on array pointer to current element.
        // even if we have added all entries, this will
        // ensure proper operation in case we rewind()
        next($this->_iteratorCache);
    }
676278
@Override
  public T next() throws NoSuchElementException {
    T result;
    if (peekedItem != null) {
      result = peekedItem.getValue();
      peekedItem = null;
    } else {
      try {
        result = super.next();
      } catch (IOException e) {
        throw new RuntimeException("Failed to read next input", e);
      }
    }
    return result;
  }
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;
    }
1032007
public function getNextOxsort()
    {
        $shopId = \OxidEsales\Eshop\Core\Registry::getConfig()->getShopId();
        $nextSort = oxNew(\OxidEsales\Eshop\Application\Model\Discount::class)->getNextOxsort($shopId);

        return $nextSort;
    }