Continues the iteration when appropriate -- that is, if we (a) have
more items and (b) don't run over our 'end' (given our 'step').
192953
@Override
    public int doAfterBody() throws JspException {

        // re-sync the index, given our prior behind-the-scenes 'step'
        index += step - 1;

        // increment the count by 1 for each round
        count++;

        // everything's been prepared for us, so just get the next item
        if (hasNext() && !atEnd()) {
            index++;
            item = next();
        } else {
            return SKIP_BODY;
        }

        /*
         * now discard anything we have to "step" over.
         * (we do this in advance to support LoopTagStatus.isLast())
         */
        discard(step - 1);

        // prepare to re-iterate...
        exposeVariables();
        calibrateLast();
        return EVAL_BODY_AGAIN;
    }
836330
public function next()
    {
        if (!$this->stack->isEmpty()) {
            $this->stack->last()->next();
            $this->discardInvalid();
        }
    }
1105995
function(n){

    	if(!_.isNumber(n)){
            return;
	    }

        // Avoid stepping over
        if(this._data[this._itr + n] === undefined){
            return;
        }

        // Advance num steps
        this._itr += n;
    }
435447
def steps(self, goal):
        

        path = self.path(goal)
        for i in range(len(path) - 1):
            yield path[i], path[i + 1]
561093
def continues(method):
        '''
        '''
        @functools.wraps(method)
        def wrapped(self, *args, **kwargs):
            yield method(self, *args, **kwargs)
            raise self.Continue()
        return wrapped
1189083
function next() {
        // Exit if all iterators are traversed.
        if (empties.size === count) {
            return done;
        }

        // Go to the next iterator.
        const iter = step();

        const res = iter.next();

        // Mark iterator as empty and go to the next.
        if (res.done) {
            empties.add(index);

            return next();
        }

        return res;
    }
709615
public static boolean step( IterativeOptimization search ) {
		for( int i = 0; i < 10000; i++ ) {
			boolean converged = search.iterate();
			if( converged || !search.isUpdated() ) {
				return converged;
			}
		}
		throw new RuntimeException("After 10,000 iterations it failed to take a step! Probably a bug.");
	}
289563
def finish(self, data=''):
        '''
        
        '''
        self.pending += data
        self.streaming = False
        for i in self:
            yield i
1363711
def step(self, exploration):
        
        if len(self._runners) > 1:
            self._populate_job_queue.put(exploration)
        else:
            self._runners[0].step(exploration)
1204296
def on_batch_end(self, iteration:int, smooth_loss:TensorOrNumber, **kwargs:Any)->None:
        ""
        if iteration==0 or smooth_loss < self.best_loss: self.best_loss = smooth_loss
        self.opt.lr = self.sched.step()
        if self.sched.is_done or (self.stop_div and (smooth_loss > 4*self.best_loss or torch.isnan(smooth_loss))):
            #We use the smoothed loss to decide on the stopping since it's less shaky.
            return {'stop_epoch': True, 'stop_training': True}
234127
def goForward(self):
        
        if self._slideshow.currentIndex() == self._slideshow.count() - 1:
            self.finished.emit()
        else:
            self._slideshow.slideInNext()
1098412
function step (err, val) {
    if (iter) {
      // generator step
      yielded = false
      isYieldable = false
      var state
      if (trycatch) {
        try {
          if (nothrow) state = iter.next(slice.call(arguments))
          else state = err ? iter.throw(err) : iter.next(val)
        } catch (err) {
          iter = null // catch err, break iteration
          return step(err)
        }
      } else {
        if (nothrow) state = iter.next(slice.call(arguments))
        else state = err ? iter.throw(err) : iter.next(val)
      }
      if (state && state.done) iter = null
      yielded = true
      isYieldable = yieldable.call(self, state.value, step, opts)
      if (!isYieldable && opts.yieldable) {
        isYieldable = opts.yieldable.call(self, state.value, step)
      }
      // next if generator returned non-yieldable
      if (!isYieldable && !iter) next(null, state.value)
    } else if (callback) {
      callback.apply(self, arguments)
      callback = null
    }
  }
1135858
private void ensureNext() {
        // Check if the current scan result has more keys (i.e. the index did not reach the end of the result list)
        if (resultIndex < scanResult.getResult().size()) {
            return;
        }
        // Since the current scan result was fully iterated,
        // if there is another cursor scan it and ensure next key (recursively)
        if (!FIRST_CURSOR.equals(scanResult.getStringCursor())) {
            scanResult = scan(scanResult.getStringCursor(), scanParams);
            resultIndex = 0;
            ensureNext();
        }
    }
354317
def _write_continue(self, value):
        
        self._FITS.write_continue(self._ext+1, str(value))
686143
def _is_in_keep_going(self, x, y):
        """"""
        x1, y1, x2, y2 = self._keep_going
        return self.won == 1 and x1 <= x < x2 and y1 <= y < y2
395037
private boolean continueProcessing() {
        Boolean currentValue = _continueProcessing.get();
        if (currentValue != null)
            return currentValue.booleanValue();

        return true;
    }
1281568
def ShouldRetry(self, exception):
        
        if (self.current_retry_attempt_count < self._max_retry_attempt_count) and self.needsRetry(exception.status_code):
            self.current_retry_attempt_count += 1
            return True
        return False