ros::Node as static member - any better ideas

edit

Situation

I'm part of a larger team working with robots and ROS. My current project is to create easy-to-use libraries for navigation and other things from existing code in our repositories. Over time, many people in our lab have implemented the same function a bit differently and I want to unify and streamline these implementations in one single library.

Now, the library has to publish on and subscribe to multiple topics and therefore it requires a ros::NodeHandle to work with. So far my library is purely static (i.e. no classes are instantiated, static members are called directly). This has the advantage, that my library has global awareness and I can prevent many user/robot/real-time errors. Furthermore, subscribing to topics takes a bit of time and messages can be missed. This is another argument for static members, since I can have a static subscriber and initialize it when the node is created.

Problem

When I have a ros::NodeHandle as a static class member, it is initialized right on program-launch, before ros::init() can be called. This returns an error as soon as the rosnode using my library is launched - makes sense.

My Solution

I thought I could perform lazy-initialization of my static members, including subscribers, publishers and the nodehandle. In order to achieve this, all ros objects are static pointers, that I initialize right before first use. My classes all look something like this.

// Class used to actually send various commands to robot
class RobotHelper {
public:
  static int sendCommand(...);

private:
  static void initialize();
  static void callback(const my_msgs::Telemetry &msg);

  static bool initialized;
  static std::unique_ptr<ros::NodeHandle> nh_ptr_;
  static std::unique_ptr<ros::Publisher> cmd_pub_ptr_;
  static std::unique_ptr<ros::Subscriber> telemetry_sub_ptr_;
};

int RobotHelper::sendCommand(...) {
  // Lazy-initialize the RobotHelper
  initialize();

  // Uses telemetry and other things to make sure nothing dangeorus happens when
  // command is sent
  // Also uses telemetry to make sure the robot accepted the command, so
  // we don't have to worry about that later
  // ...
  // ...

  return 0;
}

void RobotHelper::initialize() {
  if (initialized) {
    // nothing to do, already initialized
    return;
  }

  // Initialize all the static ros members
  nh_ptr_ = std::unique_ptr<ros::NodeHandle>(new ros::NodeHandle);

  // create subscriber
  telemetry_sub_ptr_ = std::unique_ptr<ros::Subscriber>(new ros::Subscriber);
  *telemetry_sub_ptr_ =
      nh_ptr_->subscribe("telemetry", 10, &RobotHelper::callback);

  while (ros::ok()) {
    // Wait for crucial telemetry subscriber to receive messages
    // NOTE: Here, time is wasted waiting. I don't want to do that too often 
    // ...
  }

  // Create publisher
  some_pub_ptr_ = std::unique_ptr<ros::Publisher>(new ros::Publisher);
  *some_pub_ptr_ = nh_ptr_->advertise<std_msgs::Bool>("commands", 10);
}


class PathNavigation : public NavigationBase {
public:
  // For every navigation action I create its own object
  PathNavigation(double x, double y, double z);

  // Actually perform the navigation
  // This has to be called periodically until navigation is complete.
  // In between I could handle obstacle avoidance or perform other actions.
  // Hence this should be a non-blocking function and called periodically
  int execute(bool &navigation_completed);

private:
  static std::unique_ptr<ros::NodeHandle> nh_ptr_;
  static std::unique_ptr<ros::Publisher> some_pub_ptr_;
};

PathNavigation::PathNavigation(double x, double y, double z) {
  // In the constructor I ...