Another shared_from_this bug... This time, invalidated shared_from_this state after SAVING (not loading)

[Devacor]

This bug literally took me a month to write a minimal test case for. I assumed I was doing something bad, but it seems cereal's archive molests the shared_from_this state without calling a destructor!

See the line with: //BUSTED

#include <strstream>

#include "cereal/cereal.hpp"
#include "cereal/types/map.hpp"
#include "cereal/types/vector.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/types/string.hpp"
#include "cereal/types/base_class.hpp"

#include "cereal/archives/json.hpp"
#include "cereal/types/polymorphic.hpp"

#include <memory>

struct Node : public std::enable_shared_from_this<Node> {
    Node(int val):data1(val){ std::cout << "Base Constructor" << std::endl; }
    virtual ~Node(){ std::cout << "Base Destructor" << std::endl; }

    template <class Archive>
    void serialize(Archive & archive){
        archive(CEREAL_NVP(data1), CEREAL_NVP(child));
    }

    template <class Archive>
    static void load_and_allocate(Archive & archive, cereal::allocate<Node> &allocate){
        int data1;
        archive(cereal::make_nvp("data1", data1));
        allocate(data1);
        archive(cereal::make_nvp("child", allocate->child));
    }

    std::shared_ptr<Node> child;

    int data1 = 0;
};

struct DerivedNode : public Node {
    DerivedNode(int val):Node(val), data2(val){ std::cout << "Derived Constructor" << std::endl; }
    ~DerivedNode(){ std::cout << "Derived Destructor" << std::endl; }

    template <class Archive>
    void serialize(Archive & archive){
        archive(CEREAL_NVP(data2), cereal::make_nvp("base", cereal::base_class<Node>(this)));
    }

    template <class Archive>
    static void load_and_allocate(Archive & archive, cereal::allocate<DerivedNode> &allocate){
        allocate(-1);
        archive(cereal::make_nvp("data2", allocate->data2), cereal::make_nvp("base", cereal::base_class<Node>(allocate.ptr())));
    }

    int data2 = 2;
};

CEREAL_REGISTER_TYPE(DerivedNode);

void saveTest(){
    int testInt = 10;
    int *pointInt = &testInt;
    std::stringstream stream;
    {
        std::shared_ptr<Node> node = std::make_shared<Node>(1);
        node->child = std::make_shared<DerivedNode>(3); //if this is just "Node" it's fine again!
        auto test1 = node->child->shared_from_this(); //Fine

        cereal::JSONOutputArchive archive(stream);
        auto test2 = node->child->shared_from_this(); //Fine

        auto nvp = cereal::make_nvp("node", node);
        auto test3 = node->child->shared_from_this(); //Fine

        archive(nvp);
        auto test4 = node->child->shared_from_this(); //BUSTED
        std::cout << "Completed Save!" << std::endl;
    }
    std::cout << stream.str() << std::endl;
    std::cout << std::endl;
    {
        std::shared_ptr<Node> node;

        cereal::JSONInputArchive archive(stream);
        archive(cereal::make_nvp("node", node));

        node->shared_from_this();
        std::cout << "We good?" << node->data1 << std::endl;

        node->child->shared_from_this();
        std::cout << "We still good?" << node->child->data1 << std::endl;
    }
    std::cout << "Done" << std::endl;
}

int main(){
    saveTest();
}

[Devacor]

I am at work right now, so I cannot do further testing for a few hours, but I have a hunch it might be related to cereal::base_class.

When I get home I plan on removing the cereal::base_class call and seeing if it still breaks.

[AzothAmmo]

Much simpler test case:

struct A : std::enable_shared_from_this<A>
{
  template <class Archive>
    void serialize( Archive & ar )
    { }

  virtual void foo() = 0;
};

struct B : A
{
  template <class Archive>
    void serialize( Archive & ar )
    { }

  void foo() {}
};

CEREAL_REGISTER_TYPE(B);

int main()
{
  {
    cereal::JSONOutputArchive ar(std::cout);
    std::shared_ptr<A> a( new B() );

    ar( a );

    auto x = a->shared_from_this();
  }
}

[AzothAmmo]

Fairly confident the error is due to this line. In this function we are being given a void pointer to whatever your shared_ptr holds but we know its true type (the template type T, due to registering the type earlier). I think what is happening is that the temporary shared_ptr<T> we construct is messing up the internal weak_ptr.

Also this has nothing to do with base_class or any of its variants.

[Devacor]

Awesome, thanks for looking into it! Yeah, my test case was quite heavy in comparison to the true minimal example you provided. I was just so relieved to have it nailed down to something outside of my own code base. Also glad to help with another report! :)

[AzothAmmo]

Hoping this is the last of the issues related to enable_shared_from_this, which I officially deem the most annoying standard library feature to support.

[Devacor]

Agreed. Love you. Want your babies. Thank god. I'll post again if I find any more bugs. My code base seems to be very useful for picking out this kind of intricate bullshit. :S