o routing path of forward e.g. /member/list/ -> MemberListAction
357177
public NextJourney createNextJourney(PlannedJourneyProvider journeyProvider, HtmlResponse response) { // almost copied from super
        String path = response.getRoutingPath();
        final boolean redirectTo = response.isRedirectTo();
        if (path.indexOf(":") < 0) {
            if (!path.startsWith("/")) {
                path = buildActionPath(getActionDef().getComponentName()) + path;
            }
            if (!redirectTo && isHtmlForward(path)) {
                path = filterHtmlPath(path);
            }
        }
        return newNextJourney(journeyProvider, path, redirectTo, response.isAsIs(), response.getViewObject());
    }
916988
function routeDescription (route, index, group) {
   const meta = route.meta || {};
   const desc = meta.description;
   const extd = meta.extendedDescription;

   return [
      routeInfo(route.method, route.path, group.prefix),
      !desc ? '' : m('p', desc),
      !extd ? '' : m('p', m.trust( markdown( stripIndent(extd) ) ))
   ];
}
310493
def path_to_routing_key(path)
      new_path = ""
      path.split('').each_with_index do |c,i|
        if c == '/' and i != 0 and i != path.length-1
          new_path += '.'
        elsif c != '/'
          new_path += c
        end
      end
      new_path
    end
1085011
private function getDefaultRoutePath(): string
    {
        $pattern = $this
            ->adminConfiguration
            ->getParameter('routing_url_pattern')
        ;
        $path = str_replace('{admin}', $this->adminName, $pattern);
        $path = str_replace('{action}', $this->actionName, $path);

        if (in_array($this->actionName, ['edit', 'delete'])) {
            $path .= '/{id}';
        }

        return $path;
    }
632597
def p_route_io(self, p):
        """"""
        if len(p) > 6:
            p[0] = (p[2], p[4], p[6])
        else:
            p[0] = (p[2], p[4], None)
456321
private function routing()
    {
        // import.
        $file = $this->app->getLoader()->findFirst($this->app->config('directory.config.routing') . DS . 'routes.yml');
        $this->router->import($file);

        // routing.
        $rule = $this->router->routing();
        $this->request->import($rule->getParams());

        // add action chain.
        $this->actionChain->addAction($rule->getController(), $rule->getAction());
    }
423321
private CompletableFuture<QueryResponse> queryForward(QueryRequest request) {
    if (raft.getLeader() == null) {
      return CompletableFuture.completedFuture(logResponse(QueryResponse.builder()
          .withStatus(RaftResponse.Status.ERROR)
          .withError(RaftError.Type.NO_LEADER)
          .build()));
    }

    log.trace("Forwarding {}", request);
    return forward(request, raft.getProtocol()::query)
        .exceptionally(error -> QueryResponse.builder()
            .withStatus(RaftResponse.Status.ERROR)
            .withError(RaftError.Type.NO_LEADER)
            .build())
        .thenApply(this::logResponse);
  }
644654
public function routing()
    {
        // has dispatch.
        if ($action = $this->getDispatchAction()) {
            return new Rule\MatchRule(array('action' => $action));
        }

        // default rule.
        $path = '/';
        if ($this->_default && $this->_default->matching($path)) {
            return $this->_default;
        }
    }
494713
@Override
    public SIDestinationAddress[] getDefaultForwardRoutingPath()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getDefaultForwardRoutingPath");
            SibTr.exit(tc, "getDefaultForwardRoutingPath", _defaultFrp);
        }

        return _defaultFrp;
    }
676010
def forward(self, **kwargs):
        
        # rewrite url path  
        prefix = self.url_prefix
        path= "" if request.path == "/" else request.path
        path = path[len(prefix):]
        url = '%s%s'% ( self.url_root[:-1], path )

        if request.method == 'GET':
            resp = requests.get(url, params=request.args)
            data = json.loads(resp.content)
        elif request.method == 'POST':
            if request.headers['Content-Type'].startswith('application/json'):
                # data in JSON
                resp = requests.post(url, json=request.json)
                data = request.json
            else :
                resp = requests.post(url, json=request.form)
                data = request.form
            data = json.loads(resp.content)
        else:
            # method not allowed aborting
            abort(405) # XXX

        return jsonify(data)
