YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

// THIS FILE IS AUTOGENERATED FROM yb/rpc/rtest.proto

#include "yb/rpc/rtest.proxy.h"

#include "yb/rpc/rtest.service.h"

#include "yb/rpc/proxy.h"

#include "yb/rpc/outbound_call.h"

#include "yb/util/metrics.h"

#include "yb/util/net/sockaddr.h"

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Add,

  "Bytes sent by yb.rpc_test.CalculatorService.Add() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Add() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Add,

  "Bytes received in response to yb.rpc_test.CalculatorService.Add() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Add() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Sleep,

  "Bytes sent by yb.rpc_test.CalculatorService.Sleep() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Sleep() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Sleep,

  "Bytes received in response to yb.rpc_test.CalculatorService.Sleep() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Sleep() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Echo,

  "Bytes sent by yb.rpc_test.CalculatorService.Echo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Echo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Echo,

  "Bytes received in response to yb.rpc_test.CalculatorService.Echo() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Echo() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_WhoAmI,

  "Bytes sent by yb.rpc_test.CalculatorService.WhoAmI() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.WhoAmI() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_WhoAmI,

  "Bytes received in response to yb.rpc_test.CalculatorService.WhoAmI() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.WhoAmI() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_TestArgumentsInDiffPackage,

  "Bytes sent by yb.rpc_test.CalculatorService.TestArgumentsInDiffPackage() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.TestArgumentsInDiffPackage() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_TestArgumentsInDiffPackage,

  "Bytes received in response to yb.rpc_test.CalculatorService.TestArgumentsInDiffPackage() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.TestArgumentsInDiffPackage() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Panic,

  "Bytes sent by yb.rpc_test.CalculatorService.Panic() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Panic() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Panic,

  "Bytes received in response to yb.rpc_test.CalculatorService.Panic() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Panic() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Ping,

  "Bytes sent by yb.rpc_test.CalculatorService.Ping() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Ping() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Ping,

  "Bytes received in response to yb.rpc_test.CalculatorService.Ping() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Ping() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Disconnect,

  "Bytes sent by yb.rpc_test.CalculatorService.Disconnect() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Disconnect() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Disconnect,

  "Bytes received in response to yb.rpc_test.CalculatorService.Disconnect() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Disconnect() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Forward,

  "Bytes sent by yb.rpc_test.CalculatorService.Forward() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Forward() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Forward,

  "Bytes received in response to yb.rpc_test.CalculatorService.Forward() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Forward() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Lightweight,

  "Bytes sent by yb.rpc_test.CalculatorService.Lightweight() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Lightweight() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Lightweight,

  "Bytes received in response to yb.rpc_test.CalculatorService.Lightweight() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Lightweight() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_CalculatorService_Trivial,

  "Bytes sent by yb.rpc_test.CalculatorService.Trivial() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.CalculatorService.Trivial() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_CalculatorService_Trivial,

  "Bytes received in response to yb.rpc_test.CalculatorService.Trivial() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.CalculatorService.Trivial() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_request_bytes_yb_rpc_test_AbacusService_Concat,

  "Bytes sent by yb.rpc_test.AbacusService.Concat() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes sent by yb.rpc_test.AbacusService.Concat() RPC requests");

METRIC_DEFINE_counter(

  server, proxy_response_bytes_yb_rpc_test_AbacusService_Concat,

  "Bytes received in response to yb.rpc_test.AbacusService.Concat() RPC requests",

  yb::MetricUnit::kBytes,

  "Bytes received in response to yb.rpc_test.AbacusService.Concat() RPC requests");

namespace yb {

namespace rpc_test {

namespace {

const std::string kFullCalculatorServiceName = "yb.rpc_test.CalculatorService";

::yb::rpc::ProxyMetricsPtr CreateCalculatorServiceMetrics(const scoped_refptr<MetricEntity>& entity) {

  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<11>>();

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kAdd)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Add.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Add.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kSleep)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Sleep.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Sleep.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kEcho)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Echo.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Echo.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kWhoAmI)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_WhoAmI.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_WhoAmI.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kTestArgumentsInDiffPackage)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_TestArgumentsInDiffPackage.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_TestArgumentsInDiffPackage.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kPanic)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Panic.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Panic.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kPing)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Ping.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Ping.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kDisconnect)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Disconnect.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Disconnect.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kForward)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Forward.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Forward.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kLightweight)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Lightweight.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Lightweight.Instantiate(entity)

  };

  result->value[to_underlying(CalculatorServiceRpcMethodIndexes::kTrivial)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_CalculatorService_Trivial.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_CalculatorService_Trivial.Instantiate(entity)

  };

  return result;

}

const std::string kFullAbacusServiceName = "yb.rpc_test.AbacusService";

::yb::rpc::ProxyMetricsPtr CreateAbacusServiceMetrics(const scoped_refptr<MetricEntity>& entity) {

  auto result = std::make_shared<::yb::rpc::ProxyMetricsImpl<1>>();

  result->value[to_underlying(AbacusServiceRpcMethodIndexes::kConcat)] = {

      METRIC_proxy_request_bytes_yb_rpc_test_AbacusService_Concat.Instantiate(entity),

      METRIC_proxy_response_bytes_yb_rpc_test_AbacusService_Concat.Instantiate(entity)

  };

  return result;

}

} // namespace

