Type traits for load_minimal use incorrect archive when looking up save_minimal return type

[DrAWolf]

I still think that the following is relevant for others besides me

I want to serialize enums to strings for text archives, while for binary I want to use standard serialization as an int.
(For my own classes, I want to define a standard serialization, but as soon as I define a string serialization, I want it to be applied for all text archives, while for binary the standard is applied.)

After trying for 2h, I gave up.
Could you come up with a convenient way to do this?

[AzothAmmo]

Right now since enums are still getting pulled in by default you'd have to write something like this:

namespace cereal
{
  template <class T> inline
  typename std::enable_if<common_detail::is_enum<T>::value, std::string>::type
  save_minimal( JSONOutputArchive const &, T const & t )
  {
    // somehow convert t to a string
  }

  template <class T> inline
  typename std::enable_if<common_detail::is_enum<T>::value, void>::type
  load_minimal( JSONInputArchive const &, T && t, std::string const & value )
  {
    // somehow convert value into t
  }
}

Unfortunately you have to specialize explicitly for each archive type because the generic version of the enum serialization takes the archive as a template parameter, so you need to come up with an overload that has higher precedence (and writing another template with some enable_if will have the same precedence).

This is the general game you play with all serialization functions - there can only be one highest priority valid overload for each archive-type pairing.

You also need to put this in the cereal namespace so that the compiler can find it properly.

[DrAWolf]

I cannot/dontwanto do it globally (i.e. for all enums), so defined the following:
non-binary : save as string
binary : save as fundamental type

#define _AW_ENUM_SERIALIZATION( identifier, enum_type )                                                             \
    template<class Archive>                                                                                         \
    typename std::enable_if<!std::is_same<Archive, cereal::BinaryOutputArchive>::value, std::string >::type         \
    save_minimal( const Archive& archive, const identifier& x )                                                     \
    {                                                                                                               \
        return EnumToString( x );                                                                                   \
    }                                                                                                               \
                                                                                                                    \
    template<class Archive>                                                                                         \
    typename std::enable_if<!std::is_same<Archive, cereal::BinaryInputArchive>::value, void >::type                 \
    load_minimal( const Archive& archive, identifier& x, const std::string& string_rep )                            \
    {                                                                                                               \
        x = StringToEnum( string_rep );                                                                             \
    }                                                                                                               \
                                                                                                                    \
    template<class Archive>                                                                                         \
    typename std::enable_if<std::is_same<Archive, cereal::BinaryOutputArchive>::value, enum_type >::type            \
    save_minimal( const Archive& archive, const identifier& x )                                                     \
    {                                                                                                               \
        return static_cast<enum_type>( x );                                                                         \
    }                                                                                                               \
                                                                                                                    \
    template<class Archive>                                                                                         \
    typename std::enable_if<std::is_same<Archive, cereal::BinaryInputArchive>::value, void >::type                  \
    load_minimal( const Archive& archive, identifier && x,  const enum_type& value )                                \
    {                                                                                                               \
        x = reinterpret_cast<identifier>( value );                                                                  \
    }                                                                                                               \

UNFORTUNATELY, I get a compiler error - which I think is NOT CORRECT.
"error C2338: cereal detected different types in corresponding non-member load_minimal and save_minimal functions. the paramater to load_minimal must be a constant reference to the type that save_minimal returns.
"
If I only use one version (without the enable_ifs), it works fine, but I dont want to save enums as string in the binary case)
Might be a conflict with the enum load/save_minimal in common.hpp.
Maybe your checks also compare the standard (common.hpp) save_minimal with my specializations?

[AzothAmmo]

There's a bug in our type traits that look up the return type of save_minimal. It's passing the input archive to the type trait instead of the the output archive, so it is finding one of the incorrect overloads for your functions and taking its return type.

[AzothAmmo]

Should be good to go now.