61607
def route_path(self, path):
        '''
        
        '''
        path = path.strip('/')
        name, _, subpath = path.partition('/')
        for service in singletons.settings.load_all('SERVICES'):
            if service.SERVICE_NAME == name:  # Found service!
                break
        else:
            return [], None  # found no service

        for partial_url, view in service.urls.items():
            partial_url = partial_url.strip('/')
            if isinstance(view, str):
                view = getattr(service, view)
            regexp = re.sub(r'<[^>]+>', r'([^/]+)', partial_url)
            matches = re.findall('^%s$' % regexp, subpath)
            if matches:
                if '(' not in regexp:
                    matches = []
                return matches, view

        return [], None
1276964
function Request_forward(route, params) {

        var request;

        if (router.trim(this.route, "/") === router.trim(route, '/')) {
            throw new error.HttpError(500, {
                route: route,
                params: params
            }, 'Cannot forward to same route');
        } else {

            this.stopPromiseChain();

            request = new Request({
                request: this.request,
                response: this.response,
                isForwarded: true,
                body: this.body
            }, router.createUrl(route, params));

            this.isRendered = true;

            logger.info('Request.forward.route:', {
                route: route,
                params: params
            });

            return request.parse();
        }
    }
834828
def subscription_path_for(subscription, params = {})
      options = params.dup
      options.delete(:devise_default_routes) ?
        send("#{routing_scope(options)}subscription_path", subscription, options) :
        send("#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_path", subscription.target, subscription, options)
    end
874778
def routingAreaUpdateReject():
    """"""
    a = TpPd(pd=0x3)
    b = MessageType(mesType=0xb)  # 00001011
    c = GmmCause()
    d = ForceToStandbyAndSpareHalfOctets()
    packet = a / b / c / d
    return packet
931222
def custom_url_for(object_type, action)
      path = @paths.find do |path|
        path[:object_type] == object_type &&
        path[:action] == action
      end
      if path
        ServiceUrl.new(generate_url(path[:path]), path[:method])
      end
    end
386868
function route(
    $path = '/', $actions, $method = Router::ANY_METHOD, $name = null, array $filters = [], array $events = []
    )
    {
        if (is_array($path)) {
            foreach ($path as $p) {
                $this->collection[$name ?: count($this->collection)] = (new Route($this->Parser))
                        ->route($p, is_array($actions) ? $actions : [$actions], $method, $name, $filters, $events);
            }
        } else {
            $this->collection[$name ?: count($this->collection)] = (new Route($this->Parser))
                    ->route($path, is_array($actions) ? $actions : [$actions], $method, $name, $filters, $events);
        }

        return $this;
    }
477163
final void setFRP(List<SIDestinationAddress> value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setFRP", value);

        if (value == null) {
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_DESTINATIONNAME, null);
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_MEID, null);
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATHLOCALONLY, null);
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_BUSNAME, null);
        } else {
            // The List provided should either be one of our RoutingPathList objects or
            // a standard Java List containing (non-null) SIDestinationAddress elements.
            // If it's the latter we just create a RoutingPathList to wrap it.
            RoutingPathList rp;
            if (value instanceof RoutingPathList)
                rp = (RoutingPathList) value;
            else
                rp = new RoutingPathList(value);

            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_DESTINATIONNAME, rp.getNames());
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_MEID, rp.getMEs());
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATHLOCALONLY, rp.getLocalOnlys());
            getHdr2().setField(JsHdr2Access.FORWARDROUTINGPATH_BUSNAME, rp.getBusNames());
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setFRP");
    }