{@inheritdoc}

@see \Concrete\Core\File\ImportProcessor\ProcessorInterface::shouldProcess()
358767
public function shouldProcess(Version $version)
    {
        $result = false;
        if (ExifMetadataReader::isSupported()) {
            if ($version->getTypeObject()->getName() == 'JPEG') {
                try {
                    $metadata = $version->hasImagineImage() ? $version->getImagineImage()->metadata() : null;
                    if ($metadata === null) {
                        $fr = $version->getFileResource();
                        $medatadaReader = new ExifMetadataReader();
                        $metadata = $medatadaReader->readData($fr->read());
                    }
                    switch ($metadata->get('ifd0.Orientation', null)) {
                        case 2: // top-right
                        case 3: // bottom-right
                        case 4: // bottom-left
                        case 5: // left-top
                        case 6: // right-top
                        case 7: // right-bottom
                        case 8: // left-bottom
                            $result = true;
                            break;
                    }
                } catch (Exception $x) {
                } catch (Throwable $x) {
                }
            }
        }

        return $result;
    }
437884
public function process(RequestInterface $request): bool
    {
        if (!$request->getMethod()->isPost()) {
            return false;
        }

        if ($this->checkOriginEnabled && !self::isValidOrigin($request)) {
            return false;
        }

        return $this->doProcess($request->getFormParameters(), $request->getUploadedFiles());
    }
1247971
protected function runForegroundProcess($container)
    {
        try {
            $container->call($this->callback, $this->parameters);
        } catch (Exception $e) {
            echo(' [Exception] '.$e->getMessage());
            $this->exitcode = 1;
            throw $e;
        }

        $this->exitcode = 0;
    }
1201916
protected function doExecute()
    {
        $env      = $this->getOption('env');
        $resolver = ConsoleHelper::getAllPackagesResolver($env, $this->console);
        $names    = $this->io->getArguments();

        if (!$names) {
            throw new \InvalidArgumentException('No package input.');
        }

        foreach ($names as $name) {
            $this->out()
                ->out('Start installing package: <info>' . $name . '</info>')
                ->out('---------------------------');

            $package = $resolver->getPackage($name);

            if (!$package) {
                $this->err('<comment>Package: ' . $name . ' not found.</comment>');

                continue;
            }

            $this->installConfig($package);
            $this->installRouting($package);
            $this->copyMigration($package);
            $this->copySeeders($package);
            $this->syncAssets($package);

            if (is_callable([$package, 'install'])) {
                $package->install($this);
            }
        }

        return true;
    }
1112343
public function should(
        callable $validator,
        string $error = 'unsatisfied predicate'
    ) : ValidatorAbstract {
        return $this->pipe(self::predicate($validator, $error));
    }
1133528
public function process()
    {
        if (!$this->_processed) {
            $this->_process();
            $this->_resolve();
        }
        $this->_processed = true;
        return $this->_passed !== false;
    }
1196458
private function checkDouble()
	{

		$type = new Type($this->payment->type, $this->payment->toArray());
		$payment = null;

		switch ($type->sid()) {

			case Type::PAY:

				$payment = self::findDoublePay(
					$this->payment->term,
					$this->payment->city,
					$this->payment->amount,
					$this->payment->to,
					Status::PROCESSED
				);

				break;

			case Type::CANCEL:

				$payment = self::findDoubleCancel(
					$this->payment->term,
					$this->payment->code,
					Status::PROCESSED
				);

				break;

		}

		if ($payment) {
			throw new ProcessorException(ProcessorException::RC_EXISTS_OPERATION);
		}


	}
1134468
protected function doExecute()
    {
        $paths = $this->getArgument(0);

        $paths = Arr::toArray($paths);

        if ($paths === []) {
            $p = $this->getOption('p');

            $dir = ConsoleHelper::getAllPackagesResolver()->getPackage($p)->getDir();

            $paths = [
                $dir . '/routing.yml',
                $dir . '/Resources/routing/**/*.yml'
            ];
        }

        $files = [];

        foreach ($paths as $path) {
            $files[] = \Windwalker\glob($path);
        }

        $files = array_merge(...$files);

        foreach ($files as $file) {
            $this->convert($file);
        }

        return true;
    }
1127373
public function canProcessRequest()
    {
        // Check the validity of the function name
        if(($this->sRequestedFunction) && !$this->validateFunction($this->sRequestedFunction))
        {
            $this->sRequestedFunction = null;
        }
        return ($this->sRequestedFunction != null);
    }
149212
protected boolean shouldProcessed(BlockPos pos)
	{
		if (toProcess.contains(pos) || processed.contains(pos))
			return false;

		return shouldProcess == null || shouldProcess.test(world, pos);
	}
738453
protected function runProcess(Process $process)
    {
        $output = $this->output;

        $process->run(
            function ($type, $buffer) use ($output) {
                $type;
                $output->write($buffer);
            }
        );

        return $process->isSuccessful();
    }
59407
public function add($process)
    {
        if (is_array($process)) {
            foreach ($process as $p) {
                $this->add($p);
            }
        } elseif (!$process instanceof ChainProcessInterface) {
            throw new \RuntimeException(sprintf(
                'Expect to be instance of ChainProcessInterface or array but got %s',
                get_class($process)
            ));
        } else {
            $this->processes[] = $process;
        }
    }
544674
private function shouldExecuteFile($execOption, $noExecOption, $filePath)
    {
        if ($execOption) {
            return true;
        }

        if ($noExecOption) {
            return false;
        }

        // By default, code that is edited is executed if there was no given input file path
        return $filePath === null;
    }
204206
public function process(InputInterface $input, OutputInterface $output, Config $config = null)
    {
        if (null === $config) {
            $config = new Config();
        }

        $this->load($config);

        return $this->processLoaded($input, $output, $config);
    }
610804
public function execute(Process $process, $name = null)
    {
        if (!is_null($name)) {
            $process->name($name);
        }
        if (!$process->isStarted()) {
            $process->start();
        }

        return array_push($this->processes, $process);
    }
610859
protected function tryAndProcessRules()
    {
        if (!empty($this->rules) && !is_array($this->rules)) {
            $this->phpci->logFailure('The "rules" option must be an array.');
            return false;
        }

        foreach ($this->rules as &$rule) {
            if (strpos($rule, '/') !== false) {
                $rule = $this->phpci->buildPath . $rule;
            }
        }

        return true;
    }
919199
def should_execute(self):
        """"""
        return self.args.apply and (self.args.no_confirm or self.confirm_execution())