TransportTypes.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_TRANSPORTTYPES_HH_
#define IGN_TRANSPORT_TRANSPORTTYPES_HH_
 
#ifdef _MSC_VER
#pragma warning(push, 0)
#endif
#include <google/protobuf/message.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#include <chrono>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "ignition/transport/config.hh"
#include "ignition/transport/Publisher.hh"
 
namespace ignition
{
  namespace transport
  {
    // Inline bracket to help doxygen filtering.
    inline namespace IGNITION_TRANSPORT_VERSION_NAMESPACE {
    //
    class IRepHandler;
    class IReqHandler;
    class ISubscriptionHandler;
    class RawSubscriptionHandler;
    class MessageInfo;
 
    template<typename T>
    using Addresses_M = std::map<std::string, std::vector<T>>;
 
    using MsgAddresses_M = Addresses_M<MessagePublisher>;
 
    using SrvAddresses_M = Addresses_M<ServicePublisher>;
 
    using ProtoMsg = google::protobuf::Message;
 
    using ProtoMsgPtr = std::shared_ptr<ProtoMsg>;
 
    using ISubscriptionHandlerPtr = std::shared_ptr<ISubscriptionHandler>;
 
    using RawSubscriptionHandlerPtr = std::shared_ptr<RawSubscriptionHandler>;
 
    using ISubscriptionHandler_M =
      std::map<std::string, ISubscriptionHandlerPtr>;
 
    using RawSubscriptionHandler_M =
      std::map<std::string, RawSubscriptionHandlerPtr>;
 
    using IRepHandlerPtr = std::shared_ptr<IRepHandler>;
 
    using IReqHandlerPtr = std::shared_ptr<IReqHandler>;
 
    using IReqHandler_M =
      std::map<std::string, std::map<std::string, IReqHandlerPtr>>;
 
    template <typename T>
    using DiscoveryCallback = std::function<void(const T &_publisher)>;
 
    using MsgDiscoveryCallback =
      std::function<void(const MessagePublisher &_publisher)>;
 
    using SrvDiscoveryCallback =
      std::function<void(const ServicePublisher &_publisher)>;
 
    template <typename T>
    using MsgCallback =
      std::function<void(const T &_msg, const MessageInfo &_info)>;
 
    using RawCallback =
        std::function<void(const char *_msgData, const size_t _size,
                           const MessageInfo &_info)>;
 
    using Timestamp = std::chrono::steady_clock::time_point;
 
    using DeallocFunc = void(void *_data, void *_hint);
 
    const std::string kGenericMessageType = "google.protobuf.Message";
 
    const int kDefaultRcvHwm = 1000;
 
    const int kDefaultSndHwm = 1000;
    }
  }
}
#endif