common.h

/*+-------------------------------------------------------------------------+
  |                       MultiVehicle simulator (libmvsim)                 |
  |                                                                         |
  | Copyright (C) 2014-2026  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};
        }
 
        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