Executes the current step. Redirects to the next step in line if no errors occur.
502164
public function ExecuteStep()
    {
        if ($this->ProcessStep()) {
            $this->ProcessStepSuccessHook();
            $oBasket = TShopBasket::GetInstance();
            $oBasket->aCompletedOrderStepList[$this->fieldSystemname] = true;
            $oNextStep = $this->GetNextStep();
            $this->JumpToStep($oNextStep);
        }
    }
440409
private void doProcessNext()
	{
		int _position = getPosition();
		Node _current = getSource().item(_position);

		if (getActionPool().containsKey(_current.getNodeName()))
		{
			getActionPool().get(_current.getNodeName()).execute(_current, _position);
		}
		else if (getActionPool().containsKey(NODE_NAME__DEFAULT))
		{
			getActionPool().get(NODE_NAME__DEFAULT).execute(_current, _position);
		}
		// else do nothing...

		// done
		_position++;
		setPosition(_position);
	}
522948
@Override
    public void process(Step step) {
        Status status = throwable instanceof AssertionError ? Status.FAILED : Status.BROKEN;
        step.setStatus(status);
    }
515588
public function execute()
    {
        if (!count($this->stack)) {
            foreach ($this->listeners as $cb) {
                $cb($this->pool);
            }
            return;
        }

        $params = $this->getParams();
        $params[] = function ($redis) {
            foreach ($this->listeners as $cb) {
                $cb($redis);
            }
        };
        $this->pool->eval(...$params);
    }
234444
def execute(self):
        
        if self.args and self.argument(0) == "help":
            self.error(self.usage() + "\n\n" + self.help())
            return False

        return True
1256194
public function execute()
    {
        $queue = P\queue();

        while ($this->handles || !$queue->isEmpty()) {
            // If there are no transfers, then sleep for the next delay
            if (!$this->active && $this->delays) {
                usleep($this->timeToNext());
            }
            $this->tick();
        }
    }
397638
async def _step(self):
        
        while not self._done() and not self.is_killed():
            try:
                await self._run()
                await asyncio.sleep(0)  # relinquish cpu
            except Exception as e:
                logger.error("Exception running behaviour {}: {}".format(self, e))
                self.kill(exit_code=e)
        try:
            await self.on_end()
        except Exception as e:
            logger.error("Exception running on_end in behaviour {}: {}".format(self, e))
            self.kill(exit_code=e)
406961
def run_step0(self):
        
        dae = self.system.dae
        system = self.system

        self.inc = zeros(dae.m + dae.n, 1)
        system.varout.store(self.t, self.step)

        self.streaming_step()
1278733
protected function performStep()
    {
        if ( ! $this->modelHasTrait($this->getListifyTraits())) {
            return;
        }

        /** @var Listify $model */
        $model = $this->model();

        $this->info->list->orderable      = true;
        $this->info->list->order_strategy = 'listify';
        $this->info->list->order_column   = $model->positionColumn();


        // Determine whether an (interpretable) scope is configured
        if ( ! method_exists($model, 'getScopeName')) {
            // @codeCoverageIgnoreStart
            return;
            // @codeCoverageIgnoreEnd
        }
        $scope = $model->getScopeName();

        if ($scope instanceof Relation) {
            // Attempt to resolve the relation method name from the relation instance
            $this->info->list->order_scope_relation = $this->getRelationNameFromRelationInstance($scope);
        }
    }
170940
public void run() {
		try {
			Object result = execute();
			if (!aborted) {
				this.retval = result;
				finished = true;
			}
		}
		catch (InterruptedException ie) {
			//
		}
		catch (Throwable t) {
			execException = t;
			finished = true;
		}
	}
362729
public function advance($step = 1, $redraw = false)
    {
        parent::advance($step, $redraw);

        $this->current += $step;

        $percent = 0;
        if ($this->max > 0) {
            $percent = (float) $this->current / $this->max;
        }
        $this->output->write(sprintf('%d%%', floor($percent * 100)));
    }
425949
def run_step(self):
        
        if not hasattr(self, 'train_op'):
            raise NotImplementedError(
                "Please either set `Trainer.train_op` or provide an implementation "
                "of Trainer.run_step()!")
        self.hooked_sess.run(self.train_op)
838208
final public function proceed()
    {
        if (isset($this->advices[$this->current])) {
            $currentInterceptor = $this->advices[$this->current++];

            $currentInterceptor->invoke($this);
        }
    }
472910
public void execute() {
        State currentState = state.getAndSet(State.RUNNING);
        if (currentState == State.RUNNING) {
            throw new IllegalStateException(
                    "ExecutionChain is already running!");
        }
        executeRunnable = new ExecuteRunnable();
    }
1135639
def do_step(self, args):
        
        self._do_print_from_last_cmd = True
        self._interp.step_into()
        return True
1060440
def execute(self, *args, **kwargs):
        
        self.walk(*args, **kwargs)

        failed_steps = [step for step in self.steps if step.status == FAILED]
        if failed_steps:
            raise PlanFailed(failed_steps)
730848
public void execute() {
    Entry head;
    synchronized(this) {
      head = this.head;
      this.head = null;
    }
    while (head != null) {
      try {
        head.runnable.run();
      } catch (Throwable t) {
        platform.reportError("Failure executing runnable: " + head.runnable, t);
      }
      head = head.next;
    }
  }