apollo::cyber::Client< Request, Response > 模板类 参考

Client get Response from a responding Service by sending a Request 更多...

#include <client.h>

类 apollo::cyber::Client< Request, Response > 继承关系图:

apollo::cyber::Client< Request, Response > 的协作图:

Public 类型
using	SharedRequest = typename std::shared_ptr< Request >
using	SharedResponse = typename std::shared_ptr< Response >
using	Promise = std::promise< SharedResponse >
using	SharedPromise = std::shared_ptr< Promise >
using	SharedFuture = std::shared_future< SharedResponse >
using	CallbackType = std::function< void(SharedFuture)>

Public 成员函数
	Client (const std::string &node_name, const std::string &service_name)
	Construct a new Client object
	Client ()=delete
	forbid Constructing a new Client object with empty params
virtual	~Client ()
bool	Init ()
	Init the Client
SharedResponse	SendRequest (SharedRequest request, const std::chrono::seconds &timeout_s=std::chrono::seconds(5))
	Request the Service with a shared ptr Request type
SharedResponse	SendRequest (const Request &request, const std::chrono::seconds &timeout_s=std::chrono::seconds(5))
	Request the Service with a Request object
SharedFuture	AsyncSendRequest (SharedRequest request)
	Send Request shared ptr asynchronously
SharedFuture	AsyncSendRequest (const Request &request)
	Send Request object asynchronously
SharedFuture	AsyncSendRequest (SharedRequest request, CallbackType &&cb)
	Send Request shared ptr asynchronously and invoke cb after we get response
bool	ServiceIsReady () const
	Is the Service is ready?
void	Destroy ()
	destroy this Client
template<typename RatioT = std::milli>
bool	WaitForService (std::chrono::duration< int64_t, RatioT > timeout=std::chrono::duration< int64_t, RatioT >(-1))
	wait for the connection with the Service established
Public 成员函数 继承自 apollo::cyber::ClientBase
	ClientBase (const std::string &service_name)
	Construct a new Client Base object
virtual	~ClientBase ()
const std::string &	ServiceName () const
	Get the service name

额外继承的成员函数
Protected 成员函数 继承自 apollo::cyber::ClientBase
bool	WaitForServiceNanoseconds (std::chrono::nanoseconds time_out)
Protected 属性 继承自 apollo::cyber::ClientBase
std::string	service_name_

详细描述

template<typename Request, typename Response>
class apollo::cyber::Client< Request, Response >

Client get Response from a responding Service by sending a Request

模板参数

Request	the Service request type
Response	the Service response type

警告

One Client can only request one Service

在文件 client.h 第 47 行定义.

成员类型定义说明

CallbackType

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::CallbackType = std::function<void(SharedFuture)>

在文件 client.h 第 54 行定义.

Promise

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::Promise = std::promise<SharedResponse>

在文件 client.h 第 51 行定义.

SharedFuture

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::SharedFuture = std::shared_future<SharedResponse>

在文件 client.h 第 53 行定义.

SharedPromise

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::SharedPromise = std::shared_ptr<Promise>

在文件 client.h 第 52 行定义.

SharedRequest

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::SharedRequest = typename std::shared_ptr<Request>

在文件 client.h 第 49 行定义.

SharedResponse

template<typename Request , typename Response >

using apollo::cyber::Client< Request, Response >::SharedResponse = typename std::shared_ptr<Response>

在文件 client.h 第 50 行定义.

构造及析构函数说明

Client() [1/2]

template<typename Request , typename Response >

apollo::cyber::Client< Request, Response >::Client ( const std::string &  node_name, const std::string &  service_name  )

inline

Construct a new Client object

参数

node_name	used to fill RoleAttribute
service_name	service name the Client can request

在文件 client.h 第 62 行定义.

      : ClientBase(service_name),
        node_name_(node_name),
        request_channel_(service_name + SRV_CHANNEL_REQ_SUFFIX),
        response_channel_(service_name + SRV_CHANNEL_RES_SUFFIX),
        sequence_number_(0) {}

Client() [2/2]

template<typename Request , typename Response >

apollo::cyber::Client< Request, Response >::Client ( )

delete

forbid Constructing a new Client object with empty params

~Client()

template<typename Request , typename Response >

virtual apollo::cyber::Client< Request, Response >::~Client ( )

inlinevirtual

在文件 client.h 第 74 行定义.

{}

成员函数说明

AsyncSendRequest() [1/3]

template<typename Request , typename Response >

Client< Request, Response >::SharedFuture Client::AsyncSendRequest

(

const Request &

request

)

Send Request object asynchronously

在文件 client.h 第 255 行定义.

                                                                  {
  auto request_ptr = std::make_shared<const Request>(request);
  return AsyncSendRequest(request_ptr);
}

AsyncSendRequest() [2/3]

template<typename Request , typename Response >

Client< Request, Response >::SharedFuture Client::AsyncSendRequest

(

SharedRequest

request

)

Send Request shared ptr asynchronously

在文件 client.h 第 262 行定义.

                                                                 {
  return AsyncSendRequest(request, [](SharedFuture) {});
}

AsyncSendRequest() [3/3]

template<typename Request , typename Response >

