@param string $type
@param array $input

@return Processor
351849
public static function make($type, $input)
	{
		$opType = new Type($type, $input);
		return App::make(
			'FintechFab\BankEmulator\Components\Processor\Processor',
			array($opType)
		);
	}
880387
public static function input(string $type)
    {
        $self = self::$input[$type] ?? new self;

        self::$input[$type] = $self;

        switch (strtoupper($type)) {
            case 'GET':
            case 'POST':
                $self->params = filter_input_array(constant('INPUT_' . $type)) ?? [];
                break;
            case 'PUT':
            case 'DELETE':
                $self->params = self::getParsedInput();
                break;
        }

        return function ($key = null) use ($self) {
            $self->key = $key;

            return $self;
        };
    }
73270
public static function typed(string $type, iterable $input = []): Set
    {
        $resolver = Resolver::typed($type);

        return new static($input, $resolver);
    }
611935
public function activate(Processor $processor, $type, $id)
    {
        return $processor->activate($this, $type, $id);
    }
796964
public function validate(array $input = []): ValidationResult
    {
        $results = [];

        foreach ($this->rules as $key => $definition) {

            $rules = $this->parser->parseRulesDefinition($definition);

            $results[$key] = $rules->validate($key, $input);

        }

        return new ValidationResult($results, $this->translator);
    }
900825
protected function parseType(array $input)
    {
        /** @var string $type */
        /** @var string[] $types */
        extract($input);
        switch ($type) {
            case 'array':
                if (!is_array($this->{$key}))
                    return false;
                break;
            case 'int':
            case 'integer':
                if (!is_int($this->{$key}))
                    return false;
                break;
            case 'or':
                $valid = false;
                foreach ($types as $_type) {
                    if (gettype($this->{$key}) == $_type) {
                        $valid = true;
                        break;
                    }
                }
                if (!$valid) return false;
                break;
            default:
                //throw new Exception('Incorrect rule');
                return null;
        }
        return true;
    }
986867
public function process(array $input)
    {
        if (!empty($input['q'])) {
            $this->searchQuery = $input['q'];
        }
        if (!empty($input['sort'])) {
            foreach (explode(',', $input['sort']) as $sort) {
                $this->processOrderByParams($sort);
            }
        }
        $input = $this->processPageParams($input);
        foreach ($input as $key => $param) {
            if (!in_array($key, ['sort', 'page', 'per_page', 'q'], true)) {
                $this->processFilterParams($key, $param);
            }
        }
        return $this;
    }
189773
public function setType($type): Input
    {
        $types = [
            'button',
            'checkbox',
            'color',
            'date',
            'datetime',
            'datetime-local',
            'email',
            'file',
            'hidden',
            'image',
            'month',
            'number',
            'password',
            'radio',
            'range',
            'reset',
            'search',
            'submit',
            'tel',
            'text',
            'time',
            'url',
            'week '
        ];

        if (!in_array($type, $types)) {
            Throw new FormException('Your type "' . $type . '" is no valid input control type. Allowed are ' . implode(', ', $types));
        }

        $this->type = $type;
        $this->attribute['type'] = $type;
        $this->data['control'] = $type == 'hidden' ? 'hidden' : 'input';

        return $this;
    }
65563
public function input($type, $name, $value = null)
    {
        $value = $this->inputs ? $this->inputs->get($name, $value) : $value;
        $form  = (new Input($type, $name))->value($value);
        return $this->setClass($form);
    }
400772
protected function getInputType($input)
    {
        // Get the formal type
        $type = gettype($input);

        // Check if it's numeric
        if ($type == 'integer' || $type == 'float' || $type == 'double')
            $type = 'numeric';

        // If it's something we don't check, null it
        if ($type == 'NULL' || $type == 'object' || $type == 'resource' || $type == 'undefined type')
            $type = null;

        // Check if it's an file array
        if ($type == 'array' && isset($input['type']) && $input['tmp_name'])
            $type = 'file';

        return $type;
    }
937215
protected function getOptions(InputInterface $input)
    {
        $options = $this->extras + [
            'queue' => $input->getArgument('queue'),
            'connection' => $input->getArgument('connection'),
            'poll_interval' => (int) $input->getOption('poll-interval'),
        ];

        /** @var ProcessorConfiguratorInterface $processorConfigurator */
        foreach ($this->processorConfigurators as $processorConfigurator) {
            $processorOptions = $processorConfigurator->resolveOptions($input);

            if ($processorConfigurator->isEnabled()) {
                $options += $processorOptions;
            }
        }

        return $options;
    }
376812
public static function getCreateOperation($input, $fields) {
		$operation = new CreateTransactionOperation(static::getClass(), $input, $fields);
		$operation->setSQLAdapter(static::getSQLAdapter());
		return $operation;
	}
1295525
public function spitOutHtmlForModelInputToConsume($type, $input)
    {
        if ($type === 'select') {
            return $this->select([
                'default_text' => 'Please select a '.trim($input, '_id'),
                'type'         => $type,
                'name'         => $input,
            ], [
                false => 'No',
                true  => 'Yes',
            ]);
        } elseif (in_array($type, ['text', 'file', 'password', 'email', 'date', 'number'])) {
            return $this->input([
                'type'  => $type,
                'name'  => $input,
                'class' => 'form-control',
                'id'    => $this->genId($input),
                'value' => !method_exists($this->model, $input) && in_array($input, $this->model->getFillable())? $this->model->$input:  ''
            ]);
        }

        return $this->textarea(['type' => $type, 'name' => $input, 'id' => $this->genId($input)],
            (!empty($this->model->$input) && !(stripos($input,
                        'password') !== false)) ? $this->model->$input : '');
    }
1140730
public static function fromString(string $input): StreamInterface
    {
        /** @var resource $stream */
        $stream = \fopen('php://temp', 'w+');
        if (!\is_resource($stream)) {
            throw new \Error('Could not create stream');
        }
        \fwrite($stream, $input);
        \rewind($stream);
        return new static($stream);
    }
98031
public function addLogProcessor($type)
    {
        switch ($type) {
            case 'web':
                $this->pushProcessor(new WebProcessor());
                break;

            case 'intro':
            case 'introspection':
                $this->pushProcessor(new IntrospectionProcessor());
                break;

            default:
                throw new \Exception('Unknown Log Processor', 1);
                break;
        }
    }
406218
protected function resolve(Input $input): Input
    {
        $this->call($input->value());
        $input->ignore();

        return $input;
    }
1278455
public function custom(IType $inputType, array $processors = []) : FieldBuilderBase
    {
        return $this->field->custom($inputType, $processors);
    }