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 GZ_TRANSPORT_PUBLISHER_HH_
#define GZ_TRANSPORT_PUBLISHER_HH_
 
#include <gz/msgs/discovery.pb.h>
 
#include <iostream>
#include <string>
 
#include "gz/transport/AdvertiseOptions.hh"
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
 
namespace gz::transport
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_TRANSPORT_VERSION_NAMESPACE {
 
  class GZ_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: 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: 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 GZ_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: 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;
 
#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 GZ_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: 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;
 
#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