interface.h

Go to the documentation of this file.

// Copyright 2016-2023:
//   GobySoft, LLC (2013-)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// The Goby Libraries are distributed in the hope that they will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_MIDDLEWARE_MARSHALLING_INTERFACE_H
#define GOBY_MIDDLEWARE_MARSHALLING_INTERFACE_H
 
#include <map>         // for map
#include <memory>      // for share...
#include <string>      // for string
#include <type_traits> // for is_void
#include <utility>     // for pair
#include <vector>      // for vector
 
#include "goby/middleware/marshalling/detail/primitive_type.h" // for primi...
 
namespace goby
{
namespace middleware
{
//
// MarshallingScheme
//
 
struct MarshallingScheme
{
    enum MarshallingSchemeEnum
    {
        ALL_SCHEMES = -2,
        NULL_SCHEME = -1,
        CSTR = 0,
        PROTOBUF = 1,
        DCCL = 2,
        //        CAPTN_PROTO = 3,
        //        MSGPACK = 4,
        CXX_OBJECT = 5,
        MAVLINK = 6,
        JSON = 7,
        // BOOST_SERIALIZATION = 8 (currently in Netsim)
    };
 
    static std::string to_string(int e)
    {
        auto it = e2s.find(e);
        return it != e2s.end() ? it->second : std::to_string(e);
    }
 
    static int from_string(const std::string& s)
    {
        auto it = s2e.find(s);
        return it != s2e.end() ? it->second : std::stoi(s);
    }
 
  private:
    static const std::map<int, std::string> e2s;
    static const std::map<std::string, int> s2e;
};
 
//
// SerializerParserHelper
//
 
template <typename DataType, int scheme, class Enable = void> struct SerializerParserHelper
{
    static std::vector<char> serialize(const DataType& /*msg*/)
    {
        static_assert(std::is_void<Enable>::value, "SerializerParserHelper must be specialized");
        return std::vector<char>();
    }
 
    static std::string type_name()
    {
        static_assert(std::is_void<Enable>::value, "SerializerParserHelper must be specialized");
        return std::string();
    }
 
    static std::string type_name(const DataType& /*d*/)
    {
        static_assert(std::is_void<Enable>::value, "SerializerParserHelper must be specialized");
        return std::string();
    }
 
    template <typename CharIterator>
    static std::shared_ptr<DataType> parse(CharIterator bytes_begin, CharIterator bytes_end,
                                           CharIterator& actual_end,
                                           const std::string& type = type_name())
    {
        static_assert(std::is_void<Enable>::value, "SerializerParserHelper must be specialized");
        return std::shared_ptr<DataType>();
    }
};
 
//
// scheme
//
 
template <typename DataType, typename Transporter> constexpr int transporter_scheme()
{
    using detail::primitive_type;
    return Transporter::template scheme<typename primitive_type<DataType>::type>();
}
 
template <typename DataType,
          typename std::enable_if<std::is_same<DataType, void>::value>::type* = nullptr>
constexpr int scheme()
{
    static_assert(std::is_same<DataType, void>::value, "Null scheme instantiated");
    return goby::middleware::MarshallingScheme::NULL_SCHEME;
}
 
} // namespace middleware
} // namespace goby
 
#endif