"cereal found more than one compatible output serialization function" when using external split load/save functions with explicit version

[yuqian90]

Ran into cereal assertion error when trying to use external split load/save functions with explicit version on a subclass which has two constructors, a default constructor and a non-default one.

The non-default constructor seems to have somehow caused some interesting issues. When I did any one of these, the code compiles all okay:

1. comment out the non-default constructor
2. Make the non-default constructor explicit like this:

   explicit Derived(const std::string& name)
   ...

3. remove the explicit version
4. use serialize() instead of load/save.

If I missed something from the doc, please point out. (the doc just said "cereal requires access to a default constructor for types it serializes", in my case, there is a public default constructor.)

Here's the code to produce this issue:

#include <string>
#include <sstream>
#include <memory>
#include <cassert>
#include <cereal/cereal.hpp>
#include <cereal/archives/binary.hpp>
#include <cereal/types/polymorphic.hpp>

struct Base
{
    virtual ~Base() = default;
    int id = 0;
};

struct Derived: public Base
{
    Derived() = default;

    Derived(const std::string& name): name(name){}

    virtual ~Derived() = default;
    std::string name;
};

namespace cereal{

template<class Archive>
void save(Archive& ar, const Base& obj, const std::uint32_t version)
{
    ar(obj.id);
}

template<class Archive>
void load(Archive& ar, Base& obj, const std::uint32_t version)
{
    ar(obj.id);
}

template<class Archive>
void save(Archive& ar, const Derived& obj, const std::uint32_t version)
{
    ar(base_class<Base>(&obj), obj.name);
}

template<class Archive>
void load(Archive& ar, Derived& obj, const std::uint32_t version)
{
    ar(base_class<Base>(&obj), obj.name);
}

}

CEREAL_REGISTER_TYPE(Derived)

int main(int argc, char* argv[])
{
    using namespace cereal;
    std::ostringstream osm;
    BinaryOutputArchive oarc(osm);
    std::shared_ptr<Derived> obj = std::make_shared<Derived>();
    obj->id = 10;
    obj->name = "test name";
    oarc(std::dynamic_pointer_cast<Base>(obj));

    std::istringstream ism(osm.str());
    BinaryInputArchive iarc(ism);
    std::shared_ptr<Base> obj2;
    iarc(obj2);

    auto actual = std::dynamic_pointer_cast<Derived>(obj2);
    assert(obj->name == actual->name);
    return 0;
}

Here's the compile error:

