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 IGN_TRANSPORT_PACKET_HH_
#define IGN_TRANSPORT_PACKET_HH_

#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

#include "ignition/transport/config.hh"
#include "ignition/transport/Export.hh"
#include "ignition/transport/Publisher.hh"

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"
    };

    // of message (ADV, SUB, ... ) and optional flags.
    class IGNITION_TRANSPORT_VISIBLE Header
    {
      public: Header() = default;

      public: 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: SubscriptionMsg() = default;

      public: 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: AdvertiseMessage() = default;

      public: 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: 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