NodeShared.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_NODESHARED_HH_
#define IGN_TRANSPORT_NODESHARED_HH_

#ifdef _MSC_VER
#pragma warning(push, 0)
#endif
#include <google/protobuf/message.h>
#include <zmq.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>

#include "ignition/transport/Discovery.hh"
#include "ignition/transport/HandlerStorage.hh"
#include "ignition/transport/Helpers.hh"
#include "ignition/transport/Publisher.hh"
#include "ignition/transport/RepHandler.hh"
#include "ignition/transport/ReqHandler.hh"
#include "ignition/transport/SubscriptionHandler.hh"
#include "ignition/transport/TopicStorage.hh"
#include "ignition/transport/TransportTypes.hh"
#include "ignition/transport/Uuid.hh"

namespace ignition
{
  namespace transport
  {
    class IGNITION_TRANSPORT_VISIBLE NodeShared
    {
      public: static NodeShared *Instance();

      public: void RunReceptionTask();

      public: bool Publish(const std::string &_topic,
                           const std::string &_data,
                           const std::string &_msgType);

      public: void RecvMsgUpdate();

      public: void RecvControlUpdate();

      public: void RecvSrvRequest();

      public: void RecvSrvResponse();

      public: void SendPendingRemoteReqs(const std::string &_topic,
                                         const std::string &_reqType,
                                         const std::string &_repType);

      public: void OnNewConnection(const MessagePublisher &_pub);

      public: void OnNewDisconnection(const MessagePublisher &_pub);

      public: void OnNewSrvConnection(const ServicePublisher &_pub);

      public: void OnNewSrvDisconnection(const ServicePublisher &_pub);

      protected: NodeShared();

      protected: virtual ~NodeShared();

      private: bool InitializeSockets();

      public: static const int Timeout = 250;


      public: Uuid responseReceiverId;

      public: Uuid replierId;

      public: std::string pUuid;

      public: int timeout;

      public: std::thread threadReception;

      public: std::recursive_mutex mutex;

      public: bool exit;

#ifdef _WIN32
      public: bool threadReceptionExiting;
#endif

      private: const int kMsgDiscPort = 11317;

      private: const int kSrvDiscPort = 11318;

      private: std::mutex exitMutex;

      private: TopicStorage<MessagePublisher> connections;

      private: std::vector<std::string> srvConnections;

      public: TopicStorage<MessagePublisher> remoteSubscribers;

      public: HandlerStorage<ISubscriptionHandler> localSubscriptions;

      public: HandlerStorage<IRepHandler> repliers;

      public: HandlerStorage<IReqHandler> requests;

      public: int verbose;

      public: std::string myAddress;

      public: std::string myControlAddress;

      public: std::string myRequesterAddress;

      public: std::string myReplierAddress;

      public: std::string hostAddr;


      public: std::unique_ptr<zmq::context_t> context;


      public: std::unique_ptr<zmq::socket_t> publisher;

      public: std::unique_ptr<zmq::socket_t> subscriber;

      public: std::unique_ptr<zmq::socket_t> control;

      public: std::unique_ptr<zmq::socket_t> requester;

      public: std::unique_ptr<zmq::socket_t> responseReceiver;

      public: std::unique_ptr<zmq::socket_t> replier;


      public: std::unique_ptr<MsgDiscovery> msgDiscovery;

      public: std::unique_ptr<SrvDiscovery> srvDiscovery;
    };
  }
}
#endif