node_ros_pubsub_wrapper.hpp

Go to the documentation of this file.

#ifndef NODE_ROS_PUBSUB_WRAPPER_H
#define NODE_ROS_PUBSUB_WRAPPER_H
 
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wunused-variable"
 
#include "rclcpp/rclcpp.hpp"
#include <galaxis/messages.hpp>
#include <galaxis/Errors.hpp>
#include <galaxis/utilities.hpp>
#include <string>
#include "rmw/types.h"
 
namespace galaxis {
  namespace ros {
    namespace {
      const char* TOPIC_MEASUREMENT       = "measurements";
      const char* TOPIC_MOTION            = "motion";
      const char* TOPIC_LIGHTS            = "lights";
      const char* TOPIC_SERVICESTATE      = "servicestate";
      const char* TOPIC_PATHPOLYNOM       = "pathpolynom";
      const char* TOPIC_SETTINGSVALUES    = "settingsvalues";
      const char* TOPIC_DEBUGPOLYNOM      = "debugpolynom";
      const char* TOPIC_IDENTIFICATION    = "identification";
      const char* TOPIC_POINTSLIST        = "pointslist";
      const char* TOPIC_MARVELMINDCONTROL = "marvelmindcontrol";
      const char* TOPIC_DEBUGCONTROLLER   = "debugcontroller";
      const char* TOPIC_MARVELMIND        = "marvelmind";
      const char* TOPIC_HEARTBEAT         = "heartbeat";
      const char* TOPIC_OBJECTVECTOR      = "objects_vector";
      const char* TOPIC_BUTTON_STATE      = "buttonState";
      const char* TOPIC_DEBUGMAPDATA      = "/galaxis/map/debug/data";
      const char* TOPIC_CONTROLLERREF     = "/galaxis/controller/reference";
      const char* TOPIC_OBSTACLES         = "/galaxis/objectdetection/obstacles";
      const char* TOPIC_CAR_POSE          = "/galaxis/ap/carpose";
      const char* TOPIC_SYSTEM_SETTINGS   = "/galaxis/systemsettings";
      const char* TOPIC_QR_CODE_DETECTTION= "/galaxis/qrcodedetection/state";
      const char* TOPIC_STOP_LINE         = "/galaxis/stopline";
      const char* TOPIC_PARKING_STATE     = "/galaxis/parking/state";
      const char* TOPIC_PARKING_OPERATION = "/galaxis/ap/parkingoperation";
      
 
      // separate Topics (without functions)
      const char* TOPIC_CAMERA_RAW = "/galaxis/camera_raw";
      const char* TOPIC_CAMERA_RAW_BE = "/galaxis/camera_raw/best_effort";
      const char* TOPIC_CAMERA_COMPRESSED = "/galaxis/camera_compressed";
      const char* TOPIC_VCI_LANE_IMAGE    = "/galaxis/laneimage";
      const char* TOPIC_VCI_LANE_IMAGE_SIMULATION = "/galaxis/simulation/laneimage";
      const char* TOPIC_AP_DATA_IMAGE_DEBUG = "/galaxis/debug/ap/map/lanes";
      const char* TOPIC_AP_FULL_MAP_DATA_IMAGE_DEBUG = "/galaxis/debug/ap/map/full";
      const char* TOPIC_AP_DRIVE_LANE_DEBUG = "/galaxis/debug/ap/drivelanes";
      const char* TOPIC_AP_CONTROLLER_DATA_DEBUG = "/galaxis/debug/controller/trajectory";
      const char* TOPIC_STOP_LINE_IMAGE = "/galaxis/stoplineimage";
      const char* TOPIC_START_LINE_IMAGE = "/galaxis/startline/debug";
      const char* TOPIC_STOP_LINE_IMAGE_RIGHT = "/galaxis/stoplineimageright";
      const char* TOPIC_STOP_LINE_IMAGE_LEFT = "/galaxis/stoplineimageleft";
      const char* TOPIC_STOP_LINE_IMAGE_RIGHT_BORDER = "/galaxis/stoplineimagerightborder";
 
