This converts the Client functions to a C++ class. It includes a couple infrastructure things needed for the conversion

class Handle

This is an RAII wrapper around the rclpy_handle_t type. This class can be deleted as soon as all types are no longer using rclpy_handle_t. When constructed it increments the handle's reference to block destruction, and when destructed it decrements the reference. This allows the Client to keep a node alive, so a Client won't be destructed after a node.

class Destroyable

While refactoring I found while std::shared_ptr<> solves the destruction order issue, there's still a need to block destruction of an object while it's in use. This class implements that very similarly to how it's done for rclpy_handle_t types - though I did choose to make a design change.

When destruction is requested on an rclpy_handle_t, new threads are allowed to use it as long as there is another thread using it. I didn't like that it meant two very fast threads using it back and forth (with overlap in their use) could block destruction forever. I chose to make Destroyable block new use of itself after destruction is requested, so it gets destroyed as soon as the current uses of it finish.

class Client

This is the conversion to a Client class. It inherits from Destroyable and overrides destroy() to allow early destruction. It keeps a Handle instance to the node to prevent it from being destructed before the client. Once a Node class is created, that type will become std::shared_ptr<rcl_node_t> instead.

When ~Client() is called, the destruction order between rcl_node_t and rclpy_client_t is guaranteed by the std::shared_ptr<rcl_client_t> being after node_handle_ in the class definition. When Client::destroy() is called, the destruction order is guaranteed by releasing the std::shared_ptr<rcl_client_t> before releasing the std::shared_ptr<Handle> node_handle_.