Builds the processor that takes care
of generating the PHPixie HTTP Request
@return Processor
343179
protected function requestProcessor()
    {
        $components = $this->builder->components();

        $processors     = $components->processors();
        $httpProcessors = $components->httpProcessors();

        return $processors->chain(array(
            $httpProcessors->parseBody(),
            $this->parseRouteProcessor(),
            $httpProcessors->buildRequest()
        ));
    }
660191
protected function createProcessorIterator(ContextInterface $context)
    {
        $action = $context->getAction();
        $actionProcessors = [];
        $processors = $this->configProvider->getProcessors();
        if (!empty($processors[$action])) {
            $actionProcessors = $processors[$action];
        }

        return $this->processorIteratorFactory->createProcessorIterator(
            $actionProcessors,
            $context,
            $this->processorApplicableChecker,
            $this->processorFactory
        );
    }
285881
public function build()
    {
        $documentParser = $this->createDocumentParser();
        $stylesheetParser = new StylesheetParser();
        $stylesheetParser->setComplexAttributeFactory($this->configurationLoader->createComplexAttributeFactory());
        
        $engine = $this->engineFactory->createEngine($this->engineType, $this->engineOptions);

        $document = new Document($engine);
        $this->addStringFiltersTo($document);
        
        $facade = new Facade($this->configurationLoader, $document, $documentParser, $stylesheetParser);
        $this->addStringFiltersTo($facade);
        $facade->setEngineType($this->engineType);
        
        if($documentParser instanceof FacadeAware)
        {
            $documentParser->setFacade($facade);
        }
        
        $facade->setUseCacheForStylesheetConstraint($this->useCacheForStylesheetConstraint);

        if($this->cacheType && $this->cacheType !== 'Null')
        {
            $cache = new CacheImpl($this->cacheType, $this->cacheOptions);
            $facade->setCache($cache);
            
            if($this->useCacheForConfigurationLoader)
            {
                $this->configurationLoader->setCache($cache);
            }
        }

        return $facade;
    }
121899
public function build(): ResolveNodeRequest
	{
		$instance = new ResolveNodeRequest();
		$instance->nodeId = $this->nodeId;
		$instance->backendNodeId = $this->backendNodeId;
		$instance->objectGroup = $this->objectGroup;
		$instance->executionContextId = $this->executionContextId;
		return $instance;
	}
185899
public function build(): GetContentQuadsRequest
	{
		$instance = new GetContentQuadsRequest();
		$instance->nodeId = $this->nodeId;
		$instance->backendNodeId = $this->backendNodeId;
		$instance->objectId = $this->objectId;
		return $instance;
	}
420905
protected function contextProcessor()
    {
        $components = $this->builder->components();

        $processors     = $components->processors();
        $httpProcessors = $components->httpProcessors();
        $authProcessors = $components->authProcessors();

        $context = $this->builder->context();

        return $processors->chain(array(
            $httpProcessors->updateContext($context),
            $authProcessors->updateContext($context),
        ));
    }
238947
public function getPostprocessor(): MiddlewareInterface
    {
        if (is_null($this->postProcessor)) {
            if (method_exists($this, 'resolve')) {
                $this->setPostprocessor($this->resolve(Middleware::class));
            } else {
                $this->setPostprocessor(new Middleware());
            }
        }

        return $this->postProcessor;
    }
164585
protected function dispatchProcessor()
    {
        $processors          = $this->builder->components()->processors();
        $frameworkProcessors = $this->builder->processors();

        return $processors->chain(array(
            $this->builder->configuration()->httpProcessor(),
            $frameworkProcessors->httpNormalizeResponse(),
        ));
    }
522905
public function build(): ContinueInterceptedRequestRequest
	{
		$instance = new ContinueInterceptedRequestRequest();
		if ($this->interceptionId === null) {
			throw new BuilderException('Property [interceptionId] is required.');
		}
		$instance->interceptionId = $this->interceptionId;
		$instance->errorReason = $this->errorReason;
		$instance->rawResponse = $this->rawResponse;
		$instance->url = $this->url;
		$instance->method = $this->method;
		$instance->postData = $this->postData;
		$instance->headers = $this->headers;
		$instance->authChallengeResponse = $this->authChallengeResponse;
		return $instance;
	}