      enum QoS_Profile_t {
        QOS_DEFAULT     = 0,
        QOS_BEST_EFFORT = 1,
        QOS_RELIABLE    = 2
      };
 
      static const rmw_qos_profile_t qos_profile_default = {
        RMW_QOS_POLICY_HISTORY_KEEP_LAST,
        1,
        RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT,
        RMW_QOS_POLICY_DURABILITY_VOLATILE,
        RMW_QOS_DEADLINE_DEFAULT,
        RMW_QOS_LIFESPAN_DEFAULT,
        RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT,
        RMW_QOS_LIVELINESS_LEASE_DURATION_DEFAULT,
        false
      };
 
      static const rmw_qos_profile_t qos_profile_reliable = {
        RMW_QOS_POLICY_HISTORY_KEEP_LAST,
        1,
        RMW_QOS_POLICY_RELIABILITY_RELIABLE,
        RMW_QOS_POLICY_DURABILITY_VOLATILE,
        RMW_QOS_DEADLINE_DEFAULT,
        RMW_QOS_LIFESPAN_DEFAULT,
        RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT,
        RMW_QOS_LIVELINESS_LEASE_DURATION_DEFAULT,
        false
      };
 
      rclcpp::QoS get_qos_profile(QoS_Profile_t p_qos_settings) {
        rclcpp::QoS qos_params = rclcpp::QoS(rclcpp::KeepLast(1), qos_profile_default);
 
        switch(p_qos_settings) {
          case QOS_BEST_EFFORT:
            qos_params = rclcpp::QoS(rclcpp::KeepLast(1), qos_profile_default);
            break;
          case QOS_RELIABLE:
            qos_params = rclcpp::QoS(rclcpp::KeepLast(1), qos_profile_reliable);
            break;
          default:
            //TODO galaxis::log("Wrong qos setting in get_qos_profile, using QOS_DEFAULT setting");
            break;
        }
 
        return qos_params;
      }
 
      // Subscriber Measurements
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<MeasurementsType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_MEASUREMENT;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<MeasurementsType>(topic, qos_params, p_bind);
      }
 
      // Publisher Measurements
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<MeasurementsType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_MEASUREMENT;
        p_pubSPtr              = p_nodePtr->create_publisher<MeasurementsType>(topic, qos_params);
      }
 
