process

@return ProcessorTrait

@access public
423745
public function process()
    {
        if ($this->isProcessed()) {
            throw new MultiProcessException('Already Processed!');
        }

        if ($this->doProcess()) {
            $this->setProcessed(true);
        }

        return $this;
    }
405569
public function process()
    {
        // Migrate init - to create migration table
        $type = $this->argument('type');

        $migration = Migrator::instance($this);
        $migration->getLatestMigration()
                  ->setMigrationClassName();

        if ($type == '' || $type == 'up') {
            $migration->updateMigration();
        } else {
            $migration->updateMigration('down');
        }

        $this->info('Migration Completed Successfully!');
    }
951008
protected function process()
    {
        $output = "";
        $offset = 0;
        $this->shell->_initShell();
        while( true ) {
            $temp = $this->shell->_get_channel_packet(SSH2::CHANNEL_EXEC);
            switch( true ) {
                case $temp === true:
                case $temp === false:
                    return $output;
                default:
                    $output .= $temp;
                    if( $this->handle_data(substr($output, $offset)) ) {
                        $offset = strlen($output);
                    }
            }
        }
    }
310133
public function process() {
        /* @var $currentStep StepController */
        /* @var $ancestorStep StepController */
        /* @var $descendantStep StepController */
        $currentStep = $this->stepCollectionIterator->current();
        if ($this->stepAction == self::WIZARD_STEP_ACTION_PREV && !$this->stepCollection->isFirst($this->stepCollectionIterator->current())) {
            $currentStep->leaveToAncestorStep();
            $this->stepCollectionIterator->previous();
            $ancestorStep = $this->stepCollectionIterator->current();
            $ancestorStep->enterFromDescendant();
            $this->resultContent = $this->prepareNextStepView($ancestorStep);
        } elseif ($this->stepAction == self::WIZARD_STEP_ACTION_PREV && $this->stepCollection->isFirst($this->stepCollectionIterator->current())) {
            $this->resultContent = new ResponseConfigurator();
        }
        if ($this->stepAction == self::WIZARD_STEP_ACTION_NEXT) {
            $currentStep->preProcess();
            if ($currentStep->process($currentStep->standardClosureArguments())) {
                $currentStep->postProcess();
                $currentStep->leaveStep();
                $this->stepCollectionIterator->next();

                $descendantStep = $this->stepCollectionIterator->current();
                $descendantStep->enterStep();
                $this->resultContent = $this->prepareNextStepView($descendantStep);
            } else {
                $this->resultContent = $this->prepareNextStepView($currentStep);
                $this->resultContent->setVariable("errorMessage", $currentStep->getProcessErrorMessage());
            }

        }
    }
198940
public function processRequest()
    {
        $this->signal->send($this, 'onProcessRequest');

        if (Console::isCli()) {
            $exitCode = $this->_runner->run($_SERVER['argv']);
            if (is_int($exitCode)) {
                $this->end($exitCode);
            }
        } else {
            $this->runController($this->parseRoute());
        }
    }
422874
public function getProcess(): Process
    {
        if ($this->process === null) {
            $this->process = new Process(
                $this->getSchemaName(),
                $this->getInitialState(),
                $this->buildStates()
            );
        }

        return $this->process;
    }
1224062
public function getProcess(): Process
    {
        if (count($this->prefix) === 0 && count($this->arguments) === 0) {
            throw new MethodCallException('You must add arguments before calling getProcess()');
        }

        $arguments = array_merge($this->prefix, $this->arguments);
        $command = implode(' ', array_map('escapeshellarg', $arguments));

        if ($this->inheritEnv) {
            $env = array_replace($_SERVER, $this->environment);
        } else {
            $env = $this->environment;
        }

        $process = new Process(
            $command,
            $this->directory,
            $env,
            $this->input,
            $this->timeout,
            $this->stdout,
            $this->stderr
        );

        if ($this->outputDisabled) {
            $process->disableOutput();
        }

        return $process;
    }
