Call the given route filter.

@param  string  $filter
@param  array  $parameters
@param  \Illuminate\Routing\Route  $route
@param  \Illuminate\Http\Request  $request
@param  \Illuminate\Http\Response|null $response
@return mixed
779505
public function callRouteFilter($filter, $parameters, $route, $request, $response = null)
	{
		$data = array_merge(array($route, $request, $response), $parameters);

		return $this->events->until('router.filter: '.$filter, $this->cleanFilterParameters($data));
	}
245069
public function route(RouterInterface $router, string $path, string $filter, array &$vars) : bool
    {
        $children = $this->getChildren();
        foreach($children as $child) {
            $next = '';
            $res = $child->match($path, $vars, $next);
            if ($res){
                if ($child->route($router, $next, $filter, $vars)){
                    return true;
                }
            }
        }
        return false;
    }
32118
protected function getRouteInformation(Route $route, $filter, $namespace)
    {
        $data = parent::getRouteInformation($route, $filter, $namespace);

        if (!$data || empty($data['name'])) {
            return null;
        }

        return array_only($data, ['uri', 'name']);
    }
898520
public function render($view, array $parameters = array(), Response $response = null)
    {
        if (!isset($response)) {
            $response = new Response();
        }

        $response->setContent($this->getTemplateEngine()->render($view, $parameters));

        return $response;
    }
657509
public function render($view, array $parameters = [], Response $response = null)
    {
        return $this->templating->renderResponse($view, $parameters, $response);
    }
1199245
public function route($name = '', $default = null, $filter = '')
    {
        if (is_array($name)) {
            $this->param        = [];
            return $this->route = array_merge($this->route, $name);
        }
        return $this->input($this->route, $name, $default, $filter);
    }
915129
public function render($template, array $parameters = null, Response $response = null)
    {
        $parameters = array_merge([
            'request'              => $this->getRequest(),
            'routing'              => $this->routing,
            'flash_bag'            => $this->application->getSession()->getFlashBag(),
        ], $parameters ?: []);

        return $this->application->getRenderer()->partial($template, $parameters);
    }
761753
public function delete($route, $params = [])
    {
        $route = $this->parseRoute($route, $params);
        $request = Request::create($route, 'DELETE', Input::all());
        $response = Route::dispatch($request);

        return $response;
    }
709349
protected function replaceRouteParameters($route, &$parameters = [])
    {
        return \preg_replace_callback('/\{(.*?)(:.*?)?(\{[0-9,]+\})?\}/', function ($m) use (&$parameters) {
            return isset($parameters[$m[1]]) ? Arr::pull($parameters, $m[1]) : $m[0];
        }, $route);
    }
134750
public function dispatch(Route $route, Request $request, $controller, $method)
	{
		// First we will make an instance of this controller via the IoC container instance
		// so that we can call the methods on it. We will also apply any "after" filters
		// to the route so that they will be run by the routers after this processing.
		$instance = $this->makeController($controller);

		$this->assignAfter($instance, $route, $request, $method);

		$response = $this->before($instance, $route, $request, $method);

		// If no before filters returned a response we'll call the method on the controller
		// to get the response to be returned to the router. We will then return it back
		// out for processing by this router and the after filters can be called then.
		if (is_null($response))
		{
			$response = $this->call($instance, $route, $method);
		}

		return $response;
	}
50677
public function route(RouterInterface $router, string $path, string $filter, array &$vars) : bool
    {
        return $this->traitRoute($router, $path, $filter, $vars);
    }
1151965
public function route($route = null, array $params = array(), array $query = array())
    {
        return $this->toRoute($route, $params, $query);
    }
729474
protected function postFilterRoutes(Request $request, RouteCollectionInterface $routes, array $map, array $matches)
    {
        try {
            list ($name, $route, $vars) = $this->reverseMapRoute($routes, $matches, $map['map']);
        } catch (RuntimeException $e) {
            return $this->noMatch($request, self::NOMATCH);
        }

        if (null !== $route->getHost() &&
            !(bool)preg_match_all($route->getContext()->getHostRegex(), $request->getHost())) {
            return $this->noMatch($request, self::NOMATCH_HOST);
        }

        return new Match(self::MATCH, $name, $request, $route->getHandler(), $vars);
    }
450372
protected function processFilters($parameters)
    {
        if (isset($parameters['filter'])) {
            $filters = $parameters['filter'];
            unset($parameters['filter']);
            foreach ($filters as $filter => $value) {
                $parameters['filter[' . $filter . ']'] = $value;
            }
        }

        return $parameters;
    }
341097
protected function parseFilter($filter, array $options)
	{
		$parameters = array();

		$original = $filter;

		if ($filter instanceof Closure)
		{
			$filter = $this->registerClosureFilter($filter);
		}
		elseif ($this->isInstanceFilter($filter))
		{
			$filter = $this->registerInstanceFilter($filter);
		}
		else
		{
			list($filter, $parameters) = Route::parseFilter($filter);
		}

		return compact('original', 'filter', 'parameters', 'options');
	}
327367
protected function _params_filter($parameters = array()){
    $params = array();
    foreach($parameters as $key => $val) {
        if ($key == "Signature" ||$val === "" || $val === NULL){
          continue;
        } else {
          $params[$key] = $parameters[$key];
        }
    }
    ksort($params);
    reset($params);
    return $params;
  }
621386
public function processRouteFilters(Route $route)
	{
		foreach ($this->filterByRoute($route) as $filter) {

			$result = call_user_func_array($filter, func_get_args());
			
			if ($result !== null) {

				return $result;
			}
		}
	}