      // Subscriber ControlMotion
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ControlMotionType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_MOTION;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<ControlMotionType>(topic, qos_params, p_bind);
      }
 
      // Publisher ControlMotion
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ControlMotionType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_MOTION;
        p_pubSPtr              = p_nodePtr->create_publisher<ControlMotionType>(topic, qos_params);
      }
 
      // Subscriber Pathpolynom
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<PathpolynomType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_PATHPOLYNOM;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<PathpolynomType>(topic, qos_params, p_bind);
      }
 
      // Publisher Pathpolynom
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<PathpolynomType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_PATHPOLYNOM;
        p_pubSPtr              = p_nodePtr->create_publisher<PathpolynomType>(topic, qos_params);
      }
 
      // Subscriber DebugPolynom
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<DebugPolynomType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_DEBUGPOLYNOM;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<DebugPolynomType>(topic, qos_params, p_bind);
      }
 
      // Publisher DebugPolynom
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<DebugPolynomType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_DEBUGPOLYNOM;
        p_pubSPtr              = p_nodePtr->create_publisher<DebugPolynomType>(topic, qos_params);
      }
 
      // Subscriber Settingsvalues
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<SettingsValuesType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_SETTINGSVALUES;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<SettingsValuesType>(topic, qos_params, p_bind);
      }
 
      // Publisher Settingsvalues
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<SettingsValuesType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_SETTINGSVALUES;
        p_pubSPtr              = p_nodePtr->create_publisher<SettingsValuesType>(topic, qos_params);
      }
 
      // Subscriber ServiceState
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ServiceStateType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_SERVICESTATE;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ServiceStateType>(topic, qos_params, p_bind);
      }
 
      // Publisher servicestate
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ServiceStateType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_SERVICESTATE;
        p_pubSPtr              = p_nodePtr->create_publisher<ServiceStateType>(topic, qos_params);
      }
 
      // Subscriber Identification
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<IdentificationType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_IDENTIFICATION;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<IdentificationType>(topic, qos_params, p_bind);
      }
 
      // Publisher Identification
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<IdentificationType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_IDENTIFICATION;
        p_pubSPtr              = p_nodePtr->create_publisher<IdentificationType>(topic, qos_params);
      }
 
      //Subscriber PointsList
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<PointsListType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_POINTSLIST;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<PointsListType>(topic, qos_params, p_bind);
      }
 
      // Publisher PointsList
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<PointsListType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_POINTSLIST;
        p_pubSPtr              = p_nodePtr->create_publisher<PointsListType>(topic, qos_params);
      }
 
      //Subscriber MarvelMindControl
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<MarvelMindControlType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
 
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_MARVELMINDCONTROL;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<MarvelMindControlType>(topic, qos_params, p_bind);
      }
 
      // Publisher MarvelMindControl
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<MarvelMindControlType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_MARVELMINDCONTROL;
        p_pubSPtr              = p_nodePtr->create_publisher<MarvelMindControlType>(topic, qos_params);
      }
 
      //Subscriber ControllerSetReference
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ControllerReferenceType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_CONTROLLERREF;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ControllerReferenceType>(topic, qos_params, p_bind);
      }
 
      // Publisher ControllerSetReference
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ControllerReferenceType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_CONTROLLERREF;
        p_pubSPtr              = p_nodePtr->create_publisher<ControllerReferenceType>(topic, qos_params);
      }
 
      //Subscriber GPSData
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<GPSDataType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_MARVELMIND;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<GPSDataType>(topic, qos_params, p_bind);
      }
 
      // Publisher GPSData
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<GPSDataType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_MARVELMIND;
        p_pubSPtr              = p_nodePtr->create_publisher<GPSDataType>(topic, qos_params);
      }
 
      //Subscriber ControlLights
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ControlLightsType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_LIGHTS;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<ControlLightsType>(topic, qos_params, p_bind);
      }
 
      // Publisher ControlLights
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ControlLightsType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_LIGHTS;
        p_pubSPtr              = p_nodePtr->create_publisher<ControlLightsType>(topic, qos_params);
      }
 
      //Subscriber DebugControllerType
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<DebugControllerType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_DEBUGCONTROLLER;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<DebugControllerType>(topic, qos_params, p_bind);
      }
 
      // Publisher DebugControllerType
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<DebugControllerType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_DEBUGCONTROLLER;
        p_pubSPtr              = p_nodePtr->create_publisher<DebugControllerType>(topic, qos_params);
      }
 
 
      //Subscriber HeartbeatMessage
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<HeartbeatMessageType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_HEARTBEAT;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<HeartbeatMessageType>(topic, qos_params, p_bind);
      }
 
      // Publisher HeartbeatMessage
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<HeartbeatMessageType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_HEARTBEAT;
        p_pubSPtr              = p_nodePtr->create_publisher<HeartbeatMessageType>(topic, qos_params);
      }
 
      //Subscriber ObjectVectorMessageType
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ObjectVectorMessageType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_OBJECTVECTOR;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<ObjectVectorMessageType>(topic, qos_params, p_bind);
      }
 
      // Publisher ObjectVectorMessageType
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ObjectVectorMessageType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_OBJECTVECTOR;
        p_pubSPtr              = p_nodePtr->create_publisher<ObjectVectorMessageType>(topic, qos_params);
      }
 
      //Subscriber ButtonStateMessageType
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ButtonStateMessageType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_BUTTON_STATE;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ButtonStateMessageType>(topic, qos_params, p_bind);
      }
 
      // Publisher ButtonStateMessageType
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ButtonStateMessageType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_BUTTON_STATE;
        p_pubSPtr              = p_nodePtr->create_publisher<ButtonStateMessageType>(topic, qos_params);
      }
 
      //Subscriber Obstacles
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ObstacleListType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_OBSTACLES;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ObstacleListType>(topic, qos_params, p_bind);
      }
 
      // Publisher Obstacles
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ObstacleListType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_OBSTACLES;
        p_pubSPtr              = p_nodePtr->create_publisher<ObstacleListType>(topic, qos_params);
      }
 
      //Subscriber CAR_POSE_ESTIMATED
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<CarPoseEstimatedType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_CAR_POSE;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
 
        p_subSPtr = p_nodePtr->create_subscription<CarPoseEstimatedType>(topic, qos_params, p_bind);
      }
 
      // Publisher CAR_POSE_ESTIMATED
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<CarPoseEstimatedType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_BEST_EFFORT);
        std::string topic      = TOPIC_CAR_POSE;
        p_pubSPtr              = p_nodePtr->create_publisher<CarPoseEstimatedType>(topic, qos_params);
      }
 
      //Subscriber SYSTEM_SETTINGS
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<SystemSettingsType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_SYSTEM_SETTINGS;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<SystemSettingsType>(topic, qos_params, p_bind);
      }
 
      // Publisher SYSTEM_SETTINGS
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<SystemSettingsType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_SYSTEM_SETTINGS;
        p_pubSPtr              = p_nodePtr->create_publisher<SystemSettingsType>(topic, qos_params);
      }
 
      //Subscriber STOP_LINE
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<StopLineType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_STOP_LINE;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<StopLineType>(topic, qos_params, p_bind);
      }
 
      // Publisher STOP_LINE
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<StopLineType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_STOP_LINE;
        p_pubSPtr              = p_nodePtr->create_publisher<StopLineType>(topic, qos_params);
      }
 
      //Subscriber QR Code Detection
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<QRCodeDetectType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_QR_CODE_DETECTTION;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<QRCodeDetectType>(topic, qos_params, p_bind);
      }
 
      // Publisher QR Code Detection
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<QRCodeDetectType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_QR_CODE_DETECTTION;
        p_pubSPtr              = p_nodePtr->create_publisher<QRCodeDetectType>(topic, qos_params);
      }
      
      //Subscriber parking
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ParkingStateType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_PARKING_STATE;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ParkingStateType>(topic, qos_params, p_bind);
      }
 
      // Publisher parking state
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ParkingStateType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_PARKING_STATE;
        p_pubSPtr              = p_nodePtr->create_publisher<ParkingStateType>(topic, qos_params);
      }
 
      //Subscriber parking op
      template <typename CallbackT>
      void create_subscription(
          rclcpp::Node* p_nodePtr,
          rclcpp::Subscription<ParkingOperationType>::SharedPtr& p_subSPtr,
          CallbackT&& p_bind) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        std::string topic = TOPIC_PARKING_OPERATION;
 
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
 
        p_subSPtr = p_nodePtr->create_subscription<ParkingOperationType>(topic, qos_params, p_bind);
      }
 
      // Publisher parking op
      void create_publisher(rclcpp::Node* p_nodePtr, rclcpp::Publisher<ParkingOperationType>::SharedPtr& p_pubSPtr) {
        if(p_nodePtr == nullptr) {
          throw galaxis::Errors::POINTER_ERROR();
        }
        rclcpp::QoS qos_params = get_qos_profile(QOS_RELIABLE);
        std::string topic      = TOPIC_PARKING_OPERATION;
        p_pubSPtr              = p_nodePtr->create_publisher<ParkingOperationType>(topic, qos_params);
      }
 
    } // namespace
  } // namespace ros
} // namespace galaxis
 
#pragma GCC diagnostic pop
#pragma GCC diagnostic pop
 
#endif //NODE_ROS_PUBSUB_WRAPPER_H