Publisher.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2015 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_PUBLISHER_HH_
#define IGN_TRANSPORT_PUBLISHER_HH_

#include <ignition/msgs/discovery.pb.h>

#include <iostream>
#include <string>

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

namespace ignition
{
  namespace transport
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_TRANSPORT_VERSION_NAMESPACE {
    //
    // Forward declarations.
    class MessagePublisherPrivate;

    class IGNITION_TRANSPORT_VISIBLE Publisher
    {
      public: Publisher() = default;

      public: Publisher(const std::string &_topic,
                        const std::string &_addr,
                        const std::string &_pUuid,
                        const std::string &_nUuid,
                        const AdvertiseOptions &_opts);

      public: Publisher(const Publisher &_other);

      public: virtual ~Publisher() = default;

      public: std::string Topic() const;

      public: std::string Addr() const;

      public: std::string PUuid() const;

      public: std::string NUuid() const;

      public: virtual const AdvertiseOptions &Options() const;

      public: void SetTopic(const std::string &_topic);

      public: void SetAddr(const std::string &_addr);

      public: void SetPUuid(const std::string &_pUuid);

      public: void SetNUuid(const std::string &_nUuid);

      public: void SetOptions(const AdvertiseOptions &_opts);

      public: virtual void FillDiscovery(msgs::Discovery &_msg) const;

      public: virtual void SetFromDiscovery(const msgs::Discovery &_msg);

      public: bool operator==(const Publisher &_pub) const;

      public: bool operator!=(const Publisher &_pub) const;

      public: Publisher &operator=(const Publisher &_other);

      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const Publisher &_msg)
      {
        _out << "Publisher:"                              << std::endl
             << "\tTopic: ["       << _msg.Topic() << "]" << std::endl
             << "\tAddress: "      << _msg.Addr()         << std::endl
             << "\tProcess UUID: " << _msg.PUuid()        << std::endl
             << "\tNode UUID: "    << _msg.NUuid()        << std::endl
             << _msg.Options();

        return _out;
      }

#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::string
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      protected: std::string topic;

      protected: std::string addr;

      protected: std::string pUuid;

      protected: std::string nUuid;
#ifdef _WIN32
#pragma warning(pop)
#endif

      private: AdvertiseOptions opts;
    };

    class IGNITION_TRANSPORT_VISIBLE MessagePublisher : public Publisher
    {
      public: MessagePublisher() = default;

      public: explicit MessagePublisher(const std::string &_topic,
                                        const std::string &_addr,
                                        const std::string &_ctrl,
                                        const std::string &_pUuid,
                                        const std::string &_nUuid,
                                        const std::string &_msgTypeName,
                                        const AdvertiseMessageOptions &_opts);

      public: MessagePublisher(const MessagePublisher &_other);

      public: virtual ~MessagePublisher() = default;

      public: std::string Ctrl() const;

      public: void SetCtrl(const std::string &_ctrl);

      public: std::string MsgTypeName() const;

      public: void SetMsgTypeName(const std::string &_msgTypeName);

      public: virtual const AdvertiseMessageOptions &Options() const;

      public: void SetOptions(const AdvertiseMessageOptions &_opts);

      public: virtual void FillDiscovery(msgs::Discovery &_msg) const final;

      public: virtual void SetFromDiscovery(const msgs::Discovery &_msg);

      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const MessagePublisher &_msg)
      {
        _out << "Publisher:"                                  << std::endl
             << "\tTopic: ["           << _msg.Topic() << "]" << std::endl
             << "\tAddress: "          << _msg.Addr()         << std::endl
             << "\tProcess UUID: "     << _msg.PUuid()        << std::endl
             << "\tNode UUID: "        << _msg.NUuid()        << std::endl
             << "\tControl address: "  << _msg.Ctrl()         << std::endl
             << "\tMessage type: "     << _msg.MsgTypeName()  << std::endl
             << _msg.Options();
        return _out;
      }

      public: bool operator==(const MessagePublisher &_pub) const;

      public: bool operator!=(const MessagePublisher &_pub) const;

      public: MessagePublisher &operator=(const MessagePublisher &_other);

#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::unique_ptr
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::string ctrl;

      private: std::string msgTypeName;
#ifdef _WIN32
#pragma warning(pop)
#endif

      private: AdvertiseMessageOptions msgOpts;
    };

    class IGNITION_TRANSPORT_VISIBLE ServicePublisher : public Publisher
    {
      public: ServicePublisher() = default;

      public: ServicePublisher(const std::string &_topic,
                               const std::string &_addr,
                               const std::string &_id,
                               const std::string &_pUuid,
                               const std::string &_nUuid,
                               const std::string &_reqType,
                               const std::string &_repType,
                               const AdvertiseServiceOptions &_opts);

      public: ServicePublisher(const ServicePublisher &_other);

      public: virtual ~ServicePublisher() = default;

      public: std::string SocketId() const;

      public: void SetSocketId(const std::string &_socketId);

      public: std::string ReqTypeName() const;

      public: std::string RepTypeName() const;

      public: void SetReqTypeName(const std::string &_reqTypeName);

      public: void SetRepTypeName(const std::string &_repTypeName);

      public: virtual const AdvertiseServiceOptions& Options() const;

      public: void SetOptions(const AdvertiseServiceOptions &_opts);

      public: virtual void FillDiscovery(msgs::Discovery &_msg) const final;

      public: virtual void SetFromDiscovery(const msgs::Discovery &_msg);

      public: friend std::ostream &operator<<(std::ostream &_out,
                                              const ServicePublisher &_msg)
      {
        _out << "Publisher:"                                  << std::endl
             << "\tTopic: ["           << _msg.Topic() << "]" << std::endl
             << "\tAddress: "          << _msg.Addr()         << std::endl
             << "\tProcess UUID: "     << _msg.PUuid()        << std::endl
             << "\tNode UUID: "        << _msg.NUuid()        << std::endl
             << "\tSocket ID: "        << _msg.SocketId()     << std::endl
             << "\tRequest type: "     << _msg.ReqTypeName()  << std::endl
             << "\tResponse type: "    << _msg.RepTypeName()  << std::endl
             << _msg.Options();

        return _out;
      }

      public: bool operator==(const ServicePublisher &_srv) const;

      public: bool operator!=(const ServicePublisher &_srv) const;

      public: ServicePublisher &operator=(const ServicePublisher &_other);

#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::string
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::string socketId;

      private: std::string reqTypeName;

      private: std::string repTypeName;
#ifdef _WIN32
#pragma warning(pop)
#endif

      private: AdvertiseServiceOptions srvOpts;
    };
    }
  }
}

#endif