1166875
public function process ()
    {
        if ($this->isProcessed)
            return;
        $this->isProcessed = true;
        foreach ($this->getFields() as $field)
            /* @var $field Field */
            $field->preprocess();
        $this->isUserSubmitted = $this->getValue($this->getSubmitConfirmFieldName(), 'false') == 'true' || $this->forceSubmit;
        if ($this->isUserSubmitted) {
            foreach ($this->getFields() as $field)
                $field->restoreValue($this->method);

            $this->activateHandlers();

            if ($this->isValid()) {
                $this->submit();
            }
        }
    }
798000
public function process()
    {
        $ret = call_user_func(
            $this->getConfig('callback'),
            $this->getQuery(),
            $this->getArgs(),
            $this
        );
        if ($ret === null) {
            return true;
        }

        return $ret;
    }
300090
public function process()
    {
        $rule = $this->getComponent();
        $context = $this->getContext();

        $processor = $this->getRuleProcessorFactory()->createProcessor($rule);
        $processor->setState($context);
        $processor->process();

        $this->trace($rule->getQtiClassName());
    }
429139
public function doProcess()
	{

		// card errors
		$rc = $this->doProcessCards();
		if ($rc !== '00') {
			$this->payment->rc = $rc;
			$this->payment->rrn = '';
			$this->payment->irn = '';
			$this->payment->status = Status::ERROR;
			$this->payment->save();

			return;
		}

		// process type errors
		$rc = $this->doProcessType();
		if ($rc !== '00') {
			$this->payment->rc = $rc;
			$this->payment->status = Status::ERROR;
			$this->payment->save();

			return;
		}

		// auth
		$this->doDetectAuth();

		// approved
		if($this->payment->status != Status::AUTHORIZATION){
			$this->payment->status = Status::SUCCESS;
		}
		$this->payment->rc = '00';
		$this->payment->approval = mt_rand(100000, 999999);
		$this->payment->save();

	}
1321306
public function process()
    {
        synapse()->brain->topic()->triggers()->each(function ($data, $trigger) {
            $this->searchTriggers($trigger);

            if ($this->output !== 'Error: Response could not be determined.') {
                return false;
            }
        });

        return $this->output;
    }
625562
private static function proccess()
    {
        $files = ['Process', 'Command', 'Translator', 'Migrations', 'Links', 'Tag', 'Model', 'View', 'Controller', 'Seeds', 'Router', 'Exception', 'Events', 'Alias', 'Middleware', 'Helper', 'Tests', 'Mail', 'Query'];
        $folder = static::$root.'Processes'.'/';

        self::call($files, $folder);

        $files = ['TranslatorFolderNeededException', 'TranslatorManyFolderException'];
        $folder = static::$root.'Processes/Exceptions'.'/';

        self::call($files, $folder);
    }
613356
public function run()
    {
        $error = $this->error;
        $output = $this->output;

        return $this->builder->getProcess()->run(
            function ($type, $buffer) use ($error, $output) {
                if ('err' === $type) {
                    if ($error) {
                        $error($buffer);
                    }
                } elseif ($output) {
                    $output($buffer);
                }
            }
        );
    }
1125735
public function getProcess()
    {
        switch ($this->type) {
            case 'github':
            case 'github-https':
            case 'bitbucket':
                if ($this->tree) {
                    $process = $this->installViaSubtree();
                }

                $process = $this->installViaGit();
                break;

            default:
                $process = $this->installViaComposer();
                break;
        }

        return $process;
    }
586315
protected function process()
    {
        $this->result = $this[self::RESPONSE_PROCESSING] != self::TYPE_RAW
            ? DefaultResponseParser::getInstance()->parse($this)
            : $this->request->getResponse();
    }
718804
protected function _processResponse()
    {
        $this->_factory
            ->getNewCancelProcessResponse($this->_response, $this->_order)
            ->process();
        return $this;
    }