Execute the next stage in the cycle.
432965
@Override
    public void executeNext()
    {
        final LifecycleStage nextStage = getNextStage();
        if (nextStage == null) {
            throw new IllegalStateException("Lifecycle already hit the final stage!");
        }
        execute(nextStage);
    }
102439
def step_into(self):
        
        logger.debug("Execution step into ...")
        self.run_to_states = []
        if self.finished_or_stopped():
            self.set_execution_mode(StateMachineExecutionStatus.FORWARD_INTO)
            self._run_active_state_machine()
        else:
            self.set_execution_mode(StateMachineExecutionStatus.FORWARD_INTO)
1147461
def step(self):
        
        assert len(self._agents_to_act) == 0
        self.next()
        while len(self._agents_to_act) > 0:
            self.next()
214622
public void executeWithDelay() {
        long now = Clock.currentTimeMillis();
        if (delay + now > hardLimit) {
            scheduleNewExecution(now);
        } else if (!tryPostponeExecution()) {
            scheduleNewExecution(now);
        }
    }
242815
def run(self): # No "_" in the name, but nevertheless, running in the backed
        
        self.preRun_()
        self.running=True
        
        while(self.running):
            self.cycle_()
            self.handleSignal_()
        
        self.postRun_()
675575
def run(self):
        
        for task in self.get_next_tasks(None):
            self.executor.add_task(task, None)
        while not self.executor.is_done():
            done_task_and_result = self.executor.wait_for_tasks()
            for task, task_result in done_task_and_result:
                self._add_sub_tasks_to_executor(task, task_result)
911182
function nextStep()
    {
        if ( $this->metaData( 'current_stage' ) == eZWizardBase::STAGE_PRE )
        {
            $this->setMetaData( 'current_stage', eZWizardBase::STAGE_POST );
        }
        else
        {
            $this->setMetaData( 'current_stage', eZWizardBase::STAGE_PRE );
            $this->setMetaData( 'current_step', $this->metaData( 'current_step' ) + 1 );

            return $this->Module->redirectTo( $this->WizardURL );
        }

        $this->savePersistentData();
    }
11828
def _run(self):
        ''''''
      
        while self._is_running:
            yield from self._task()

        # Signal that the loop has finished.
        self._run_complete.set_result(True)
133121
public function next()
    {
        if ($this->x + 1 < $this->width) {
            $this->x++;
        } else {
            $this->x = 0;
            $this->y++;
        }

        $this->index++;
    }
1008497
def execute(cls, stage, state, data, next_allowed_exec_time=None):
        """"""
        try:
            context = Context.from_state(state, stage)
            now = datetime.utcnow()
            if next_allowed_exec_time and now < next_allowed_exec_time:
                # task not allowed to run yet; put it back in the queue
                Queue.queue(stage, state, data, delay=next_allowed_exec_time)
            elif context.crawler.disabled:
                pass
            elif context.stage.rate_limit:
                try:
                    with rate_limiter(context):
                        context.execute(data)
                except RateLimitException:
                    delay = max(1, 1.0/context.stage.rate_limit)
                    delay = random.randint(1, int(delay))
                    context.log.info(
                        "Rate limit exceeded, delaying %d sec.", delay
                    )
                    Queue.queue(stage, state, data, delay=delay)
            else:
                context.execute(data)
        except Exception:
            log.exception("Task failed to execute:")
        finally:
            # Decrease the pending task count after excuting a task.
            Queue.decr_pending(context.crawler)
            # If we don't have anymore tasks to execute, time to clean up.
            if not context.crawler.is_running:
                context.crawler.aggregate(context)
1082895
def call_next(self):
        """"""
        if self.handle is not None:
            self.handle.cancel()
        next_time = self.get_next()
        self.handle = self.loop.call_at(next_time, self.call_next)
        self.call_func()
