/*
(non-Javadoc)

@see javax.security.enterprise.authentication.mechanism.http.HttpMessageContext#forward(java.lang.String)
514
@Override
    public AuthenticationStatus forward(String path) {
        try {
            RequestDispatcher requestDispatcher = request.getRequestDispatcher(path);
            requestDispatcher.forward(request, response);
        } catch (Exception e) {
            // TODO: Add serviceability message
        }
        return AuthenticationStatus.SEND_CONTINUE;
    }
133229
def forward_message(self, *args, **kwargs):
        """"""
        return forward_message(*args, **self._merge_overrides(**kwargs)).run()
724021
private void forward() {

        Set<String> selected = new HashSet<>();

        for (CheckBox checkbox : m_componentCheckboxes) {
            CmsSetupComponent component = (CmsSetupComponent)(checkbox.getData());
            if (checkbox.getValue().booleanValue()) {
                selected.add(component.getId());
            }
        }
        String error = null;
        for (String compId : selected) {
            CmsSetupComponent component = m_componentMap.get(compId);
            for (String dep : component.getDependencies()) {
                if (!selected.contains(dep)) {
                    error = "Unfulfilled dependency: The component "
                        + component.getName()
                        + " can not be installed because its dependency "
                        + m_componentMap.get(dep).getName()
                        + " is not selected";
                    break;
                }
            }
        }
        if (error == null) {
            Set<String> modules = new HashSet<>();

            for (CmsSetupComponent component : m_componentMap.values()) {

                if (selected.contains(component.getId())) {

                    for (CmsModule module : m_context.getSetupBean().getAvailableModules().values()) {
                        if (component.match(module.getName())) {
                            modules.add(module.getName());
                        }
                    }
                }
            }
            List<String> moduleList = new ArrayList<>(modules);
            m_context.getSetupBean().setInstallModules(CmsStringUtil.listAsString(moduleList, "|"));
            m_context.stepForward();
        } else {
            CmsSetupErrorDialog.showErrorDialog(error, error);
        }
    }
265263
@SuppressWarnings({"UnusedDeclaration"})
    public void doIndex(StaplerRequest req, StaplerResponse resp) throws IOException, ServletException {
        req.getView(this, chooseAction()).forward(req, resp);
    }
246256
def forward(self, is_train=False):
        """"""
        for texec in self.train_execs:
            texec.forward(is_train=is_train)
651650
protected function forward($uri, $filter = FALSE){
        $this->context->app->httpCore->executeHttpRequest(NULL, $uri, $filter);
    }
121158
@Override
    public VarTensor forward() {
        VarTensor x = modInX.getOutput();
        y = new VarTensor(s, x.getVars());
        for (int c = 0; c < y.size(); c++) {
            y.setValue(c, s.fromLogProb(x.getValue(c)));
        }
        return y;
    }
197642
public static String getForwardURI(HttpServletRequest request) {
        String result = (String) request.getAttribute(WebUtils.FORWARD_REQUEST_URI_ATTRIBUTE);
        if (GrailsStringUtils.isBlank(result)) result = request.getRequestURI();
        return result;
    }
593764
public static void Forward(double[][] data) {
        int rows = data.length;
        int cols = data[0].length;

        double[] row = new double[cols];
        double[] col = new double[rows];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < row.length; j++)
                row[j] = data[i][j];

            Forward(row);

            for (int j = 0; j < row.length; j++)
                data[i][j] = row[j];
        }

        for (int j = 0; j < cols; j++) {
            for (int i = 0; i < col.length; i++)
                col[i] = data[i][j];

            Forward(col);

            for (int i = 0; i < col.length; i++)
                data[i][j] = col[i];
        }
    }
775474
protected void prepareForwardedRequestHeaders(RequestData request, ForwardDestination destination) {
        HttpHeaders headers = request.getHeaders();
        headers.set(HOST, destination.getUri().getAuthority());
        headers.remove(TE);
    }
1114600
public void setDefactoForwardedHeaders() {
        if (xForwardedForHeader != null && xForwardedByHeader != null) {
            httpOutboundRequest.setHeader(Constants.X_FORWARDED_FOR,
                    xForwardedForHeader.trim() + COMMA + " " + xForwardedByHeader.trim());
        } else if (xForwardedByHeader != null) {
            httpOutboundRequest.setHeader(Constants.X_FORWARDED_FOR, xForwardedByHeader.trim());
        }
        httpOutboundRequest.setHeader(Constants.X_FORWARDED_BY, localAddress);
    }
352220
public void forward(ServletRequest request, ServletResponse response)
			throws ServletException, IOException {
		if(request != null) {
			((SipServletRequest)request).getSession().setHandler(handler.getName());
		} else {
			((SipServletResponse)response).getSession().setHandler(handler.getName());
		}
		Servlet servlet = handler.allocate();
		servlet.service(request, response);
		handler.deallocate(servlet);
	}
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();
        }
    }
384850
@Override
    public VarTensor forward() {
        MVecArray<VarTensor> xs = modIn.getOutput();
        y = new VarTensor(s, new VarSet(), s.one());
        for (int a=0; a<xs.dim(); a++) {
            VarTensor x = xs.get(a);
            y.prod(x);
        }
        return y;
    }
441382
protected <T extends Request, U extends Response> CompletableFuture<U> forward(T request) {
    CompletableFuture<U> future = new CompletableFuture<>();
    context.getConnections().getConnection(context.getLeader().serverAddress()).whenComplete((connection, connectError) -> {
      if (connectError == null) {
        connection.<T, U>sendAndReceive(request).whenComplete((response, responseError) -> {
          if (responseError == null) {
            future.complete(response);
          } else {
            future.completeExceptionally(responseError);
          }
        });
      } else {
        future.completeExceptionally(connectError);
      }
    });
    return future;
  }
746121
private void forwardMessage(AbstractMessage aMessage,
                                SIBUuid8 targetMEUuid)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "forwardMessage",
                  new Object[]{aMessage, targetMEUuid});

    if (TraceComponent.isAnyTracingEnabled() && UserTrace.tc_mt.isDebugEnabled() && !aMessage.isControlMessage())
    {
      JsMessage jsMsg = (JsMessage) aMessage;
      JsDestinationAddress routingDestination = jsMsg.getRoutingDestination();
      if(routingDestination != null)
      {
        String destId = routingDestination.getDestinationName();
        boolean temporary = false;
        if(destId.startsWith(SIMPConstants.TEMPORARY_PUBSUB_DESTINATION_PREFIX))
          temporary = true;

        UserTrace.forwardJSMessage(jsMsg,
                                   targetMEUuid,
                                   destId,
                                   temporary);
      }
      else
      {
        DestinationHandler dest =
          _destinationManager.getDestinationInternal(aMessage.getGuaranteedTargetDestinationDefinitionUUID(), false);

        if (dest != null)
          UserTrace.forwardJSMessage(jsMsg,
                                     targetMEUuid,
                                     dest.getName(),
                                     dest.isTemporary());
        else
          UserTrace.forwardJSMessage(jsMsg,
                                     targetMEUuid,
                                     jsMsg.getGuaranteedTargetDestinationDefinitionUUID().toString(),
                                     false);
      }

    }

    // Send this to MPIO
    _mpio.sendToMe( targetMEUuid,
                    aMessage.getPriority().intValue(),
                    aMessage );

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
         SibTr.exit(tc, "forwardMessage");
  }
455596
@Override
	public void render() {
		try {
			final HttpServletRequest request = Request.getServletRequest();
			request.getRequestDispatcher(uri).forward(request, Response.getServletResponse());
		} catch (Exception e) {
			throw new RenderException("Forward to " + uri + " error!", e);
		}
	}