Add the given filters to the route by type.

@param  string  $type
@param  string  $filters
@return $this
164143
protected function addFilters($type, $filters)
	{
		$filters = static::explodeFilters($filters);

		if (isset($this->action[$type]))
		{
			$existing = static::explodeFilters($this->action[$type]);

			$this->action[$type] = array_merge($existing, $filters);
		}
		else
		{
			$this->action[$type] = $filters;
		}

		return $this;
	}
523688
public function filter($filter)
    {
        if (is_array($filter)) {
            $filter = new Filter($filter);
        }
        $this->filter = $filter;
        return $this;
    }
345056
public function setFilters(array $filters)
    {
        if (empty($filters)) {
            return $this->clearFilters();
        }

        session()->put($this->getSessionKey(static::TYPE_FILTERS), $filters);

        return $this;
    }
315296
public function setFilter(Filter $filter)
    {
        if (is_null($this->name)) {
            $this->name = $filter->getName();
        }
        $this->filter = $filter;

        return $this;
    }
178573
public function setFilters($filters)
    {
        $this->filters = Collection::make($filters);
        foreach ($this->filters as $filterConfig) {
            $filterConfig->attach($this);
        }

        return $this;
    }
456221
public function setInputFilter($inputName, $filters)
    {
        $input = $this->getInput($inputName);
        $input->filters = [];
        $this->addInputFilter($inputName, $filters);
        return $this;
    }
732004
public function addFilters(array $filters)
    {
        foreach ($filters as $key => $filter) {
            $this->addFilter($filter);

            /** Name the expression if $key is a non-numeric string. */
            if (is_string($key) && !is_numeric($key)) {
                $filter = end($this->filters);
                $filter->setName($key);
            }
        }

        return $this;
    }
1296060
public function addFiltersWithOrToTable(iterable $filters): self
    {
        $addWith = $this->expr()->orX();
        $this->applyFilters($addWith, $this->getTableName(), $filters);
        $addWith->count() <= 0 ?: $this->andWhere($addWith);

        return $this;
    }
220119
public static function create(?TypeCollection $types = null): self
    {
        $types = $types ?? TypeCollection::createDefault();

        $parser = new Parser();

        $factory = new RouteFactory($parser, $types);

        return new self($factory);
    }
1041358
public function setFilters(array $filters = [])
    {
        foreach ($filters as $filterName => $filterValue) {
            $this->addFilter($filterName, $filterValue);
        }

        return $this;
    }
81576
protected function _addFilters(Input &$input, array $filters)
    {
        foreach($filters as $filter) {
            $input->getFilterChain()->add(StaticFilter::create($filter));
        }
    }
1228752
public function filters(Collection $filters)
    {
        foreach ($filters as $element) {
            // do not apply filter if no request var were found.
            if (!app('request')->has($element->id())) {
                continue;
            }

            $this->assemblyQuery($element);
        }

        return $this;
    }
529420
public function addFilter($key, $filter)
    {
        if (false === isset($this->filters[$key])) {
            $this->filters[$key] = [];
        }

        $this->filters[$key][] = $filter;

        return $this;
    }
1039024
public function addFilters(array $filters)
    {
        foreach ($filters as $filter) {
            if ($filter === null) {
                continue;
            }

            $this->addFilter($filter);
        }

        return $this;
    }
423440
public function setFilters(Mutable $filters = null)
    {
        if ($filters) {
            $filters = $filters->map(function ($element) {
                if ($this->request->has($id = $element->id())) {
                    $element->getInput()->setValue(
                        $this->request->get($id)
                    );
                }

                return $element;
            });
        }

        $this->filters = $filters;

        return $this;
    }
148423
public function setFilter(FilterQuery $filter)
    {
        $this->result = array_merge($this->result, $filter->toArray()['bool']);

        return $this;
    }
631074
public function addTypeFilter($type)
    {
        $this->filter->eq('predicate', OntologyRdf::RDF_TYPE)
                     ->eq('object', $type);
        return $this;
    }