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 GZ_TRANSPORT_TRANSPORTTYPES_HH_
#define GZ_TRANSPORT_TRANSPORTTYPES_HH_
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#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 "gz/transport/config.hh"
#include "gz/transport/Publisher.hh"
 
namespace gz::transport
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_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