gz/transport/Node.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_NODE_HH_
#define GZ_TRANSPORT_NODE_HH_
 
#include <algorithm>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_set>
#include <vector>
 
// TODO(anyone): Remove after fixing the warnings
#ifdef _MSC_VER
#pragma warning(push, 0)
#endif
#include <ignition/msgs.hh>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#include "gz/transport/AdvertiseOptions.hh"
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
#include "gz/transport/NodeOptions.hh"
#include "gz/transport/NodeShared.hh"
#include "gz/transport/Publisher.hh"
#include "gz/transport/RepHandler.hh"
#include "gz/transport/ReqHandler.hh"
#include "gz/transport/SubscribeOptions.hh"
#include "gz/transport/SubscriptionHandler.hh"
#include "gz/transport/TopicStatistics.hh"
#include "gz/transport/TopicUtils.hh"
#include "gz/transport/TransportTypes.hh"
 
namespace ignition
{
  namespace transport
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_TRANSPORT_VERSION_NAMESPACE {
    //
    // Forward declarations.
    class NodePrivate;
 
    int IGNITION_TRANSPORT_VISIBLE rcvHwm();
 
    int IGNITION_TRANSPORT_VISIBLE sndHwm();
 
    void IGNITION_TRANSPORT_VISIBLE waitForShutdown();
 
    class IGNITION_TRANSPORT_VISIBLE Node
    {
      class PublisherPrivate;
 
      public: class IGNITION_TRANSPORT_VISIBLE Publisher
      {
        public: Publisher();
 
        public: explicit Publisher(const MessagePublisher &_publisher);
 
        public: virtual ~Publisher();
 
        public: operator bool();
 
        public: operator bool() const;
 
        public: bool Valid() const;
 
        public: bool Publish(const ProtoMsg &_msg);
 
        public: bool PublishRaw(
          const std::string &_msgData,
          const std::string &_msgType);
 
        public: bool ThrottledUpdateReady() const;
 
        private: bool UpdateThrottling();
 
        public: bool HasConnections() const;
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::shared_ptr
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
        private: std::shared_ptr<PublisherPrivate> dataPtr;
#ifdef _WIN32
#pragma warning(pop)
#endif
      };
 
      public: explicit Node(const NodeOptions &_options = NodeOptions());
 
      public: virtual ~Node();
 
      public: template<typename MessageT>
      Node::Publisher Advertise(
          const std::string &_topic,
          const AdvertiseMessageOptions &_options = AdvertiseMessageOptions());
 
      public: Node::Publisher Advertise(
          const std::string &_topic,
          const std::string &_msgTypeName,
          const AdvertiseMessageOptions &_options = AdvertiseMessageOptions());
 
      public: std::vector<std::string> AdvertisedTopics() const;
 
      public: template<typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          void(*_callback)(const MessageT &_msg),
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: template<typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          std::function<void(const MessageT &_msg)> _callback,
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: template<typename ClassT, typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          void(ClassT::*_callback)(const MessageT &_msg),
          ClassT *_obj,
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: template<typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          void(*_callback)(const MessageT &_msg, const MessageInfo &_info),
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: template<typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          std::function<void(const MessageT &_msg,
                             const MessageInfo &_info)> _callback,
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: template<typename ClassT, typename MessageT>
      bool Subscribe(
          const std::string &_topic,
          void(ClassT::*_callback)(const MessageT &_msg,
                                   const MessageInfo &_info),
          ClassT *_obj,
          const SubscribeOptions &_opts = SubscribeOptions());
 
      public: std::vector<std::string> SubscribedTopics() const;
 
      public: bool Unsubscribe(const std::string &_topic);
 
      public: template<typename RequestT, typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          bool(*_callback)(const RequestT &_request, ReplyT &_reply),
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          bool(*_callback)(ReplyT &_reply),
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename RequestT>
      bool Advertise(
          const std::string &_topic,
          void(*_callback)(const RequestT &_request),
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename RequestT, typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          std::function<bool(const RequestT &_request,
                             ReplyT &_reply)> _callback,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          std::function<bool(ReplyT &_reply)> &_callback,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename RequestT>
      bool Advertise(
          const std::string &_topic,
          std::function<void(const RequestT &_request)> &_callback,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename ClassT, typename RequestT, typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          bool(ClassT::*_callback)(const RequestT &_request, ReplyT &_reply),
          ClassT *_obj,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename ClassT, typename ReplyT>
      bool Advertise(
          const std::string &_topic,
          bool(ClassT::*_callback)(ReplyT &_reply),
          ClassT *_obj,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: template<typename ClassT, typename RequestT>
      bool Advertise(
          const std::string &_topic,
          void(ClassT::*_callback)(const RequestT &_request),
          ClassT *_obj,
          const AdvertiseServiceOptions &_options = AdvertiseServiceOptions());
 
      public: std::vector<std::string> AdvertisedServices() const;
 
      public: template<typename RequestT, typename ReplyT>
      bool Request(
          const std::string &_topic,
          const RequestT &_request,
          void(*_callback)(const ReplyT &_reply, const bool _result));
 
      public: template<typename ReplyT>
      bool Request(
          const std::string &_topic,
          void(*_callback)(const ReplyT &_reply, const bool _result));
 
      public: template<typename RequestT, typename ReplyT>
      bool Request(
          const std::string &_topic,
          const RequestT &_request,
          std::function<void(const ReplyT &_reply,
                             const bool _result)> &_callback);
 
      public: template<typename ReplyT>
      bool Request(
          const std::string &_topic,
          std::function<void(const ReplyT &_reply,
                             const bool _result)> &_callback);
 
      public: template<typename ClassT, typename RequestT, typename ReplyT>
      bool Request(
          const std::string &_topic,
          const RequestT &_request,
          void(ClassT::*_callback)(const ReplyT &_reply, const bool _result),
          ClassT *_obj);
 
      public: template<typename ClassT, typename ReplyT>
      bool Request(
          const std::string &_topic,
          void(ClassT::*_callback)(const ReplyT &_reply, const bool _result),
          ClassT *_obj);
 
      public: template<typename RequestT, typename ReplyT>
      bool Request(
          const std::string &_topic,
          const RequestT &_request,
          const unsigned int &_timeout,
          ReplyT &_reply,
          bool &_result);
 
      public: template<typename ReplyT>
      bool Request(
          const std::string &_topic,
          const unsigned int &_timeout,
          ReplyT &_reply,
          bool &_result);
 
      public: template<typename RequestT>
      bool Request(const std::string &_topic, const RequestT &_request);
 
      public: bool RequestRaw(const std::string &_topic,
                  const std::string &_request, const std::string &_requestType,
                  const std::string &_responseType, unsigned int _timeout,
                  std::string &_response,
                  bool &_result);
 
      public: bool UnadvertiseSrv(const std::string &_topic);
 
      public: void TopicList(std::vector<std::string> &_topics) const;
 
      public: bool TopicInfo(const std::string &_topic,
                             std::vector<MessagePublisher> &_publishers) const;
 
      public: void ServiceList(std::vector<std::string> &_services) const;
 
      public: bool ServiceInfo(
          const std::string &_service,
          std::vector<ServicePublisher> &_publishers) const;
 
      public: bool SubscribeRaw(
        const std::string &_topic,
        const RawCallback &_callback,
        const std::string &_msgType = kGenericMessageType,
        const SubscribeOptions &_opts = SubscribeOptions());
 
      public: const NodeOptions &Options() const;
 
      public: bool EnableStats(const std::string &_topic, bool _enable,
                  const std::string &_publicationTopic = "/statistics",
                  uint64_t _publicationRate = 1);
 
      public: std::optional<TopicStatistics> TopicStats(
                  const std::string &_topic) const;
 
      private: NodeShared *Shared() const;
 
      private: const std::string &NodeUuid() const;
 
      private: std::unordered_set<std::string> &TopicsSubscribed() const;
 
      private: std::unordered_set<std::string> &SrvsAdvertised() const;
 
      private: bool SubscribeHelper(const std::string &_fullyQualifiedTopic);
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::unique_ptr
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::unique_ptr<transport::NodePrivate> dataPtr;
#ifdef _WIN32
#pragma warning(pop)
#endif
    };
    }
  }
}
 
#include "gz/transport/detail/Node.hh"
 
#endif