Alternative implementation of NLOHMANN_DEFINE_TYPE_INTRUSIVE

[pfeatherstone]

Instead of using the current macro expansion of NLOHMANN_DEFINE_TYPE_INTRUSIVE, which imposes an upper bound on the number of member variables, why not use something like this:

template<typename T>
inline void serialize_to_json(nlohmann::json& j, const std::vector<std::string>& names, int offset, const T& x)
{
    j[names[offset]] = x;
}

template<typename T, typename... Rest>
inline void serialize_to_json(nlohmann::json& j, const std::vector<std::string>& names, int offset, const T& x, const Rest& ... rest)
{
    serialize_to_json(j, names, offset++, x);
    serialize_to_json(j, names, offset, rest...);
}

template<typename T>
inline void deserialize_from_json(const nlohmann::json& j, const std::vector<std::string>& names, int offset, T& x)
{
    j.at(names[offset]).get_to(x);
}

template<typename T, typename... Rest>
inline void deserialize_from_json(const nlohmann::json& j, const std::vector<std::string>& names, int offset, T& x, Rest& ... rest)
{
    deserialize_from_json(j, names, offset++, x);
    deserialize_from_json(j, names, offset, rest...);
}

vector<string> split(const string& str, const string& delim)
{
    vector<string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        token.erase(std::remove(token.begin(), token.end(), ' '), token.end());
        if (!token.empty()) 
            tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

#define JSON_DEFINE_SERIALIZE_MEMBER_FUNCS(...) \
void to_json_private(nlohmann::json& j) const                           \
{                                                                       \
    const static std::string s = #__VA_ARGS__;                          \
    const static std::vector<std::string> names = split(s, ",");           \
    int offset = 0;                                                     \
    serialize_to_json(j, names, offset, __VA_ARGS__);                      \
}                                                                       \
                                                                        \
void from_json_private(const nlohmann::json& j)                         \
{                                                                       \
    const static std::string s = #__VA_ARGS__;                          \
    const static std::vector<std::string> names = split(s, ",");           \
    int offset = 0;                                                     \
    deserialize_from_json(j, names, offset, __VA_ARGS__);                  \
}                                                                       

#define NLOHMANN_DEFINE_TYPE_INTRUSIVE2(type, ...)                      \
JSON_DEFINE_SERIALIZE_MEMBER_FUNCS(__VA_ARGS__)                         \
friend void to_json(nlohmann::json& j, const type& obj)                 \
{ obj.to_json_private(j);}                                              \
                                                                        \
friend void from_json(const nlohmann::json& j, type& obj)               \
{obj.from_json_private(j);}

Note that a better split function could be used. @nlohmann sorry i didn't suggest this at the time when these macros were in development.

[pfeatherstone]

There is no upper bound on the number of member variables. But, though the string s and vector of strings names are static, these will be created every time the header is included. Maybe a C++11 version of string_view which is constexpr could be used instead.

[nlohmann]

See #2404 (reply in thread)