toml_serialize_macro.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_TOML_SERIALIZE_MACRO_H_
#define DESIGNLAB_TOML_SERIALIZE_MACRO_H_
 
 
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
 
#include <magic_enum.hpp>
 
#include "strconv2.h"
 
#include "implicit_metafunction_for_toml11.h"
#include "math_euler.h"
#include "math_quaternion.h"
#include "math_vector3.h"
#include "toml11_define.h"
 
 
namespace designlab::toml_func
{
 
struct Toml11Description final
{
    static const char kNoTable[];
 
    Toml11Description(const std::string& t, const std::string& d) :
        table_name(t),
        description(d)
    {
    }
 
    std::string table_name;  
    std::string description;  
};
 
 
std::vector<std::string> sjis_to_utf8_vec(const std::vector<std::string>& str_vec);
 
template <typename T>
typename std::enable_if<impl::is_toml11_available_type<T>::value>::type
SetTomlValue(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& str, const T& value)
{
    (*v)[str] = value;
}
 
template <typename T>
typename std::enable_if<!impl::is_toml11_available_type<T>::value&& std::is_enum<T>::value>::type
SetTomlValue(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& str, const T& value)
{
    (*v)[str] = static_cast<std::string>(magic_enum::enum_name(value));
}
 
template <typename T>
typename std::enable_if<!impl::is_toml11_available_type<T>::value&& impl::has_output_operator<T>::value>::type
SetTomlValue(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& str, const T& value)
{
    std::stringstream ss;
    ss << value;
    (*v)[str] = ss.str();
}
 
template <typename T>
typename std::enable_if<!impl::is_toml11_available_type<T>::value&& impl::is_vector_of_has_output_operator<T>::value>::type
SetTomlValue(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& str, const T& value)
{
    std::vector<std::string> str_vec(value.size());
 
    for (int i = 0; i < value.size(); ++i)
    {
        std::stringstream ss;
        ss << value[i];
        str_vec[i] = ss.str();
    }
 
    (*v)[str] = str_vec;
}
 
template <typename T, typename Enable = void>
struct GetTomlValueImpl;
 
template <typename T>
struct GetTomlValueImpl < T, typename std::enable_if<impl::is_toml11_available_type<T>::value> ::type >
{
    static T Get(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& var_str)
    {
        return toml::find<T>(*v, var_str);
    }
};
 
template <typename T>
struct GetTomlValueImpl<T, typename std::enable_if<!impl::is_toml11_available_type<T>::value&& std::is_enum<T>::value>::type>
{
    static T Get(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& var_str)
    {
        std::string str = toml::find<std::string>(*v, var_str);
        return magic_enum::enum_cast<T>(str).value();
    }
};
 
template <typename T>
struct GetTomlValueImpl<T, typename std::enable_if<!impl::is_toml11_available_type<T>::value&& impl::has_input_operator<T>::value>::type>
{
    static T Get(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& var_str)
    {
        std::string str = toml::find<std::string>(*v, var_str);
        std::stringstream ss;
        ss << str;
        T temp{};
        ss >> temp;
        return temp;
    }
};
 
template <typename T>
struct GetTomlValueImpl<T, typename std::enable_if<!impl::is_toml11_available_type<T>::value&& impl::is_vector_of_has_input_operator<T>::value>::type>
{
    static T Get(::toml::basic_value<toml::preserve_comments, std::map>* v, const std::string& var_str)
    {
        std::vector<std::string> str_vec = toml::find<std::vector<std::string>>(*v, var_str);
 
        T temp{};
 
        temp.resize(str_vec.size());
 
        for (int i = 0; i < str_vec.size(); ++i)
        {
            std::stringstream ss;
            ss << str_vec[i];
            ss >> temp[i];
        }
 
        return temp;
    }
};
 
template <typename T>
T GetTomlValue(::toml::basic_value<toml::preserve_comments, std::map> v, const std::string& var_str)
{
    return GetTomlValueImpl<T>::Get(&v, var_str);
}
 
}  // namespace designlab::toml_func
 
 
#define DESIGNLAB_SUB_MACRO_FIND_MEMBER_VARIABLE_FROM_VALUE(VAR_NAME)      \
{                                                                          \
    const std::string table_str = desc.VAR_NAME.table_name;                \
                                                                           \
    if (table_str == ::designlab::toml_func::Toml11Description::kNoTable)  \
    {                                                                      \
        obj.VAR_NAME =                                                     \
            ::designlab::toml_func::GetTomlValue<decltype(obj.VAR_NAME)>(  \
                v_,                                                        \
                TOML11_STRINGIZE(VAR_NAME));                               \
    }                                                                      \
    else                                                                   \
    {                                                                      \
        obj.VAR_NAME =                                                     \
            ::designlab::toml_func::GetTomlValue<decltype(obj.VAR_NAME)>(  \
                v_[table_str],                                             \
                TOML11_STRINGIZE(VAR_NAME));                               \
    }                                                                      \
}
 
 
 