cereal/include/cereal/cereal.hpp: In instantiation of ‘ArchiveType& cereal::OutputArchive<ArchiveType, Flags>::processImpl(const T&) [with T = std::basic_string<char>; typename cereal::traits::detail::EnableIfHelper<(cereal::traits::has_invalid_output_versioning<T, ArchiveType>::value || ((! cereal::traits::is_output_serializable<T, ArchiveType>::value) && ((!(Flags & AllowEmptyClassElision)) || ((Flags & AllowEmptyClassElision) && (! std::is_empty<T>::value)))))>::type <anonymous> = (cereal::traits::detail::type)0; ArchiveType = cereal::BinaryOutputArchive; unsigned int Flags = 1u]’:
cereal/include/cereal/cereal.hpp:347:9:   required from ‘void cereal::OutputArchive<ArchiveType, Flags>::process(T&&) [with T = std::basic_string<char>&; ArchiveType = cereal::BinaryOutputArchive; unsigned int Flags = 1u]’
cereal/include/cereal/cereal.hpp:249:9:   required from ‘ArchiveType& cereal::OutputArchive<ArchiveType, Flags>::operator()(Types&& ...) [with Types = {std::basic_string<char, std::char_traits<char>, std::allocator<char> >&}; ArchiveType = cereal::BinaryOutputArchive; unsigned int Flags = 1u]’
cereal/include/cereal/details/polymorphic_impl.hpp:545:59:   required from ‘static void cereal::detail::OutputBindingCreator<Archive, T>::writeMetadata(Archive&) [with Archive = cereal::BinaryOutputArchive; T = Derived]’
cereal/include/cereal/details/polymorphic_impl.hpp:621:29:   required from ‘cereal::detail::OutputBindingCreator<Archive, T>::OutputBindingCreator() [with Archive = cereal::BinaryOutputArchive; T = Derived]::__lambda10’
cereal/include/cereal/details/polymorphic_impl.hpp:618:13:   required from ‘struct cereal::detail::OutputBindingCreator<Archive, T>::OutputBindingCreator() [with Archive = cereal::BinaryOutputArchive; T = Derived]::__lambda10’
cereal/include/cereal/details/polymorphic_impl.hpp:617:32:   [ skipping 4 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
cereal/include/cereal/details/polymorphic_impl.hpp:706:96:   required from ‘static void cereal::detail::polymorphic_serialization_support<Archive, T>::instantiate() [with Archive = cereal::BinaryOutputArchive; T = Derived]’
cereal/include/cereal/details/polymorphic_impl.hpp:686:5:   required from ‘struct cereal::detail::polymorphic_serialization_support<cereal::BinaryOutputArchive, Derived>’
cereal/include/cereal/archives/binary.hpp:163:1:   required by substitution of ‘template<class T, class BindingTag> typename cereal::detail::polymorphic_serialization_support<cereal::BinaryOutputArchive, T>::type cereal::detail::instantiate_polymorphic_binding(T*, cereal::BinaryOutputArchive*, BindingTag, cereal::detail::adl_tag) [with T = Derived; BindingTag = cereal::detail::{anonymous}::polymorphic_binding_tag]’
cereal/include/cereal/details/polymorphic_impl.hpp:724:86:   required from ‘void cereal::detail::bind_to_archives<T, Tag>::bind(std::false_type) const [with T = Derived; Tag = cereal::detail::{anonymous}::polymorphic_binding_tag; std::false_type = std::integral_constant<bool, false>]’
cereal/include/cereal/details/polymorphic_impl.hpp:738:37:   required from ‘const cereal::detail::bind_to_archives<T, Tag>& cereal::detail::bind_to_archives<T, Tag>::bind() const [with T = Derived; Tag = cereal::detail::{anonymous}::polymorphic_binding_tag]’
simplecerealtest.cpp:53:1:   required from here
cereal/include/cereal/cereal.hpp:472:9: error: static assertion failed: cereal found more than one compatible output serialization function for the provided type and archive combination. 

 Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). 
 Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions.  
 Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. 
 In addition, you may not mix versioned with non-versioned serialization functions. 

 
         static_assert(traits::detail::count_output_serializers<T, ArchiveType>::value < 2,

cereal version used is release 1.2.2

Compiler used:

$ c++ --version
c++ (Ubuntu 4.8.4-2ubuntu1~14.04) 4.8.4
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

[AzothAmmo]

Fair warning: this response is more of a triage of the problem than an easy solution. The best way around this currently is to use explicit.

cereal is finding two conflicting functions for serializing std::string, one is the default (in cereal/types/string.hpp) which does not take a version parameter, the other is created through the implicit conversion your constructor provides. You can get an identical error by defining both a versioned and non-versioned variant for a class:

struct Hello
{
  Hello() = default;
  int x;
};

namespace cereal
{
  template <class Archive>
  void load( Archive &, Hello & )
  { }

  template <class Archive>
  void save( Archive &, Hello const & )
  { }

  template <class Archive>
  void load( Archive &, Hello &, const std::uint32_t )
  { }

  template <class Archive>
  void save( Archive &, Hello const &, const std::uint32_t )
  { }
}

when serialized gives:

workspace/cereal/include/cereal/cereal.hpp:472:9: error: static assertion failed: cereal found more than one compatible output serialization function for the provided type and archive combination. 

 Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). 
 Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions.  
 Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. 
 In addition, you may not mix versioned with non-versioned serialization functions. 

 
         static_assert(traits::detail::count_output_serializers<T, ArchiveType>::value < 2,
         ^

A more direct but simplified version of your issue is:

struct Snarf
{
  Snarf() = default;
  int x;
};

struct Hello
{
  Hello() = default;
  Hello( Snarf const & ) {}
  int x;
};

namespace cereal
{
  template <class Archive>
  void load( Archive &, Snarf & )
  { }

  template <class Archive>
  void save( Archive &, Snarf const & )
  { }

  template <class Archive>
  void load( Archive &, Hello &, const std::uint32_t )
  { }

  template <class Archive>
  void save( Archive &, Hello const &, const std::uint32_t )
  { }
}

Serializing Snarf will give the same error. The key to reproducing this is that you have a type with a versioned serialization function that can be implicitly instantiated by a non-versioned type.

When cereal is trying to see how it can serialize the non-versioned type, it has to check for and count all possible valid ways, both versioned and non-versioned, it could be saved and loaded. When it is implicitly convertible to another type that is also versioned, it finds two ways - which creates the error.

We check for these types (see details/traits.hpp line 217) by doing something like:

auto has_load_not_versioned(int) -> decltype( load( std::declval<Archive&>(), std::declval<Type&>() );
auto has_load_versioned(int) -> decltype( load( std::declval<Archive&>(), std::declval<Type&>(), 1u );

Both end up being valid which eventually triggers the static assertion.

There is a way around this, which is what we currently do for minimal serialization, where we have a proxy type that is not implicitly convertible, see details/traits.hpp around line 602. This however creates a lot of annoyances and has some downsides (see #132).

To end this rambling, for now just use explicit and know that resolving this in a clean way is a difficult problem because C++ lacks reflection.