Disables a filter.

@param string $name Name of the filter.

@return SQLFilter The disabled filter.

@throws InvalidArgumentException If the filter does not exist.
194526
public function disable($name)
    {
        // Get the filter to return it
        $filter = $this->getFilter($name);

        unset($this->enabledFilters[$name]);

        // Now the filter collection is dirty
        $this->filtersState = self::FILTERS_STATE_DIRTY;

        return $filter;
    }
8710
final public function removeColumn(string $name): Index
    {
        if (!$this->hasColumn($name)) {
            throw new InvalidArgumentException('Index not contains the column '.$name);
        }

        $this->columns = array_filter(
            $this->columns,
            function (IndexColumn $indexColumn) use ($name) {
                $column = $indexColumn->getColumn();

                return (bool) ($column::getName() !== $name);
            }
        );

        return $this;
    }
429360
public function find(string $name)
    {
        if (! \array_key_exists($name, $this->keyMap)) {
            throw new InvalidArgumentException("Name [{$name}] is not available.");
        }

        return $this->controls[$this->keyMap[$name]];
    }
589804
public function withoutAttribute($name){
        if(!is_string($name)){
            throw new \InvalidArgumentException(
                "Argument must be of the type string, " . gettype($name) . " given."
            );
        }

        if(!array_key_exists($name, $this->attributes)){
            return $this;
        }

        $clone  = clone $this;

        unset($clone->attributes[$name]);

        return $clone;
    }
993372
public function addFilter(AbstractQuery $filter, string $name = null): self
    {
        $filterArray = [];

        $type = self::NAMED_TYPE;

        if (null === $name) {
            $filterArray[] = $filter;
            $type = self::ANONYMOUS_TYPE;
        } else {
            $filterArray[$name] = $filter;
        }

        if ($this->hasParam('filters')
            && \count($this->getParam('filters'))
            && $this->_type !== $type
        ) {
            throw new InvalidException('Mix named and anonymous keys are not allowed');
        }

        $this->_type = $type;

        return $this->addParam('filters', $filterArray);
    }
401316
public function unset($name)
    {
        $names = $name ? (array) $name : [];
        foreach ($names as $name) {
            unset($this->_columns[$name]);
        }
        return $this;
    }
161821
public function removeFilter($name)
    {
        $filters = $this->getFilters();
        if (array_key_exists($name, $filters)) {
            unset($filters[$name]);
            $this->filters = $filters;
        }

        return $this;
    }
590556
final public function getParameter(string $name)
    {
        if (! array_key_exists($name, $this->parameters)) {
            throw new InvalidArgumentException("Filter parameter '" . $name . "' is not set.");
        }
        return $this->parameters[$name];
    }
563723
public function getFilter($name)
    {
        if (isset($this->filters[$name])) {
            return $this->filters[$name];
        } else {
            return null;
        }
    }
45126
private function getFilter($name)
    {
        if (!$this->hasFilter($name)) {
            throw new FilterNotFoundException($name);
        }

        return $this->filters[$name];
    }
1130018
public function getRule($name)
    {
        if ($this->hasRule($name)) {
            return $this->rules[$name];
        }

        throw new \InvalidArgumentException(sprintf('No rule with name "%s" could be found', $name));
    }
902305
public function removeGetParameter($name)
    {
        if (!$this->hasGetParameter($name)) {
            throw new \InvalidArgumentException(sprintf('The GET request parameter "%s" does not exist.', $name));
        }

        unset($this->getParameters[rawurlencode($name)]);
    }
1223878
public function getPermission($name)
    {
        if ($this->hasPermission($name)) {
            return $this->permissions[$name];
        }

        throw new \InvalidArgumentException(sprintf('No permission with name "%s" could be found', $name));
    }
380331
public function getFilter($name)
	{
		if (!isset(self::$filters[$name]))
		{
			$class = $this->getFilterClass($name);
			self::$filters[$name] = new $class;
			self::$filters[$name]->setPipeline($this);
		}
		
		return self::$filters[$name];
	}
255194
public function setFilter($name, $filter)
    {
        if (!(
            is_callable($filter) ||
            class_exists($filter) ||
            method_exists($filter, 'parse')
        )) {
            throw new InvalidArgumentException(
                'Invalid ' . $name . ' filter given: ' .
                'it must be a callable or a class name.'
            );
        }

        return $this->getCompiler()->setFilter($name, $filter);
    }
816774
public function _unset($name)
    {
        $name = $this->normalizeFieldName($name);
        if (array_key_exists($name, $this->dirty)) {
            $this->data[$name] = $this->dirty[$name];
            unset($this->dirty[$name]);
        }

        return $this;
    }
1168033
public function enableFilter($name) {
        if ( ! is_array($name)) {
            $name = [$name];
        }

        $this->getRoutesMatcher()->getFiltersMatcher()
            ->enableFilters($name);

        return $this;
    }