nlohmann::is_serializable<T>

[pfeatherstone]

How about an integral_constant that returns whether a type is serializable or not. Here is a working implementation:

namespace nlohmann
{
    template<typename... Ts>
    struct is_serializable_helper {};
    
    template<typename T, typename _ = void>
    struct is_serializable : std::false_type {};

    template<typename T>
    struct is_serializable<
            T,
            typename std::conditional<
                false,
                is_serializable_helper<
                    decltype(to_json(std::declval<json&>(), std::declval<const T&>())),
                    decltype(from_json(std::declval<const json&>(), std::declval<T&>()))
                    >,
                void
                >::type
            > : public std::true_type {};
}

[pfeatherstone]

@nlohmann what do you think?

[nlohmann]

You seem to also check for from_json which would be rather "deserialization". Do you think this is a good idea?

[pfeatherstone]

Maybe something like this:

namespace nlohmann
{    
    #if __cplusplus == 201103L
    template <typename ...> struct void_t_impl {typedef void type;};
    template <typename ... T> using void_t = typename void_t_impl<T...>::type;
    #else
    using std::void_t;
    #endif

    template<typename T, typename = void>
    struct is_convertible : std::false_type {};
    
    template<typename T>
    struct is_convertible<T,void_t<decltype(to_json(std::declval<json&>(), std::declval<const T&>())),
                                   decltype(from_json(std::declval<const json&>(), std::declval<T&>()))>> : std::true_type {};
}

Would be better?

[pfeatherstone]

I'm not convinced anymore it's a super good idea for user-code to use this type trait. I can see it being useful in library implementations as you can have some static_assert statements here and there which improve compiler error messages, rather than letting the compiler provide an enormous dump of unclear messages. But exposing it in the API might lead users to using nlohmann library incorrectly. And whatever you do with this type trait you can probably do a slightly different way using function overloading. So not sure if it provides anything extra. That's my opinion. But others, who love metaprogramming, might enjoy this.

[pfeatherstone]

@nlohmann On a related note, you might find this interesting. It removes the upper limit on the number of member variables. You're only bound by the template recursion limit of your compiler which should be high enough.

[gregmarr]

I think there are versions of MSVC that currently work with this library but don't have variadic template support.

[pfeatherstone]

i guess nlohmann::json requires a C++11 strictly conforming compiler. If a compiler doesn't support variadic templates, it's difficult to qualify it as C++11 conforming... But fair enough, no point in changing something that ain't broke.