Retrieves the next FixedSizeCollection using one or more API calls.

@return FixedSizeCollection
549302
public function getNextCollection()
    {
        $lastPage = $this->getLastPage();
        $nextPage = $lastPage->getNextPage($this->collectionSize);
        return new FixedSizeCollection($nextPage, $this->collectionSize);
    }
175017
public function getNextRelease()
    {
        if (!$this->nextRelease) {
            $manual = $this->getOption('release');
            $manual = $this->isRelease($manual) ? $manual : null;

            $this->nextRelease = $manual ?: $this->bash->getTimestamp();
        }

        return $this->nextRelease;
    }
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 );
			}
		}
	}
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;
    }
546221
public function getNext()
    {
        reset($this->groups);
        while ($key = key($this->groups)) {
            $nextGroup = next($this->groups);

            if ($this->groups[$key] === $this->group && $nextGroup) {
                return $nextGroup;
            }
        }

        return $this->group;
    }
1283590
public function getLists()
    {
        if(!$this->isPropertyAvailable('Lists')){
            $this->setProperty("Lists", new ListCollection($this->getContext(),new ResourcePathEntity($this->getContext(),$this->getResourcePath(),"Lists")));
        }
        return $this->getProperty("Lists");
    }
539842
public function nextRowset()
    {
        if ( false !== ( $result = $this->_statement->nextRowset() ) )
        {
            $this->_index = null;
        }

        return $result;
    }
413721
public function getFirst()
    {
        $varReturn = null;
        if (count($this->collection) > 0) {
            $varReturn = $this->collection[0];
        }

        return $varReturn;
    }
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());
    }
508155
protected function NextItem()
	{
		while (true)
		{
			if ( ! is_null( $this->childIter ) )
			{
				if ( $this->childIter instanceof ExprIterator )
				{
					$result = $this->childIter;
					$this->childIter = null;
					return $result;
				}
				else
				{
					if ( $this->childIter->MoveNext() )
						return $this->childIter->getCurrent();
					else
						$this->childIter = null;
				}
			}
			if ( ! $this->iter->MoveNext() )
				return null;

			if ( $this->owner->MoveNext( $this->provider, $this->dataPool, $this->iter->getCurrent(), $res ) )
			{
				if ( $res instanceof XPath2NodeIterator )
				{
					$this->childIter = $res;
				}
				else
				{
					$this->childIter = null;
					return $res instanceof XPathItem
						? $res
						: XPath2Item::fromValue( $res );
				}
			}
		}
	}
874559
public function getNext() {
		$list = $this->getList();
		foreach($list as $migration=>$params) {
			if(!isset($params['migrated']))
				return $migration;
		}
	}
1008097
public function generateCollectionLinks()
    {
        $links = [
            'self' => $this->getPaginator()->getSelf(),
        ];

        if ($first = $this->getPaginator()->getFirst()) {
            $links['first'] = $first;
        }

        if ($previous = $this->getPaginator()->getPrevious()) {
            $links['previous'] = $previous;
        }

        if ($next = $this->getPaginator()->getNext()) {
            $links['next'] = $next;
        }

        if ($last = $this->getPaginator()->getLast()) {
            $links['last'] = $last;
        }

        return $links;
    }
1332998
public function getNext()
	{
		if (! $this->valid()) {
			throw new \OutOfBoundsException('End of iterator reached.');
		}

		$value = $this->get($this->key());

		$this->next();

		return $value;
	}
1209304
public function collections()
    {
        $uri = $this->uri->withPath($this->uri->getPath() . ':listCollectionIds');
        $value = $this->client->post($uri, null);
        $collections = [];

        foreach ($value['collectionIds'] as $id) {
            $collections[] = $this->collection($id);
        }

        return $collections;
    }
646365
public function getCollection()
    {
        if ($this->parent) {
            return $this->parent->getCollection();
        }

        if (!is_object($this->_collection)) {
            $action = $this->controller->action;
            if ($action instanceof self) {
                $scenario = $action->getScenario();
            } else {
                $scenario = $action->id;
            }

            $this->_collection = Yii::createObject(ArrayHelper::merge([
                'class' => Collection::class,
                'model' => $this->controller->newModel(['scenario' => $scenario]),
                'scenario' => $scenario,
                'queryOptions' => $this->queryOptions,
            ], (array) $this->_collection));
        }

        return $this->_collection;
    }
203787
protected function get_collection_from() {
        if ($this->collectionfrom === null) {
            $this->collectionfrom = api::search_competencies('', $this->from);
        }
        return $this->collectionfrom;
    }
1359116
protected function NextItem()
	{
		/**
		 * @var \XBRL $taxonomy
		 */
		$taxonomy = $this->context->xbrlTaxonomy;

		$memberPathPartsCount = count( explode( "/", $this->memberPath ) );

		while ( true )
		{
			if ( is_null( $this->candidates ) || ! is_array( $this->candidates ) || $this->index >= count( $this->candidates ) )
			{
				return null;
			}

			$candidaterPath = $this->candidates[ $this->index++ ];
			$candidaterPathParts = explode( "/", $candidaterPath );

			if ( $this->axis == "DRS-child" )
			{
				// The member at the index can only be child.
				// That is, the count of parts can only be the same as $memberPathPartsCount or just one greater
				if ( count( $candidaterPathParts ) > $memberPathPartsCount + 1 )
				{
					continue;
				}
			}

			$member = $candidaterPathParts[ count( $candidaterPathParts ) - 1 ];
			$memTaxonomy = $taxonomy->getTaxonomyForXSD( $member );
			$memberId = trim( strrchr( $member, "#"), "#" );
			$memElement = $memTaxonomy->getElementById( $memberId );
			$result = QNameValue::fromNCName( "{$memTaxonomy->getPrefix()}:{$memElement['name']}", $this->context->NamespaceManager );

			return $result;

		}

		return null;
	}