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 <magic_enum.hpp>
#include <map>
#include <sstream>
#include <string>
#include <vector>
 
#include "implicit_metafunction_for_toml11.h"
#include "math_euler.h"
#include "math_quaternion.h"
#include "math_vector3.h"
#include "strconv2.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_