Add a way to make to_json and from_json functions in global scope work

[Niko-O]

(Solved. See first comment below.)

I have some enums, each in a different file. Simplified example:

// In Stuff.h
namespace Bloop
{
    enum class Stuff { Foo = 0, Bar };
}

// In Things.h
namespace Bloop
{
    enum class Things : unsigned char { Baz = 20, Frob };
}

// In Clobber.h
namespace Blarg
{
    enum class Clobber { Boop, Beep };
}

I need to de-/serialize those to/from json. Simplified example:

// in main.cpp
#include <iostream>

#include "Stuff.h"
#include "Things.h"
#include "Clobber.h"

#include "nlohmann/json.hpp"

#include "Helper.h"

template<typename T>
void roundtripJson(const char* name, T value)
{
    nlohmann::json json1 = value;
    std::cout << name << " 1: " << json1.dump() << std::endl;
    T roundtrip = json1.get<T>();
    nlohmann::json json2 = roundtrip;
    std::cout << name << " 2: " << json2.dump() << std::endl << std::endl;
}

int main()
{
    roundtripJson("Stuff", Bloop::Stuff::Foo);
    roundtripJson("Things", Bloop::Things::Baz);
    roundtripJson("Clobber", Blarg::Clobber::Beep);
    return 0;
}

This will serialize the enum values simply as the underlying integral value.

To get my own serialization to work, I need to declare to_json and from_json functions at the place of #include "Helper.h":

// In Helper.h
    template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>    
    void to_json(nlohmann::json& json, const T& value)                                      
    {                                                                                       
        json = 1000 + static_cast<int>(value); /* This is just a placeholder */             
    }                                                                                       
    template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>    
    void from_json(const nlohmann::json& json, T& value)                                    
    {                                                                                       
        value = static_cast<T>(json.get<int>() - 1000); /* This is just a placeholder */    
    }

My problem is that I have to repeat this exact code for every namespace that contains an enum, even though the code is exactly the same. In this example, I need to do this:

// In Helper.h
#define EnumJsonFunctions                                                                   \
    template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>    \
    void to_json(nlohmann::json& json, const T& value)                                      \
    {                                                                                       \
        json = 1000 + static_cast<int>(value); /* This is just a placeholder */             \
    }                                                                                       \
    template<typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>    \
    void from_json(const nlohmann::json& json, T& value)                                    \
    {                                                                                       \
        value = static_cast<T>(json.get<int>() - 1000); /* This is just a placeholder */    \
    }                                                                                       

namespace Bloop
{
    EnumJsonFunctions
}
namespace Blarg
{
    EnumJsonFunctions
}

This works, but it quickly becomes unwieldy. I have a big project with >60 enums in a heap of different namespaces. When I add a new enum I need to remember to look in Helper.h to see whether a matching namespace block exists and C&P one if necessary. And when I remove an enum I need to check again and try to remember whether there are any other enums that need that block, and remove it if none are left.
Alternatively, I could make the to_json and from_json functions not templates and have a specific one for each enum, along with the enum declaration in each file. But that's even more annoying code duplication.

Aside from being error-prone busywork, this is just silly to have to do. It would be much nicer to have one of those functions (my guess is in global scope) and have that be used.

[Niko-O]

Actually, nevermind.

namespace nlohmann
{
    namespace detail
    {
        EnumJsonFunctions
    }
}

Works like a charm.

I thought of this as I was typing "my guess is in global scope" above. For posterity, I'll leave the original post here, in case someone else has the same problem.