873309
public function build(): SetAsyncCallStackDepthRequest
	{
		$instance = new SetAsyncCallStackDepthRequest();
		if ($this->maxDepth === null) {
			throw new BuilderException('Property [maxDepth] is required.');
		}
		$instance->maxDepth = $this->maxDepth;
		return $instance;
	}
143576
public function build(): HighlightNodeRequest
	{
		$instance = new HighlightNodeRequest();
		if ($this->highlightConfig === null) {
			throw new BuilderException('Property [highlightConfig] is required.');
		}
		$instance->highlightConfig = $this->highlightConfig;
		$instance->nodeId = $this->nodeId;
		$instance->backendNodeId = $this->backendNodeId;
		$instance->objectId = $this->objectId;
		$instance->selector = $this->selector;
		return $instance;
	}
1103021
public function createProcedure()
    {
        $procedure = new Procedure(
            $this->engine,
            $this->parser,
            $this->cacheHandler,
            $this->renderer
        );

        return $procedure;
    }
617175
def _build_ftp_processor(cls, session: AppSession):
        ''''''
        ftp_client = session.factory['FTPClient']

        fetch_params = session.factory.new(
            'FTPProcessorFetchParams',
            remove_listing=session.args.remove_listing,
            retr_symlinks=session.args.retr_symlinks,
            preserve_permissions=session.args.preserve_permissions,
            glob=session.args.glob,
        )

        return session.factory.new(
            'FTPProcessor',
            ftp_client,
            fetch_params,
        )
422874
public function getProcess(): Process
    {
        if ($this->process === null) {
            $this->process = new Process(
                $this->getSchemaName(),
                $this->getInitialState(),
                $this->buildStates()
            );
        }

        return $this->process;
    }
370391
public function process()
    {
        if (isset($this->initialized['process'])) {
            return;
        }

        // Initialize Grav if needed.
        $this->setup();

        $this->initialized['process'] = true;

        $container = new Container(
            [
                'configurationProcessor' => function () {
                    return new ConfigurationProcessor($this);
                },
                'loggerProcessor' => function () {
                    return new LoggerProcessor($this);
                },
                'errorsProcessor' => function () {
                    return new ErrorsProcessor($this);
                },
                'debuggerProcessor' => function () {
                    return new DebuggerProcessor($this);
                },
                'initializeProcessor' => function () {
                    return new InitializeProcessor($this);
                },
                'backupsProcessor' => function () {
                    return new BackupsProcessor($this);
                },
                'pluginsProcessor' => function () {
                    return new PluginsProcessor($this);
                },
                'themesProcessor' => function () {
                    return new ThemesProcessor($this);
                },
                'schedulerProcessor' => function () {
                    return new SchedulerProcessor($this);
                },
                'requestProcessor' => function () {
                    return new RequestProcessor($this);
                },
                'tasksProcessor' => function () {
                    return new TasksProcessor($this);
                },
                'assetsProcessor' => function () {
                    return new AssetsProcessor($this);
                },
                'twigProcessor' => function () {
                    return new TwigProcessor($this);
                },
                'pagesProcessor' => function () {
                    return new PagesProcessor($this);
                },
                'debuggerAssetsProcessor' => function () {
                    return new DebuggerAssetsProcessor($this);
                },
                'renderProcessor' => function () {
                    return new RenderProcessor($this);
                },
            ]
        );

        $default = function (ServerRequestInterface $request) {
            return new Response(404);
        };

        /** @var Debugger $debugger */
        $debugger = $this['debugger'];

        $collection = new RequestHandler($this->middleware, $default, $container);

        $response = $collection->handle($this['request']);

        $this->header($response);
        echo $response->getBody();

        $debugger->render();

        register_shutdown_function([$this, 'shutdown']);
    }
135528
public function getProcessor()
    {
        if (is_null($this->processor)) {
            $processor = oxNew(\OxidEsales\PayPalModule\Model\IPNProcessor::class);
            $this->setProcessor($processor);
        }

        return $this->processor;
    }
420272
public function build(): SetCacheDisabledRequest
	{
		$instance = new SetCacheDisabledRequest();
		if ($this->cacheDisabled === null) {
			throw new BuilderException('Property [cacheDisabled] is required.');
		}
		$instance->cacheDisabled = $this->cacheDisabled;
		return $instance;
	}