common.h

Go to the documentation of this file.

/*+-------------------------------------------------------------------------+
  |                       MultiVehicle simulator (libmvsim)                 |
  |                                                                         |
  | Copyright (C) 2014-2024  Jose Luis Blanco Claraco                       |
  | Copyright (C) 2017  Borys Tymchenko (Odessa Polytechnic University)     |
  | Distributed under 3-clause BSD License                                  |
  |   See COPYING                                                           |
  +-------------------------------------------------------------------------+ */
 
#pragma once
 
#if defined(MVSIM_HAS_ZMQ) && defined(MVSIM_HAS_PROTOBUF)
 
#include <mrpt/io/CMemoryStream.h>
#include <mrpt/serialization/CArchive.h>
 
#include <variant>
 
#include "zmq_fwrds.h"
 
namespace google::protobuf
{
class MessageLite;
}
 
namespace mvsim
{
void sendMessage(const google::protobuf::MessageLite& m, zmq::socket_t& socket);
 
zmq::message_t receiveMessage(zmq::socket_t& s);
 
void parseMessage(const zmq::message_t& msg, google::protobuf::MessageLite& out);
 
class UnexpectedMessageException : public std::runtime_error
{
   public:
        UnexpectedMessageException(const char* reason) : std::runtime_error(reason) {}
};
namespace internal
{
std::tuple<std::string, std::string> parseMessageToParts(const zmq::message_t& msg);
 
template <typename variant_t, size_t IDX = 0>
variant_t recursiveParse(const std::string& typeName, const std::string& serializedData)
{
        if constexpr (IDX < std::variant_size_v<variant_t>)
        {
                using this_t = std::variant_alternative_t<IDX, variant_t>;
                this_t v;
                const std::string expectedName = v.GetTypeName();
                if (expectedName == typeName)
                {
                        bool ok = v.ParseFromString(serializedData);
                        if (!ok)
                                THROW_EXCEPTION_FMT(
                                        "Format error: protobuf could not decode binary message of "
                                        "type '%s'",
                                        typeName.c_str());
                        return {v};
                }
                else
                        return recursiveParse<variant_t, IDX + 1>(typeName, serializedData);
        }
        throw UnexpectedMessageException(
                mrpt::format("Type '%s' not found in expected list of variant arguments.", typeName.c_str())
                        .c_str());
}
}  // namespace internal
 
std::string get_zmq_endpoint(const zmq::socket_t& s);
 
template <typename variant_t>
variant_t parseMessageVariant(const zmq::message_t& msg)
{
        const auto [typeName, serializedData] = internal::parseMessageToParts(msg);
        return internal::recursiveParse<variant_t>(typeName, serializedData);
}
 
template <class... Ts>
struct overloaded : Ts...
{
        using Ts::operator()...;
};
 
template <class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;
 
}  // namespace mvsim
#endif