Returns whether or not there are states after the current one

@return bool true if there is a next state
333358
public function hasNextState()
	{
		return $this->cacheIndexMap[$this->owner->{$this->stateAttribute}] + 1 < count($this->stateConfig);
	}
123212
public function next()
    {
        if (!isset($this->states[++$this->index])) {
            $this->index = 0;
        }

        $state = $this->fab->paint(
            $this->states[$this->index]
        );

        foreach ($this->trajectories as &$trajectory) {
            if (count($trajectory) >= $this->maxWidth) {
                array_shift($trajectory);
            }

            $trajectory[] = $state;
        }

        return $this->trajectories;
    }
229915
private State getNextState(State state) {

        State nextState = null;
        switch (state) {
            case off:
                nextState = State.on;
                break;
            case on:
                nextState = State.off;
                break;
            case middle:
            default:
                nextState = m_nextStateAfterMiddle;
        }
        return nextState;
    }
81857
public boolean next() {
    if (!isInitialized_) {
      level_ = 0;
      i_ = levels_[level_];
      weight_ = 1;
      isInitialized_ = true;
    } else {
      i_++;
    }
    if (i_ < levels_[level_ + 1]) {
      return true;
    }
    // go to the next non-empty level
    do {
      level_++;
      if (level_ == numLevels_) {
        return false; // run out of levels
      }
      weight_ *= 2;
    } while (levels_[level_] == levels_[level_ + 1]);
    i_ = levels_[level_];
    return true;
  }
93654
public function isNew()
    {
        $result = true;
        if($row = $this->getIterator()->current()) {
            $result = $row->isNew();
        }

        return $result;
    }
533660
protected function getNext()
    {
        if (!$this->current)
        {
            return null;
        }
        if ($this->next !== -1)
        {
            return $this->next;
        }
        $this->load();
        for ($i = 0; $i < count($this->items); $i++)
        {
            if ($this->items[$i]->id == $this->current->id)
            {
                if ($i + 1 < count($this->items))
                {
                    $this->next = $this->items[$i + 1];
                    return $this->next;
                }
                break;
            }
        }
        return null;
    }
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;
    }
989321
private function backtrack(): bool
    {
        $found = false;

        do {
            $last = \array_pop($this->trace);

            if ($last instanceof Entry) {
                $found = $this->grammar->fetch($last->getRule()) instanceof Alternation;
            } elseif ($last instanceof Escape) {
                $found = $this->grammar->fetch($last->getRule()) instanceof Repetition;
            } elseif ($last instanceof Token) {
                if (! $this->stream->prev()) {
                    return false;
                }
            }
        } while (0 < \count($this->trace) && $found === false);

        if ($found === false) {
            return false;
        }

        $this->todo = $last->getTodo();
        $this->todo[] = new Entry($last->getRule(), $last->getData() + 1);

        return true;
    }
456253
def Next(self):
        
        try:
            self.key, self.value = next(self.current)
        except StopIteration:

            if self.current != self.second:
                self.current = self.second
                return self.Next()

            return False

        return True
1218812
public function isDirty() : bool
    {
        foreach ($this->__state as $prop => $val) {
            if ($this->isModified($prop)) {
                return true;
            }
        }
        return false;
    }
608738
public function getNextBatch()
    {
        if ($this->_result === [] && $this->_hasMore) {
            // read more from server
            $this->fetchOutstanding();
        }

        if ($this->_result !== []) {
            $result        = $this->_result;
            $this->_result = [];

            return $result;
        }

        // cursor is exhausted
        return false;
    }
857940
protected function hasInvalidState()
    {
        if ($this->isStateless()) {
            return false;
        }
        $state = $this->getSessionData('Socialite.state');
        return !(strlen($state) > 0 && A::get($this->request->getQueryParams(), 'state') === $state);
    }
767440
public function isNew()
    {
        $result = true;
        if($entity = $this->getIterator()->current()) {
            $result = $entity->isNew();
        }

        return $result;
    }
1068947
public function next()
    {
        if (! $this->startedIterating) {
            $this->ensureIterator();
            $this->startedIterating = true;
        } else {
            if ($this->cursorNeedsAdvancing) {
                $this->ensureIterator()->next();
            }

            $this->cursorNeedsAdvancing = true;
            $this->position++;
        }

        return $this->storeIteratorState();
    }
264668
protected function NextItem()
	{
		if ( $this->empty ) return null;

		/**
		 * @var int $index
		 */
		$index = $this->getCurrentPosition() + 1;
		if ( $index < count( $this->buffer ) )
		{
			return $this->buffer[ $index ];
		}
		else if ( ! $this->filled )
		{
			if ( ! $this->src->getIsFinished() )
			{
				if ( $this->src->MoveNext() )
				{
					$current = $this->src->getCurrent();
					$this->buffer[] = $current;
					return $current;
				}
				else
				{
					$this->filled = true;
				}
			}

			if ( ! count( $this->buffer ) )
			{
				$this->empty = true;
			}
		}

		return null;
	}
692238
public function MoveNext()
	{
		if ( ! $this->iterationStarted )
		{
			$this->current = $this->original->CloneInstane();
			$this->iterationStarted = true;
		}
		if ( ! is_null( $this-current ) && $this->current->MoveNext() )
		{
			return true;
		}
		$this->current = null;
		return false;
	}
654792
public function getNext()
    {
        if ($this->getPage() != $this->getLastPage()) {
            $next = $this->getPage() + 1;
        } else {
            $next = false;
        }

        return $next;
    }