Add static assertions on invalid archive parameter for minimal serialization functions

[DrAWolf]

Just a detail:
In the following code, I have to REMOVE const of archvie in load_minimal in order to compile...

    std::string save_minimal( const cereal::JSONOutputArchive& archive ) const
    {
        return ToString();
    }

    void load_minimal( const /*!!!???*/ cereal::JSONInputArchive & archive, const std::string& string_rep )
    {
        FromString( string_rep );
    }

related remark:
ordinary load() also has a non-const archive, which seems counterintuitive...

[AzothAmmo]

Both minimal functions should accept their archives by constant reference - is this not the case for you?

The reason for this is because we don't want people mucking around with archives when they've promised (by using a minimal function) to only serialize a single primitive value.

The other serialization types take archives as non constant references because you directly invoke them (operator()) to perform serialization.

[DrAWolf]

The above code in isolation is not problematic. Here is a better example:

I use the following code to invoke different behaviour for binary/non-binary:

    template<class Archive>
    typename std::enable_if<std::is_same<Archive, cereal::BinaryOutputArchive>::value, void >::type
        save( Archive& archive ) const
    {
            archive( x );
    }

    template<class Archive>
    typename std::enable_if<std::is_same<Archive, cereal::BinaryInputArchive>::value, void >::type
        load( Archive& archive )
    {
            archive( x );
    }

    template<class Archive>
    typename std::enable_if<!std::is_same<Archive, cereal::BinaryOutputArchive>::value, std::string >::type
     save_minimal( const Archive& archive ) const
    {
        return ToString();
    }

    template<class Archive>
    typename std::enable_if<!std::is_same<Archive, cereal::BinaryInputArchive>::value, void >::type
        load_minimal( const Archive& archive, const std::string& string_rep )
    {
        FromString( string_rep );
    }

If I remove const (of Archive&) from load_minimal, it still compiles, but crashes on loading..

I was just wondering whether you want/can to enforce a certain const-signature and put out warnings for it.

If the user mixes different const/non-const functions this will probably result in hard-to-find errors.

[AzothAmmo]

Yes we can add static assertions on a failure to have a const archive parameter - this must have slipped by, we give errors for most of the other bad things you can try to do to a minimal function.

[AzothAmmo]

So after looking at this fairly in depth I've come to two conclusions: 1) This is purely an enable_if problem (not on our end) and 2) cereal cannot actually check to make sure you wrote const in the archive parameter.

There doesn't seem to be a way to distinguish between:

template <class T> void asdf( T & x );

and

template <class T> void asdf( T const & x );

without having the function itself try to modify x.

What this means to cereal is that for minimal serialization functions, you are free to try and accept the archive as a non constant reference, and you will only get an error when you actually try and use that archive. Your example was failing because your enable_if did not properly detect the archives matching due to const issues. You can solve this with things like std::decay.

To make this easy on people, we'll put in a type-trait cereal::is_same_archive that will do all of the decaying and make things look tidier. Example:

struct Hello
{
  int x;

  template <class Archive,
            cereal::traits::DisableIf<cereal::traits::is_same_archive<Archive, cereal::BinaryOutputArchive>::value> = cereal::traits::sfinae>
  std::string save_minimal( Archive & ) const
  {
    return std::to_string( x ) + "hello";
  }

  template <class Archive,
            cereal::traits::DisableIf<cereal::traits::is_same_archive<Archive, cereal::BinaryInputArchive>::value> = cereal::traits::sfinae>
  void load_minimal( Archive const &, std::string const & str )
  {
    x = std::stoi( str.substr(0, 1) );
  }

  template <class Archive,
            cereal::traits::EnableIf<cereal::traits::is_same_archive<Archive, cereal::BinaryOutputArchive>::value> = cereal::traits::sfinae>
  int save_minimal( Archive & ) const
  {
    return x;
  }

  template <class Archive,
            cereal::traits::EnableIf<cereal::traits::is_same_archive<Archive, cereal::BinaryInputArchive>::value> = cereal::traits::sfinae>
  void load_minimal( Archive const &, int const & xx )
  {
    x = xx;
  }
};