gz/transport/Packet.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_TRANSPORT_PACKET_HH_
#define GZ_TRANSPORT_PACKET_HH_
 
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
 
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
#include "gz/transport/Publisher.hh"
 
// This whole file is deprecated in version 8 of Ignition Transport. Please
// remove this file in Version 9.
 
namespace ignition
{
  namespace transport
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_TRANSPORT_VERSION_NAMESPACE {
    //
    // Message types.
    static const uint8_t Uninitialized  = 0;
    static const uint8_t AdvType        = 1;
    static const uint8_t SubType        = 2;
    static const uint8_t UnadvType      = 3;
    static const uint8_t HeartbeatType  = 4;
    static const uint8_t ByeType        = 5;
    static const uint8_t NewConnection  = 6;
    static const uint8_t EndConnection  = 7;
 
    // Flag set when a discovery message is relayed.
    static const uint16_t FlagRelay   = 0b000000000000'0001;
    // Flag set when we want to avoid to relay a discovery message.
    // This is used to avoid loops.
    static const uint16_t FlagNoRelay = 0b000000000000'0010;
 
    static const std::vector<std::string> MsgTypesStr =
    {
      "UNINITIALIZED", "ADVERTISE", "SUBSCRIBE", "UNADVERTISE", "HEARTBEAT",
      "BYE", "NEW_CONNECTION", "END_CONNECTION"
    };
 
    class IGNITION_TRANSPORT_VISIBLE Header
    {
      public: IGN_DEPRECATED(8) Header() = default;
 
      public: IGN_DEPRECATED(8) Header(const uint16_t _version,
                     const std::string &_pUuid,
                     const uint8_t _type,
                     const uint16_t _flags = 0);
 
      public: virtual ~Header() = default;
 
      public: uint16_t Version() const;
 
      public: std::string PUuid() const;
 
      public: uint8_t Type() const;
 
      public: uint16_t Flags() const;
 
      public: void SetVersion(const uint16_t _version);
 
      public: void SetPUuid(const std::string &_pUuid);
 
      public: void SetType(const uint8_t _type);
 
      public: void SetFlags(const uint16_t _flags);
 
      public: int HeaderLength() const;
 
      public: size_t Pack(char *_buffer) const;
 
      public: size_t Unpack(const char *_buffer);
 
      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const Header &_header)
      {
        _out << "--------------------------------------\n"
             << "Header:" << std::endl
             << "\tVersion: " << _header.Version() << "\n"
             << "\tProcess UUID: " << _header.PUuid() << "\n"
             << "\tType: " << MsgTypesStr.at(_header.Type()) << "\n"
             << "\tFlags: " << _header.Flags() << "\n";
        return _out;
      }
 
      private: uint16_t version = 0;
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::string
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::string pUuid = "";
#ifdef _WIN32
#pragma warning(pop)
#endif
 
      private: uint8_t type = Uninitialized;
 
      private: uint16_t flags = 0;
    };
 
    class IGNITION_TRANSPORT_VISIBLE SubscriptionMsg
    {
      public: IGN_DEPRECATED(8) SubscriptionMsg() = default;
 
      public: IGN_DEPRECATED(8) SubscriptionMsg(
                  const transport::Header &_header,
                  const std::string &_topic);
 
      public: transport::Header Header() const;
 
      public: std::string Topic() const;
 
      public: void SetHeader(const transport::Header &_header);
 
      public: void SetTopic(const std::string &_topic);
 
      public: size_t MsgLength() const;
 
      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const SubscriptionMsg &_msg)
      {
        _out << _msg.Header()
             << "Body:" << std::endl
             << "\tTopic: [" << _msg.Topic() << "]" << std::endl;
 
        return _out;
      }
 
      public: size_t Pack(char *_buffer) const;
 
      public: size_t Unpack(const char *_buffer);
 
      private: transport::Header header;
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by std::string
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::string topic = "";
#ifdef _WIN32
#pragma warning(pop)
#endif
    };
 
    template <class T> class AdvertiseMessage
    {
      public: IGN_DEPRECATED(8) AdvertiseMessage() = default;
 
      public: IGN_DEPRECATED(8) AdvertiseMessage(const Header &_header,
                               const T &_publisher)
        : header(_header),
          publisher(_publisher)
      {
      }
 
      public: transport::Header Header() const
      {
        return this->header;
      }
 
      public: T& Publisher()
      {
        return this->publisher;
      }
 
      public: void SetHeader(const transport::Header &_header)
      {
        this->header = _header;
      }
 
      public: void SetPublisher(const T &_publisher)
      {
        this->publisher = _publisher;
      }
 
      public: size_t MsgLength() const
      {
        return this->header.HeaderLength() + this->publisher.MsgLength();
      }
 
      public: size_t Pack(char *_buffer) const
      {
        // Pack the common part of any advertise message.
        size_t len = this->header.Pack(_buffer);
        if (len == 0)
          return 0;
 
        _buffer += len;
 
        // Pack the part of the publisher.
        if (this->publisher.Pack(_buffer) == 0)
          return 0;
 
        return this->MsgLength();
      }
 
      public: size_t Unpack(const char *_buffer)
      {
        // Unpack the message publisher.
        if (this->publisher.Unpack(_buffer) == 0)
          return 0;
 
        return this->publisher.MsgLength();
      }
 
      public: void SetFromDiscovery(const msgs::Discovery &_msg)
      {
        this->publisher.SetFromDiscovery(_msg);
      }
 
      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const AdvertiseMessage &_msg)
      {
        _out << _msg.header << _msg.publisher;
        return _out;
      }
 
      private: transport::Header header;
 
      private: T publisher;
    };
    }
  }
}
 
#endif