@param Filter $filter
@param Argument[] $arguments

@return \League\CLImate\Argument\Parser
977438
public function setFilter($filter, $arguments)
    {
        $this->filter = $filter;
        $this->filter->setArguments($arguments);

        return $this;
    }
544650
public function filterPrefix(array $arguments)
    {
        if (empty($arguments)) {
            throw new \InvalidArgumentException('At least one argument needed');
        }

        $path = &$arguments[0];

        if (!\is_string($path)) {
            throw new \InvalidArgumentException('First argument should be a string');
        }

        [$prefix, $path] = $this->getPrefixAndPath($path);

        return [$prefix, $arguments];
    }
592651
public function getChildren(...$args)
    {
        if (!$this->filter) {
            $this->filter = new \Amiss\Filter($this->mapper);
        }
        return $this->filter->getChildren(...$args);
    }
1312887
public function filterAction(array $filter)
    {
        $this->checkStaticTemplateIsIncluded();

        $arguments = $this->request->getArguments();

        $filtertext = $this->arrayToFiltertext($filter);

        $arguments['filter'] = $filtertext;

        $this->redirect('dynamic', null, null, $arguments);
    }
359591
public function filterConfig($filter, $settings = null)
    {
        if ($settings === null) {
            if (is_string($filter)) {
                return isset($this->_filters[$filter]) ? $this->_filters[$filter] : [];
            }
            if (is_array($filter)) {
                $result = [];
                foreach ($filter as $f) {
                    $result[$f] = $this->filterConfig($f);
                }
                return $result;
            }
        }
        $this->_filters[$filter] = array_map(
            [$this, '_replacePathConstants'],
            $settings
        );
    }
363431
public function getArgument($num, $filter = null, $default = false)
  {
    if (!$this->hasArgument($num)) {
      return $default;
    }

    $v = $this->arguments[$num];

    return Filter::Value($v, $filter, $default);
  }
1285672
public function addFilter($filters)
    {
        $filters = (array) AnConfig::unbox($filters);

        foreach ($filters as $filter) {
            if (!($filter instanceof LibBaseTemplateFilterInterface)) {
                $filter = $this->getFilter($filter);
            }
            
            //Enqueue the filter in the command chain
            $this->getCommandChain()->enqueue($filter);
            
            //Store the filter
            $this->_filters[$filter->getIdentifier()->name] = $filter;
        }
        
        return $this;
    }
18969
public function addFilter($filter)
    {
        if (!($filter instanceof FilterInterface) && !is_callable($filter)) {
            $filter = FilterHelper::create($filter);
        }

        $this->filter->addFilter($filter);

        return $this;
    }
732805
public function provideFilter($filter = null)
    {
        if ($filter === null) {
            $filter = config('eloquentfilter.namespace', 'App\\ModelFilters\\').class_basename($this).'Filter';
        }

        return $filter;
    }
400759
private function betweenFilter($call, $arguments)
    {
        $num = $this->unsafeFilter($call, $arguments);

        return max(min($arguments[2], $num), $arguments[1]);
    }
1073029
public function auto_filter($filter = true)
	{
		if (func_num_args() == 0)
		{
			return $this->auto_filter;
		}

		$this->auto_filter = $filter;

		return $this;
	}
366436
public function filter(/*Callable*/ $filter)
    {
        $result = clone $this;
        foreach ($this as $object)
        {
            if (call_user_func($filter, $object) === false) {
                $result->remove($object);
            }
        }

        return $result;
    }
834269
public static function getOptions($filter = array())
    {
        $filter = Filter::create($filter);
        return self::getCollection('/options' . $filter->toQuery(), 'Option');
    }
1345549
public function filter($filter)
    {
        if (is_array($filter)) {
            $filter = new GridFilter($filter);
        }

        if ($filter instanceof FilterSpecification) {
            $filter = new GridFilter($filter->asFilter());
        }

        $this->filter = $filter;

        return $this;
    }
636849
public function addArgumentFilter(string $argumentName, string $columnName, ArgFilterDirective $argFilterDirective): self
    {
        if ($argFilterDirective->combinesMultipleArguments()) {
            $filterKey = "{$columnName}.{$argFilterDirective->name()}";

            $this->multiArgumentFilters[$filterKey] = $argFilterDirective;
            $this->multiArgumentFiltersArgNames[$filterKey][] = $argumentName;
        } else {
            $this->singleArgumentFilters[$argumentName] = [
                'filter' => $argFilterDirective,
                'columnName' => $columnName,
            ];
        }

        return $this;
    }
70932
public function handle(FilterOptionInterface $filter, array $options)
    {
        if (count($options) === 0) {
            return $filter;
        }

        $validOptions = $filter->getValidOptions();

        $this->validateFilterOptions($options, $validOptions);
        $this->setFilterOptions($filter, $options, $validOptions);

        return $filter;
    }
210310
public function evaluate(FlowQuery $flowQuery, array $arguments)
    {
        if (count($flowQuery->getContext()) === 0) {
            return;
        }

        if (!isset($arguments[0]) || empty($arguments[0])) {
            if ($flowQuery->peekOperationName() === 'filter') {
                $filterOperation = $flowQuery->popOperation();
                if (count($filterOperation['arguments']) === 0 || empty($filterOperation['arguments'][0])) {
                    throw new FizzleException('Filter() needs arguments if it follows an empty children(): children().filter()', 1332489382);
                }
                $selectorAndFilter = $filterOperation['arguments'][0];
            } else {
                throw new FizzleException('children() needs at least a Property Name filter specified, or must be followed by filter().', 1332489399);
            }
        } else {
            $selectorAndFilter = $arguments[0];
        }

        $parsedFilter = FizzleParser::parseFilterGroup($selectorAndFilter);

        if (count($parsedFilter['Filters']) === 0) {
            throw new FizzleException('filter needs to be specified in children()', 1332489416);
        } elseif (count($parsedFilter['Filters']) === 1) {
            $filter = $parsedFilter['Filters'][0];

            if (isset($filter['PropertyNameFilter'])) {
                $this->evaluatePropertyNameFilter($flowQuery, $filter['PropertyNameFilter']);
                if (isset($filter['AttributeFilters'])) {
                    foreach ($filter['AttributeFilters'] as $attributeFilter) {
                        $flowQuery->pushOperation('filter', [$attributeFilter['text']]);
                    }
                }
            } elseif (isset($filter['AttributeFilters'])) {
                throw new FizzleException('children() must have a property name filter and cannot only have an attribute filter.', 1332489432);
            }
        } else {
            throw new FizzleException('children() only supports a single filter group right now, i.e. nothing of the form "filter1, filter2"', 1332489489);
        }
    }