Removes a route for the given priority.

@access public
@param string $route
@param integer $priority
@return boolean
334869
public function removeRoute($route, $priority = 50)
    {
        // If the priority isn't existing we return at this point
        if (!isset($this->routes[$priority])) {
            return true;
        }
        
        // If the route isn't registred we return with true.
        if (!isset($this->routes[$priority][$route])) {
            return true;
        }
        
        // Remove the route from the array
        unset($this->routes[$priority][$route]);
        $this->saveRoutes();
        
        return true;
    }
1135812
public function removeFilterHandler($filterName, $filterHandlerName, $priority = 50)
    {
        $this->removeHandler(self::FILTER, $filterName, $filterHandlerName, $priority);
    }
1365154
public function removeRoute($path)
    {
        $routeName = ltrim($path, '/');
        if (!isset($this->routes[$routeName])) {
            return false;
        }
        unset($this->routes[$routeName]);
        return true;
    }
1360880
public function remove($hookName, $functionToRemove, $priority = 10) : bool
    {
        $hookName = $this->sanitizeKeyName($hookName);
        if (!$hookName) {
            return false;
        }

        $functionToRemove = $this->uniqueId($functionToRemove);
        $r = $this->filters[$hookName][$priority];
        $r = $r ? $r->has($functionToRemove) : false;
        if ($r === true) {
            $this->filters[$hookName][$priority]->remove($functionToRemove);
            if ($this->filters[$hookName][$priority]->isEmpty()) {
                unset($this->filters[$hookName][$priority]);
            }
            if (empty($this->filters[$hookName])) {
                $this->filters[$hookName]= [];
            }
            unset($this->merged[$hookName]);
        }

        return $r;
    }
1336601
private function isAllowedByIp(array $route)
    {
        if (empty($route['allow']['from'])) {
            return true;
        }

        $from = $route['allow']['from'];
        $pieces = explode('|', $from);

        return in_array($this->ip, $pieces);
    }
1192321
public function removeByKey(string $key): bool
    {
        if (isset($this->routes[$key])) {
            unset($this->routes[$key]);
            return true;
        }
        return false;
    }
500812
function update($route) {
        $route->pattern = $this->parser->trimPath($route->pattern);
        return parent::update($route);
    }
702497
def remove_routes(self, item, routes):
        """"""
        for route in routes:
            items = self._routes.get(route)
            try:
                items.remove(item)
                LOG.debug('removed item from route %s', route)
            except ValueError:
                pass
            if not items:
                self._routes.pop(route)
                LOG.debug('removed route %s', route)
55322
public function delete($rule, $route = '', array $option = [], array $pattern = [])
    {
        return $this->rule($rule, $route, 'DELETE', $option, $pattern);
    }
396918
public function processRoute($route) {
		if( !$route ) {
			throw new NotFoundException('No route matches the current request '.$this);
		}
		$this->setRoute($route);
		return $this->route->run($this);
	}
543449
public function remove($hook, $callback = null, $priority = 10)
    {
        // If $callback is null, it means we have chained the methods to
        // the action/filter instance. If the instance has no callback, return false.
        if (is_null($callback)) {
            if (! $callback = $this->getCallback($hook)) {
                return false;
            }

            list($callback, $priority, $accepted_args) = $callback;

            // Unset the hook.
            unset($this->hooks[$hook]);
        }

        $this->removeAction($hook, $callback, $priority);

        return $this;
    }
31385
private function isPrefixedRoute($route, $routePrefix)
    {
        $regexp = '~^'. preg_quote($routePrefix) .'~';
        
        return preg_match($regexp, $this->getRouteParam($route, 'uri'));
    }
634331
public function removeTemplate($key, $file, $priority = 10)
    {
        // If we can't find the template file we do not have to remove anything.
        if (!isset($this->templates[$key][$priority])) {
            return false;
        }
        
        // Remove the template file.
        unset($this->templates[$key][$priority]);
    }
139865
public function is( $route = '' ) {

		if ( $route == '' ) {
			return self::$destination;
		} else {

			if ( self::$destination == $route ) {
				return TRUE;
			} else {
				return FALSE;
			}

		}

	}
749322
public function dispatch(Route $route)
    {
        $callback = $route->getCallback();
        $params = array_values($route->getData());

        if ($callback instanceof Closure) {
            return $this->container->resolveClosure($callback, $params);
        }

        $class = $this->container->make($callback[0]);
        return $this->container->resolveMethod($class, $callback[1], $params);
    }
99445
protected function isNotSameRouteHost(Route $route): bool
    {
        if ($this->host === null && $route->getHost() === null) {
            return false;
        }

        if ($this->host === null && $route->getHost() !== null) {
            return true;
        }

        return !$route->isSameHost($this->host, $this->hostConstraints);
    }
1050404
public static function delete(Route $route)
    {
        $routeWithoutSlash = $route;
        $routeWithSlash = $route->getWithSlash();

        // exception_if(! check(self::$register[$routeWithoutSlash->getName()]), RouteNotFoundInRoutesRegisterException::class , $routeWithoutSlash);
        // exception_if(! check(self::$register[$routeWithSlash->getName()]), RouteNotFoundInRoutesRegisterException::class , $routeWithSlash);

        if (check(self::$register[$routeWithoutSlash->getName()])) {
            unset(self::$register[$routeWithoutSlash->getName()]);
        }

        if (check(self::$register[$routeWithSlash->getName()])) {
            unset(self::$register[$routeWithSlash->getName()]);
        }
    }