called by the ExecuteStep Method - place any logic for the standard proccessing of this step here
return false if any errors occure (returns the user to the current step for corrections).

@return bool
18201
protected function ProcessStep()
    {
        $bContinue = parent::ProcessStep();
        if ($bContinue) {
            $aInput = TGlobal::instance()->GetUserData('aInput');
            if (!is_array($aInput)) {
                $aInput = array();
            }
            $sCardId = false;
            $sWrappId = false;
            $aArticleIds = false;
            if (array_key_exists('shop_wrapping_id', $aInput) && !empty($aInput['shop_wrapping_id'])) {
                $sWrappId = $aInput['shop_wrapping_id'];
            }
            if (array_key_exists('shop_wrapping_card_id', $aInput) && !empty($aInput['shop_wrapping_card_id'])) {
                $sCardId = $aInput['shop_wrapping_card_id'];
            }
            if (array_key_exists('shop_article_id', $aInput)) {
                if (is_array($aInput['shop_article_id'])) {
                    $aArticleIds = $aInput['shop_article_id'];
                } elseif (!empty($aInput['shop_article_id'])) {
                    $aArticleIds = array($aInput['shop_article_id']);
                }
            }

            $oBasket = TShopBasket::GetInstance();
            if ($sWrappId) {
                $oBasket->AddWrapping($sWrappId, $aArticleIds);
            }
            if ($sCardId) {
                $oBasket->AddWrappingCard($sCardId, $aArticleIds);
            }
        }
        if ($bContinue) {
            $sNextStep = TGlobal::instance()->GetUserData('nextStep');
            if (!empty($sNextStep)) {
                $oStep = TdbShopOrderStep::GetStep($sNextStep);
                $this->JumpToStep($oStep);
            }
        }

        return $bContinue;
    }
11766
public function execute() {
        if (!$this->built) {
            throw new base_task_exception('base_task_not_built', $this->name);
        }
        if ($this->executed) {
            throw new base_task_exception('base_task_already_executed', $this->name);
        }

        // Starts progress based on the weight of this task and number of steps.
        $progress = $this->get_progress();
        $progress->start_progress($this->get_name(), count($this->steps), $this->get_weight());
        $done = 0;

        // Execute all steps.
        foreach ($this->steps as $step) {
            $result = $step->execute();
            // If step returns array, it will be forwarded to plan
            // (TODO: shouldn't be array but proper result object)
            if (is_array($result) and !empty($result)) {
                $this->add_result($result);
            }
            $done++;
            $progress->progress($done);
        }
        // Mark as executed if any step has been executed
        if (!empty($this->steps)) {
            $this->executed = true;
        }

        // Finish progress for this task.
        $progress->end_progress();
    }
667785
public function validate()
    {
        $steps = [
            'PrivateKey',
            'IdpMetadata',
            'SpMetadata'
        ];

        foreach ($steps as $step) {
            $method = 'validate' . $step;
            if (!$this->$method()) {
                return false;
            }
        }

        return true;
    }
804127
public function runSteps()
    {
        $steps = $this->steps()->pullSteps();
        foreach ($steps as list($method, $arguments)) {
            $callable = is_callable($method) ? $method : [$this, $method];
            $arguments = (array) $arguments;

            $results = $callable(...$arguments);
            $results = $this->checkResults($results);
            if (!$results) {
                return false;
            }
        }

        return true;
    }
1048262
public function isAbsolutePathReference():bool{
		return $this->getScheme() === '' && $this->getAuthority() === '' && isset($this->getPath()[0]) && $this->getPath()[0] === '/';
	}
753943
function executeSteps( $steps )
    {
        $stepNum = 1;
        foreach( $steps as $step )
        {
            $this->execFunction( $step );

            if( $this->lastErrorCode() !== eZSiteInstaller::ERR_OK )
            {
                $res = $this->handleError();
                if( $res === false )
                    $res = $this->defaultErrorHandler();

                if( $res === eZSiteInstaller::ERR_ABORT )
                {
                    $this->reportError( "Aborting execution on step number $stepNum: '". $step['_function'] ."'", 'eZSiteInstaller::postInstall' );
                    break;
                }
            }

            ++$stepNum;
        }
    }
1047632
public function rollBackTransaction(): bool
	{
		if($this->transactionNestingLevel > 0)
		{
			if($this->transactionNestingLevel > 1)
			{
				$success = $this->rollBackSavepoint();
			}
			else
			{
				$success =  $this->pdo->rollBack();
			}

			$this->transactionNestingLevel--;

			return $success;
		}

		return false;
	}