CalculatorServiceProxy::CalculatorServiceProxy(

    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,

    const ::yb::rpc::Protocol* protocol,

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullCalculatorServiceName, &CreateCalculatorServiceMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status CalculatorServiceProxy::Add(

    const ::yb::rpc_test::AddRequestPB &req, ::yb::rpc_test::AddResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Add");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kAdd)), req, resp, controller);

}

void CalculatorServiceProxy::AddAsync(

    const ::yb::rpc_test::AddRequestPB &req, ::yb::rpc_test::AddResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Add");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kAdd)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Sleep(

    const ::yb::rpc_test::SleepRequestPB &req, ::yb::rpc_test::SleepResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Sleep");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kSleep)), req, resp, controller);

}

void CalculatorServiceProxy::SleepAsync(

    const ::yb::rpc_test::SleepRequestPB &req, ::yb::rpc_test::SleepResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Sleep");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kSleep)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Echo(

    const ::yb::rpc_test::EchoRequestPB &req, ::yb::rpc_test::EchoResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Echo");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kEcho)), req, resp, controller);

}

void CalculatorServiceProxy::EchoAsync(

    const ::yb::rpc_test::EchoRequestPB &req, ::yb::rpc_test::EchoResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Echo");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kEcho)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::WhoAmI(

    const ::yb::rpc_test::WhoAmIRequestPB &req, ::yb::rpc_test::WhoAmIResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "WhoAmI");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kWhoAmI)), req, resp, controller);

}

void CalculatorServiceProxy::WhoAmIAsync(

    const ::yb::rpc_test::WhoAmIRequestPB &req, ::yb::rpc_test::WhoAmIResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "WhoAmI");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kWhoAmI)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::TestArgumentsInDiffPackage(

    const ::yb::rpc_test_diff_package::ReqDiffPackagePB &req, ::yb::rpc_test_diff_package::RespDiffPackagePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "TestArgumentsInDiffPackage");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kTestArgumentsInDiffPackage)), req, resp, controller);

}

void CalculatorServiceProxy::TestArgumentsInDiffPackageAsync(

    const ::yb::rpc_test_diff_package::ReqDiffPackagePB &req, ::yb::rpc_test_diff_package::RespDiffPackagePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "TestArgumentsInDiffPackage");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kTestArgumentsInDiffPackage)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Panic(

    const ::yb::rpc_test::PanicRequestPB &req, ::yb::rpc_test::PanicResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Panic");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kPanic)), req, resp, controller);

}

void CalculatorServiceProxy::PanicAsync(

    const ::yb::rpc_test::PanicRequestPB &req, ::yb::rpc_test::PanicResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Panic");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kPanic)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Ping(

    const ::yb::rpc_test::PingRequestPB &req, ::yb::rpc_test::PingResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Ping");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kPing)), req, resp, controller);

}

void CalculatorServiceProxy::PingAsync(

    const ::yb::rpc_test::PingRequestPB &req, ::yb::rpc_test::PingResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Ping");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kPing)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Disconnect(

    const ::yb::rpc_test::DisconnectRequestPB &req, ::yb::rpc_test::DisconnectResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Disconnect");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kDisconnect)), req, resp, controller);

}

void CalculatorServiceProxy::DisconnectAsync(

    const ::yb::rpc_test::DisconnectRequestPB &req, ::yb::rpc_test::DisconnectResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Disconnect");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kDisconnect)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Forward(

    const ::yb::rpc_test::ForwardRequestPB &req, ::yb::rpc_test::ForwardResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Forward");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kForward)), req, resp, controller);

}

void CalculatorServiceProxy::ForwardAsync(

    const ::yb::rpc_test::ForwardRequestPB &req, ::yb::rpc_test::ForwardResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Forward");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kForward)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Lightweight(

    const ::yb::rpc_test::LightweightRequestPB &req, ::yb::rpc_test::LightweightResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Lightweight");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kLightweight)), req, resp, controller);

}

void CalculatorServiceProxy::LightweightAsync(

    const ::yb::rpc_test::LightweightRequestPB &req, ::yb::rpc_test::LightweightResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Lightweight");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kLightweight)), req, resp, controller, std::move(callback));

}

::yb::Status CalculatorServiceProxy::Trivial(

    const ::yb::rpc_test::TrivialRequestPB &req, ::yb::rpc_test::TrivialResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Trivial");

  return proxy().SyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kTrivial)), req, resp, controller);

}

void CalculatorServiceProxy::TrivialAsync(

    const ::yb::rpc_test::TrivialRequestPB &req, ::yb::rpc_test::TrivialResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Trivial");

  proxy().AsyncRequest(

      &method, metrics<11>(static_cast<size_t>(CalculatorServiceRpcMethodIndexes::kTrivial)), req, resp, controller, std::move(callback));

}

AbacusServiceProxy::AbacusServiceProxy(

    ::yb::rpc::ProxyCache* cache, const ::yb::HostPort& remote,

    const ::yb::rpc::Protocol* protocol,

    const ::yb::MonoDelta& resolve_cache_timeout)

    : ProxyBase(kFullAbacusServiceName, &CreateAbacusServiceMetrics,

                cache, remote, protocol, resolve_cache_timeout) {}

::yb::Status AbacusServiceProxy::Concat(

    const ::yb::rpc_test::ConcatRequestPB &req, ::yb::rpc_test::ConcatResponsePB *resp, ::yb::rpc::RpcController *controller) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Concat");

  return proxy().SyncRequest(

      &method, metrics<1>(static_cast<size_t>(AbacusServiceRpcMethodIndexes::kConcat)), req, resp, controller);

}

void AbacusServiceProxy::ConcatAsync(

    const ::yb::rpc_test::ConcatRequestPB &req, ::yb::rpc_test::ConcatResponsePB *resp, ::yb::rpc::RpcController *controller,

    ::yb::rpc::ResponseCallback callback) const {

  static ::yb::rpc::RemoteMethod method("yb.rpc_test.CalculatorService", "Concat");

  proxy().AsyncRequest(

      &method, metrics<1>(static_cast<size_t>(AbacusServiceRpcMethodIndexes::kConcat)), req, resp, controller, std::move(callback));

}

} // namespace rpc_test

} // namespace yb