#define DESIGNLAB_SUB_MACRO_ASSIGN_MEMBER_VARIABLE_TO_VALUE(VAR)                  \
if (desc.VAR.table_name != ::designlab::toml_func::Toml11Description::kNoTable) { \
    if (v.count(desc.VAR.table_name) == 0)                                        \
    {                                                                             \
        v[desc.VAR.table_name] = toml::table{};                                   \
    }                                                                             \
                                                                                  \
    ::designlab::toml_func::SetTomlValue(&v[desc.VAR.table_name],                 \
        TOML11_STRINGIZE(VAR), obj.VAR);                                          \
}                                                                                 \
else                                                                              \
{                                                                                 \
    ::designlab::toml_func::SetTomlValue(                                         \
        &v, TOML11_STRINGIZE(VAR), obj.VAR);                                      \
}
 
 
#define DESIGNLAB_SUB_MACRO_ADD_COMMENT(VN)                                        \
if (desc.VN.description != "") {                                                   \
    if (desc.VN.table_name != ::designlab::toml_func::Toml11Description::kNoTable) \
    {                                                                              \
        v[desc.VN.table_name][#VN].comments().push_back(desc.VN.description);      \
    }                                                                              \
    else                                                                           \
    {                                                                              \
        v[#VN].comments().push_back(desc.VN.description);                          \
    }                                                                              \
}
 
 
#define DESIGNLAB_TOML11_DESCRIPTION_CLASS(CLASS) \
struct CLASS##Description final
 
 
#define DESIGNLAB_TOML11_FILE_NO_DESCRIPTION() \
const ::std::vector<::std::string> file_description_vec{};
 
#define DESIGNLAB_TOML11_FILE_ADD_DESCRIPTION(DESCRIPTION) \
const ::std::vector<::std::string> file_description_vec{sjis_to_utf8(DESCRIPTION)};
 
#define DESIGNLAB_TOML11_FILE_ADD_DESCRIPTION_MULTI_LINE(DESCRIPTION_VEC) \
const ::std::vector<::std::string> file_description_vec = \
    ::designlab::toml_func::sjis_to_utf8_vec(DESCRIPTION_VEC);
 
 
#define DESIGNLAB_TOML11_TABLE_ADD_DESCRIPTION(...) \
const std::vector<std::string> table_name_description_vec = \
    ::designlab::toml_func::sjis_to_utf8_vec({ __VA_ARGS__ });
 
#define DESIGNLAB_TOML11_TABLE_NO_DESCRIPTION() \
const std::vector<std::string> table_name_description_vec = {};
 
 
#define DESIGNLAB_TOML11_VARIABLE_ADD_DESCRIPTION(VARIABLE, TABLE, DESCRIPTION) \
const ::designlab::toml_func::Toml11Description VARIABLE{                       \
    TABLE, sjis_to_utf8(DESCRIPTION)                                            \
}
 
#define DESIGNLAB_TOML11_VARIABLE_NO_DESCRIPTION(VARIABLE, TABLE) \
const ::designlab::toml_func::Toml11Description VARIABLE{TABLE, ""}
 
#define DESIGNLAB_TOML11_NO_TABLE \
::designlab::toml_func::Toml11Description::kNoTable
 
 
#define DESIGNLAB_TOML11_SERIALIZE(NAME, ...)                                   \
namespace toml                                                                  \
{                                                                               \
template<>                                                                      \
struct from<NAME>                                                               \
{                                                                               \
  static_assert(std::is_class<NAME>::value,                                     \
    "第1引数はクラスか構造体である必要があります．");                           \
  static_assert(std::is_default_constructible<NAME>::value,                     \
    "第1引数はデフォルトコンストラクタを持つ必要があります．");                 \
                                                                                \
  template<typename C, template<typename ...> class T,                          \
       template<typename ...> class A>                                          \
  static NAME from_toml(basic_value<C, T, A>& v)                                \
  {                                                                             \
    ::toml::basic_value<toml::preserve_comments, std::map> v_ = v;              \
    NAME obj;                                                                   \
    NAME##Description desc;                                                     \
    TOML11_FOR_EACH_VA_ARGS(                                                    \
        DESIGNLAB_SUB_MACRO_FIND_MEMBER_VARIABLE_FROM_VALUE, __VA_ARGS__)       \
    return obj;                                                                 \
  }                                                                             \
};                                                                              \
                                                                                \
template<>                                                                      \
struct into<NAME>                                                               \
{                                                                               \
  static value into_toml(const NAME& obj)                                       \
  {                                                                             \
    ::toml::basic_value<toml::preserve_comments, std::map> v = ::toml::table{}; \
                                                                                \
    NAME##Description desc;                                                     \
                                                                                \
    for (const auto i : desc.file_description_vec)                              \
    {                                                                           \
      v.comments().push_back(i);                                                \
    }                                                                           \
                                                                                \
    for (int i = 0; i < desc.table_name_description_vec.size(); ++i)            \
    {                                                                           \
      v[desc.table_name_description_vec[i]] = ::toml::table{};                  \
      v[desc.table_name_description_vec[i]].comments().                         \
        push_back(desc.table_name_description_vec[i + 1]);                      \
      ++i;                                                                      \
    }                                                                           \
                                                                                \
    TOML11_FOR_EACH_VA_ARGS(                                                    \
        DESIGNLAB_SUB_MACRO_ASSIGN_MEMBER_VARIABLE_TO_VALUE, __VA_ARGS__)       \
    TOML11_FOR_EACH_VA_ARGS(                                                    \
        DESIGNLAB_SUB_MACRO_ADD_COMMENT, __VA_ARGS__)                           \
    return v;                                                                   \
  }                                                                             \
};                                                                              \
                                                                                \
}  // namespace toml
 
 
#endif  // DESIGNLAB_TOML_SERIALIZE_MACRO_H_