760015
public function saveCurrent()
    {
        if ($this->saveEnabled() && $this->isViewValid() && $this->isViewUnique())
        {
            $success = $this->saveCurrentModel();

            // Keep on only if the model save has succeeded
            if ($success)
            {
                $this->storeCurrentHash();

                $this->saveTrackables(
                    $this->getCurrent(),
                    $success
                );
            }

            return $success;
        }

        return false;
    }
782510
public function init()
    {
        // If the step is not a registered step exit
        if (!in_array($this->step, CheckoutSteps::getSteps())) {
            $this->redirect($this->Link('/'));
        }

        // If no ReservationSession exists redirect back to the base event controller
        elseif (empty(ReservationSession::get())) {
            $this->redirect($this->Link('/'));
        }

        // If the reservation has been processed end the session and redirect
        elseif (ReservationSession::get()->Status === 'PAID' && $this->step != 'success') {
            ReservationSession::end();
            $this->redirect($this->Link('/'));
        } else {
            $this->reservation = ReservationSession::get();
            parent::init();
        }
    }
622985
public static function incrementStep()
    {
        if (self::isLastStep()) {
            return;
        }
        $next = self::classNameNumber() + 1;
        if ($next == 1) {
            $next++;
        }
        return self::setCurrentStep($next);
    }
561534
protected function performUpdate()
    {
        $params = $this->setKeysForSave();

        // If the updating event returns false, we will cancel the update operation so
        // developers can hook Validation systems into their models and cancel this
        // operation if the model does not pass validation. Otherwise, we update.
        if ($this->fireModelEvent('updating') === false) {
            return false;
        }

        // Send updates
        $results = $this->makeRequest($this->getEndpoint(), 'update', [
            $this->getKey(),
            $params
        ]);

        if ($results) {
            // Update model with new data
            $this->fill($results);

            $this->fireModelEvent('updated', false);
        }

        return true;
    }
1190846
public function setStep($step)
    {
        $this->step = (integer)$step;
        $this->hasStep = true;

        return $this;
    }
122279
public function getCurrentStep()
    {
        if ($this->_iCurrStep === null) {
            if (($this->_iCurrStep = $this->getInstance("Utilities")->getRequestVar("istep")) === null) {
                $this->_iCurrStep = $this->getStep('STEP_SYSTEMREQ');
            }
            $this->_iCurrStep = (int) $this->_iCurrStep;
        }

        return $this->_iCurrStep;
    }
250303
public static function isLastStep()
    {
        $n = self::classNameNumber();
        $n1 = $n + 1;
        $class = str_replace($n, $n1, get_called_class());
        return !class_exists($class);
    }
546788
protected function ProcessStep()
    {
        $bContinue = parent::ProcessStep();
        $oMsgManager = TCMSMessageManager::GetInstance();

        // we may continue only if a shipping group and payment method is set
        if ($bContinue && is_null($this->oActiveShippingGroup)) {
            $oMsgManager->AddMessage(self::MSG_SHIPPING_GROUP, 'ERROR-BASKET-NO-SHIPPING-GROUP');
            $bContinue = false;
        }
        if ($bContinue && is_null($this->oActivePaymentMethod)) {
            $oMsgManager->AddMessage(self::MSG_PAYMENT_METHOD, 'ERROR-BASKET-NO-PAYMENT-METHOD');
            $bContinue = false;
        }

        $oPaymentHandler = null;
        if ($bContinue) {
            // check payment method data
            $oPaymentHandler = &$this->oActivePaymentMethod->GetFieldShopPaymentHandler();
            $bContinue = $oPaymentHandler->ValidateUserInput();
        }

        if ($bContinue) {
            // set payment method and shipping group in basket
            $oBasket = TShopBasket::GetInstance();
            $oBasket->SetActiveShippingGroup($this->oActiveShippingGroup);
            $oBasket->SetActivePaymentMethod($this->oActivePaymentMethod);
            $oBasket->RecalculateBasket();
            $bContinue = $this->postSelectPaymentHook();

            // if things fail here, we need to redirect to the active step to clear our parameter list - and refresh the payment list
            if (false === $bContinue) {
                $this->JumpToStep($this);
            }
        }

        return $bContinue;
    }
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;
    }
428202
public function addStep(Step $step)
    {
        if (!$this->steps->contains($step)) {
            $this->steps->add($step);
        }

        return $this;
    }