Class GenericClient

Defined in File generic_client.hpp

Nested Relationships

Nested Types

Struct GenericClient::FutureAndRequestId

Inheritance Relationships

Base Type

public rclcpp::ClientBase (Class ClientBase)

Class Documentation

class GenericClient : public rclcpp::ClientBase 

Public Types

using Request = void*

using Response = void*

using SharedResponse = std::shared_ptr<void>

using Promise = std::promise<SharedResponse>

using SharedPromise = std::shared_ptr<Promise>

using Future = std::future<SharedResponse>

using SharedFuture = std::shared_future<SharedResponse>

Public Functions

GenericClient(rclcpp::node_interfaces::NodeBaseInterface *node_base, rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph, const std::string &service_name, const std::string &service_type, rcl_client_options_t &client_options)

virtual SharedResponse create_response() override

virtual std::shared_ptr<rmw_request_id_t> create_request_header() override

virtual void handle_response(std::shared_ptr<rmw_request_id_t> request_header, std::shared_ptr<void> response) override

FutureAndRequestId async_send_request(const Request request)

Send a request to the service server.

This method returns a FutureAndRequestId instance that can be passed to Executor::spin_until_future_complete() to wait until it has been completed.

If the future never completes, e.g. the call to Executor::spin_until_future_complete() times out, GenericClient::remove_pending_request() must be called to clean the client internal state. Not doing so will make the Client instance to use more memory each time a response is not received from the service server.

auto future = client->async_send_request(my_request);
if (
  rclcpp::FutureReturnCode::TIMEOUT ==
  executor->spin_until_future_complete(future, timeout))
{
  client->remove_pending_request(future);
  // handle timeout
} else {
  handle_response(future.get());
}

Parameters:: request – [in] request to be send.
Returns:: a FutureAndRequestId instance.

template<typename AllocatorT = std::allocator<int64_t>> inline size_t prune_requests_older_than(std::chrono::time_point<std::chrono::system_clock> time_point, std::vector<int64_t, AllocatorT> *pruned_requests = nullptr)

Clean all pending requests older than a time_point.

Parameters:

time_point – [in] Requests that were sent before this point are going to be removed.
pruned_requests – [inout] Removed requests id will be pushed to the vector if a pointer is provided.

Returns:

number of pending requests that were removed.

size_t prune_pending_requests()

bool remove_pending_request(int64_t request_id)

inline bool take_response(Response response_out, rmw_request_id_t &request_header_out)

Take the next response for this client.