feature/server-client-protocol-version-2

app/mon/mon_gui/src/widgets/ecalmon_tree_widget/service_widget.cpp

@@ -114,7 +114,7 @@ void ServiceWidget::autoSizeColumns()
   example_service_pb.set_uname("eCALRPCService____");
   example_service_pb.set_pid(999999);
   example_service_pb.set_sname("eCALRPCService____");
-  example_service_pb.set_tcp_port(999999);
+  example_service_pb.set_tcp_port_v1(999999);
 
   eCAL::pb::Method* method = example_service_pb.mutable_methods()->Add();
   method->set_mname("ShutdownProcessName____");

app/mon/mon_gui/src/widgets/models/service_tree_item.cpp

@@ -78,7 +78,7 @@ QVariant ServiceTreeItem::data(Columns column, Qt::ItemDataRole role) const
     }
     else if (column == Columns::TCP_PORT)
     {
-      return service_.tcp_port();
+      return service_.tcp_port_v1();
     }
     else if (column == Columns::MNAME)
     {

app/mon/mon_tui/src/model/monitor.hpp

@@ -266,7 +266,7 @@ class MonitorModel
       service.process_name = std::move(*s.mutable_pname());
       service.unit_name = std::move(*s.mutable_uname());
       service.registration_clock = s.rclock();
-      service.tcp_port = s.tcp_port();
+      service.tcp_port = s.tcp_port_v1();
       for(auto &m: *s.mutable_methods())
       {
         auto &method = service.methods.emplace_back();

ecal/core/include/ecal/ecal_callback.h

@@ -36,87 +36,66 @@ namespace eCAL
   **/
   struct SReceiveCallbackData
   {
-    SReceiveCallbackData()
-    {
-      buf   = nullptr;
-      size  = 0;
-      id    = 0;
-      time  = 0;
-      clock = 0;
-    };
-    void*     buf;    //!< payload buffer
-    long      size;   //!< payload buffer size
-    long long id;     //!< publisher id (SetId())
-    long long time;   //!< publisher send time in µs
-    long long clock;  //!< publisher send clock
+    void*     buf   = nullptr;  //!< payload buffer
+    long      size  = 0;        //!< payload buffer size
+    long long id    = 0;        //!< publisher id (SetId())
+    long long time  = 0;        //!< publisher send time in µs
+    long long clock = 0;        //!< publisher send clock
   };
 
   /**
    * @brief eCAL publisher event callback struct.
   **/
   struct SPubEventCallbackData
   {
-    SPubEventCallbackData()
-    {
-      type  = pub_event_none;
-      time  = 0;
-      clock = 0;
-    };
-    eCAL_Publisher_Event type;    //!< publisher event type
-    long long            time;    //!< publisher event time in µs
-    long long            clock;   //!< publisher event clock
-    std::string          tid;     //!< topic id of the of the connected subscriber              (for pub_event_update_connection only)
-    std::string          ttype;   //!< topic type information of the connected subscriber       (for pub_event_update_connection only)
-    std::string          tdesc;   //!< topic descriptor information of the connected subscriber (for pub_event_update_connection only)
+    eCAL_Publisher_Event type  = pub_event_none;  //!< publisher event type
+    long long            time  = 0;               //!< publisher event time in µs
+    long long            clock = 0;               //!< publisher event clock
+    std::string          tid;                     //!< topic id of the of the connected subscriber              (for pub_event_update_connection only)
+    std::string          ttype;                   //!< topic type information of the connected subscriber       (for pub_event_update_connection only)
+    std::string          tdesc;                   //!< topic descriptor information of the connected subscriber (for pub_event_update_connection only)
   };
 
   /**
    * @brief eCAL subscriber event callback struct.
   **/
   struct SSubEventCallbackData
   {
-    SSubEventCallbackData()
-    {
-      type  = sub_event_none;
-      time  = 0;
-      clock = 0;
-    };
-    eCAL_Subscriber_Event type;   //!< subscriber event type
-    long long             time;   //!< subscriber event time in µs
-    long long             clock;  //!< subscriber event clock
-    std::string           tid;    //!< topic id of the of the connected publisher              (for sub_event_update_connection only)
-    std::string           ttype;  //!< topic type information of the connected publisher       (for sub_event_update_connection only)
-    std::string           tdesc;  //!< topic descriptor information of the connected publisher (for sub_event_update_connection only)
+    eCAL_Subscriber_Event type  = sub_event_none;  //!< subscriber event type
+    long long             time  = 0;               //!< subscriber event time in µs
+    long long             clock = 0;               //!< subscriber event clock
+    std::string           tid;                     //!< topic id of the of the connected publisher              (for sub_event_update_connection only)
+    std::string           ttype;                   //!< topic type information of the connected publisher       (for sub_event_update_connection only)
+    std::string           tdesc;                   //!< topic descriptor information of the connected publisher (for sub_event_update_connection only)
   };
 
   /**
    * @brief eCAL service attributes.
   **/
   struct SServiceAttr
   {
-    std::string    key;           //!< unique service key (internal)
-    std::string    hname;         //!< host name
-    std::string    pname;         //!< process name
-    std::string    uname;         //!< process unit name
-    std::string    sname;         //!< service name
-    std::string    sid;           //!< service id
-    int            pid = 0;       //!< process id
-    unsigned short tcp_port = 0;  //!< service tcp port
+    std::string    key;              //!< unique service key (internal)
+    std::string    hname;            //!< host name
+    std::string    pname;            //!< process name
+    std::string    uname;            //!< process unit name
+    std::string    sname;            //!< service name
+    std::string    sid;              //!< service id
+    int            pid         = 0;  //!< process id
+
+    // internal protocol specifics
+    unsigned int   version     = 0;  //!< service protocol version
+    unsigned short tcp_port_v0 = 0;  //!< service tcp port protocol version 0
+    unsigned short tcp_port_v1 = 0;  //!< service tcp port protocol version 1
   };
 
   /**
    * @brief eCAL client event callback struct.
   **/
   struct SClientEventCallbackData
   {
-    SClientEventCallbackData()
-    {
-      type = client_event_none;
-      time = 0;
-    };
-    eCAL_Client_Event type;  //!< event type
-    long long         time;  //!< event time in µs
-    SServiceAttr      attr;  //!< event related service attributes
+    eCAL_Client_Event type = client_event_none;  //!< event type
+    long long         time = 0;                  //!< event time in µs
+    SServiceAttr      attr;                      //!< event related service attributes
   };
 
   /**
@@ -131,20 +110,17 @@ namespace eCAL
     std::string    sname;         //!< service name
     std::string    sid;           //!< service id
     int            pid = 0;       //!< process id
+
+    unsigned int   version = 0;   //!< client version
   };
 
   /**
    * @brief eCAL server event callback struct.
   **/
   struct SServerEventCallbackData
   {
-    SServerEventCallbackData()
-    {
-      type = server_event_none;
-      time = 0;
-    };
-    eCAL_Server_Event type;  //!< event type
-    long long         time;  //!< event time in µs
+    eCAL_Server_Event type = server_event_none;  //!< event type
+    long long         time = 0;                  //!< event time in µs
   };
 
   /**
@@ -153,50 +129,50 @@ namespace eCAL
    * @param topic_name_  The topic name of the received message.
    * @param data_        Data struct containing payload, timestamp and publication clock.
   **/
-  typedef std::function<void(const char* topic_name_, const struct SReceiveCallbackData* data_)> ReceiveCallbackT;
+  using ReceiveCallbackT = std::function<void (const char *, const struct SReceiveCallbackData *)>;
 
   /**
    * @brief Timer callback function type.
   **/
-  typedef std::function<void(void)> TimerCallbackT;
+  using TimerCallbackT = std::function<void ()>;
 
   /**
    * @brief Registration callback type.
    *
    * @param sample_       The sample protocol buffer registration payload buffer.
    * @param sample_size_  The payload buffer size.
   **/
-  typedef std::function<void(const char* sample_, int sample_size_)> RegistrationCallbackT;
+  using RegistrationCallbackT = std::function<void (const char *, int)>;
 
   /**
    * @brief Publisher event callback function type.
    *
    * @param topic_name_  The topic name of the publisher that triggered the event.
-   * @param data_        Event callback data structure with the event specific informations.
+   * @param data_        Event callback data structure with the event specific information.
   **/
-  typedef std::function<void(const char* topic_name_, const struct SPubEventCallbackData* data_)> PubEventCallbackT;
+  using PubEventCallbackT = std::function<void (const char *, const struct SPubEventCallbackData *)>;
 
   /**
    * @brief Subscriber event callback function type.
    *
    * @param topic_name_  The topic name of the subscriber that triggered the event.
-   * @param data_        Event callback data structure with the event specific informations.
+   * @param data_        Event callback data structure with the event specific information.
   **/
-  typedef std::function<void(const char* topic_name_, const struct SSubEventCallbackData* data_)> SubEventCallbackT;
+  using SubEventCallbackT = std::function<void (const char *, const struct SSubEventCallbackData *)>;
 
   /**
    * @brief Client event callback function type.
    *
    * @param name_  The name of the connection that triggered the event.
-   * @param data_  Event callback data structure with the event specific informations.
+   * @param data_  Event callback data structure with the event specific information.
   **/
-  typedef std::function<void(const char* name_, const struct SClientEventCallbackData* data_)> ClientEventCallbackT;
+  using ClientEventCallbackT = std::function<void (const char *, const struct SClientEventCallbackData *)>;
 
   /**
    * @brief Server event callback function type.
    *
    * @param name_  The name of the connection that triggered the event.
-   * @param data_  Event callback data structure with the event specific informations.
+   * @param data_  Event callback data structure with the event specific information.
   **/
-  typedef std::function<void(const char* name_, const struct SServerEventCallbackData* data_)> ServerEventCallbackT;
+  using ServerEventCallbackT = std::function<void (const char *, const struct SServerEventCallbackData *)>;
 };

ecal/core/include/ecal/ecal_config.h

@@ -118,6 +118,12 @@ namespace eCAL
     ECAL_API bool              IsTopicTypeSharingEnabled            ();
     ECAL_API bool              IsTopicDescriptionSharingEnabled     ();
 
+    /////////////////////////////////////
+    // service
+    /////////////////////////////////////
+    ECAL_API bool              IsServiceProtocolV0Enabled           ();
+    ECAL_API bool              IsServiceProtocolV1Enabled           ();
+
     /////////////////////////////////////
     // experimental
     /////////////////////////////////////