159161
public void nextStep() {
        if (currentStepIndex >= getWidgetCount() - 1) {
            CompleteEvent.fire(MaterialStepper.this, currentStepIndex + 1);
        } else {
            Widget w = getWidget(currentStepIndex);
            if (w instanceof MaterialStep) {
                MaterialStep step = (MaterialStep) w;
                step.setActive(false);

                step.setSuccessText(step.getDescription());

                // next step
                int nextStepIndex = getWidgetIndex(step) + 1;
                if (nextStepIndex >= 0) {
                    for (int i = nextStepIndex; i < getWidgetCount(); i++) {
                        w = getWidget(i);
                        if (!(w instanceof MaterialStep)) {
                            continue;
                        }
                        MaterialStep nextStep = (MaterialStep) w;
                        if (nextStep.isEnabled() && nextStep.isVisible()) {
                            nextStep.setActive(true);
                            setCurrentStepIndex(i);
                            NextEvent.fire(MaterialStepper.this);
                            break;
                        }
                    }
                }
            }
        }
    }
969082
def start(self, phase, stage, **kwargs):
        """"""
        return ProgressSection(self, self._session, phase, stage, self._logger, **kwargs)
475855
def _decrement_stage(self):
        

        try:

            if self._cur_stage > 0:
                self._cur_stage -= 1
                self._completed_flag = threading.Event()  # reset

        except Exception, ex:
            raise EnTKError(text=ex)
659132
private void doStep(boolean forward) {

        // increment or decrement sequence
        if(forward)
            sequenceIndex++;
        else
            sequenceIndex--;

        // check sequence bounds; rollover if needed
        if(sequenceIndex >= stepSequence.length)
            sequenceIndex = 0;
        else if(sequenceIndex < 0)
            sequenceIndex = (stepSequence.length - 1);

        // start cycling GPIO pins to move the motor forward or reverse
        for(int pinIndex = 0; pinIndex < pins.length; pinIndex++) {
            // apply step sequence
            double nib = Math.pow(2, pinIndex);
            if((stepSequence[sequenceIndex] & (int)nib) > 0)
                pins[pinIndex].setState(onState);
            else
                pins[pinIndex].setState(offState);
        }
        try {
            Thread.sleep(stepIntervalMilliseconds, stepIntervalNanoseconds);
        }
        catch (InterruptedException e) {}
    }
582676
@Override
    public void executeTo(@Nonnull final LifecycleStage lifecycleStage)
    {
        boolean foundStage = false;
        do {
            final LifecycleStage nextStage = lifecycleDriver.getNextStage();

            if (nextStage == null) {
                throw new IllegalStateException("Never reached stage '" + lifecycleStage.getName() + "' before ending the lifecycle.");
            }

            foundStage = nextStage.equals(lifecycleStage);
            execute(nextStage);

        } while(!foundStage);
    }
168195
def _execute_stage(self, index, stage, stop):
        
        if stop.is_set():
            _LOGGER.info("Stopped pipeline on group %s", self._group)
            return
        _LOGGER.info(" -> Running stage '%s' on group %s", stage, self._group)
        if stage.name == 'on':
            self._group.on = True
        elif stage.name == 'off':
            self._group.on = False
        elif stage.name == 'hue':
            self._group.hue = stage.args[0]
        elif stage.name == 'saturation':
            self._group.saturation = stage.args[0]
        elif stage.name == 'color':
            self._group.color = Color(*stage.args)
        elif stage.name == 'brightness':
            self._group.brightness = stage.args[0]
        elif stage.name == 'temperature':
            self._group.temperature = stage.args[0]
        elif stage.name == 'transition':
            self._group.transition(*stage.args, **stage.kwargs)
        elif stage.name == 'white':
            self._group.white()
        elif stage.name == 'white_up':
            self._group.white_up()
        elif stage.name == 'white_down':
            self._group.white_down()
        elif stage.name == 'red_up':
            self._group.red_up()
        elif stage.name == 'red_down':
            self._group.red_down()
        elif stage.name == 'green_up':
            self._group.green_up()
        elif stage.name == 'green_down':
            self._group.green_down()
        elif stage.name == 'blue_up':
            self._group.blue_up()
        elif stage.name == 'blue_down':
            self._group.blue_down()
        elif stage.name == 'night_light':
            self._group.night_light()
        elif stage.name == 'flash':
            self._group.flash(**stage.kwargs)
        elif stage.name == 'repeat':
            self._repeat(index, stage, stop)
        elif stage.name == 'wait':
            time.sleep(*stage.args)
        elif stage.name == 'callback':
            stage.args[0](*stage.args[1:], **stage.kwargs)