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

#include <algorithm>
#include <functional>
#include <memory>
#include <mutex>
#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 "ignition/transport/AdvertiseOptions.hh"
#include "ignition/transport/config.hh"
#include "ignition/transport/Export.hh"
#include "ignition/transport/NodeOptions.hh"
#include "ignition/transport/NodeShared.hh"
#include "ignition/transport/Publisher.hh"
#include "ignition/transport/RepHandler.hh"
#include "ignition/transport/ReqHandler.hh"
#include "ignition/transport/SubscribeOptions.hh"
#include "ignition/transport/SubscriptionHandler.hh"
#include "ignition/transport/TopicUtils.hh"
#include "ignition/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 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;

      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 "ignition/transport/detail/Node.hh"

#endif