docs: private Object doChainedInvocation(URI uri,
                                         MultivaluedMap<String, String> headers,
                                         OperationResourceInfo ori,
                                         Object[] methodParams,
                                         Object body,
                                         int bodyIndex,
                                         Exchange exchange,
                                         Map<String, Object> invocationContext) throws Throwable {
          //CHECKSTYLE:ON
          Bus configuredBus = getConfiguration().getBus();
          Bus origBus = BusFactory.getAndSetThreadDefaultBus(configuredBus);
          ClassLoaderHolder origLoader = null;
          try {
              ClassLoader loader = configuredBus.getExtension(ClassLoader.class);
              if (loader != null) {
                  origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
              }
              Message outMessage = createMessage(body, ori, headers, uri,
                                                 exchange, invocationContext, true);
              if (bodyIndex != -1) {
                  outMessage.put(Type.class, ori.getMethodToInvoke().getGenericParameterTypes()[bodyIndex]);
              }
              outMessage.getExchange().setOneWay(ori.isOneway());
              setSupportOnewayResponseProperty(outMessage);
              outMessage.setContent(OperationResourceInfo.class, ori);
              setPlainOperationNameProperty(outMessage, ori.getMethodToInvoke().getName());
              outMessage.getExchange().put(Method.class, ori.getMethodToInvoke());
  
              outMessage.put(Annotation.class.getName(),
                             getMethodAnnotations(ori.getAnnotatedMethod(), bodyIndex));
  
              outMessage.getExchange().put(Message.SERVICE_OBJECT, proxy);
              if (methodParams != null) {
                  outMessage.put(List.class, Arrays.asList(methodParams));
              }
              if (body != null) {
                  outMessage.put(PROXY_METHOD_PARAM_BODY_INDEX, bodyIndex);
              }
              outMessage.getInterceptorChain().add(bodyWriter);
  
              Map<String, Object> reqContext = getRequestContext(outMessage);
              reqContext.put(OperationResourceInfo.class.getName(), ori);
              reqContext.put(PROXY_METHOD_PARAM_BODY_INDEX, bodyIndex);
  
              // execute chain
              InvocationCallback<Object> asyncCallback = checkAsyncCallback(ori, reqContext, outMessage);
              if (asyncCallback != null) {
                  return doInvokeAsync(ori, outMessage, asyncCallback);
              }
              doRunInterceptorChain(outMessage);
  
              Object[] results = preProcessResult(outMessage);
              if (results != null && results.length == 1) {
                  return results[0];
              }
  
              try {
                  return handleResponse(outMessage, ori.getClassResourceInfo().getServiceClass());
              } finally {
                  completeExchange(outMessage.getExchange(), true);
              }
  
          } finally {
              if (origLoader != null) {
                  origLoader.reset();
              }
              if (origBus != configuredBus) {
                  BusFactory.setThreadDefaultBus(origBus);
              }
          }
  
      }