Client< Request, Response >::SharedFuture Client::AsyncSendRequest	(	SharedRequest	request,
		CallbackType &&	cb
	)

Send Request shared ptr asynchronously and invoke cb after we get response

参数

request	Request shared ptr
cb	callback function after we get response

返回

SharedFuture a std::future shared ptr

在文件 client.h 第 268 行定义.

                                                               {
  if (IsInit()) {
    std::lock_guard<std::mutex> lock(pending_requests_mutex_);
    sequence_number_++;
    transport::MessageInfo info(writer_id_, sequence_number_, writer_id_);
    request_transmitter_->Transmit(request, info);
    SharedPromise call_promise = std::make_shared<Promise>();
    SharedFuture f(call_promise->get_future());
    pending_requests_[info.seq_num()] =
        std::make_tuple(call_promise, std::forward<CallbackType>(cb), f);
    return f;
  } else {
    return std::shared_future<std::shared_ptr<Response>>();
  }
}

Destroy()

template<typename Request , typename Response >

void Client::Destroy ( )

virtual

destroy this Client

实现了 apollo::cyber::ClientBase.

在文件 client.h 第 178 行定义.

{}

Init()

template<typename Request , typename Response >

bool Client::Init

(

)

Init the Client

返回

true if init successfully

false if init failed

在文件 client.h 第 181 行定义.

                                     {
  proto::RoleAttributes role;
  role.set_node_name(node_name_);
  role.set_channel_name(request_channel_);
  auto channel_id = common::GlobalData::RegisterChannel(request_channel_);
  role.set_channel_id(channel_id);
  role.mutable_qos_profile()->CopyFrom(
      transport::QosProfileConf::QOS_PROFILE_SERVICES_DEFAULT);
  auto transport = transport::Transport::Instance();
  request_transmitter_ =
      transport->CreateTransmitter<Request>(role, proto::OptionalMode::RTPS);
  if (request_transmitter_ == nullptr) {
    AERROR << "Create request pub failed.";
    return false;
  }
  writer_id_ = request_transmitter_->id();
 
  response_callback_ =
      std::bind(&Client<Request, Response>::HandleResponse, this,
                std::placeholders::_1, std::placeholders::_2);
 
  role.set_channel_name(response_channel_);
  channel_id = common::GlobalData::RegisterChannel(response_channel_);
  role.set_channel_id(channel_id);
  response_receiver_ = transport->CreateReceiver<Response>(
      role,
      [=](const std::shared_ptr<Response>& response,
          const transport::MessageInfo& message_info,
          const proto::RoleAttributes& reader_attr) {
        (void)message_info;
        (void)reader_attr;
        response_callback_(response, message_info);
      },
      proto::OptionalMode::RTPS);
  if (response_receiver_ == nullptr) {
    AERROR << "Create response sub failed.";
    request_transmitter_.reset();
    return false;
  }
  return true;
}

SendRequest() [1/2]

template<typename Request , typename Response >

Client< Request, Response >::SharedResponse Client::SendRequest	(	const Request &	request,
		const std::chrono::seconds &	timeout_s = std::chrono::seconds(5)
	)

Request the Service with a Request object

参数

request	Request object
timeout_s	request timeout, if timeout, response will be empty

返回

SharedResponse result of this request

在文件 client.h 第 244 行定义.

                                                                          {
  if (!IsInit()) {
    return nullptr;
  }
  auto request_ptr = std::make_shared<const Request>(request);
  return SendRequest(request_ptr, timeout_s);
}

SendRequest() [2/2]

template<typename Request , typename Response >

Client< Request, Response >::SharedResponse Client::SendRequest	(	SharedRequest	request,
		const std::chrono::seconds &	timeout_s = std::chrono::seconds(5)
	)

Request the Service with a shared ptr Request type

参数

request	shared ptr of Request type
timeout_s	request timeout, if timeout, response will be empty

返回

SharedResponse result of this request

在文件 client.h 第 225 行定义.

                                                                          {
  if (!IsInit()) {
    return nullptr;
  }
  auto future = AsyncSendRequest(request);
  if (!future.valid()) {
    return nullptr;
  }
  auto status = future.wait_for(timeout_s);
  if (status == std::future_status::ready) {
    return future.get();
  } else {
    return nullptr;
  }
}

ServiceIsReady()

template<typename Request , typename Response >

bool Client::ServiceIsReady ( ) const

virtual

Is the Service is ready?

实现了 apollo::cyber::ClientBase.

在文件 client.h 第 286 行定义.

                                                     {
  return true;
}

WaitForService()

template<typename Request , typename Response >

template<typename RatioT = std::milli>

bool apollo::cyber::Client< Request, Response >::WaitForService ( std::chrono::duration< int64_t, RatioT >  timeout = std::chrono::duration<int64_t, RatioT>(-1) )

inline

wait for the connection with the Service established

模板参数

RatioT

timeout unit, default is std::milli

参数

timeout

wait time in unit of RatioT

返回

true if the connection established

false if timeout

在文件 client.h 第 145 行定义.

                                                                  {
    return WaitForServiceNanoseconds(
        std::chrono::duration_cast<std::chrono::nanoseconds>(timeout));
  }

---

该类的文档由以下文件生成:

• cyber/service/client.h