id,summary,reporter,owner,description,type,status,milestone,component,version,severity,resolution,keywords,cc
9601,Unable to load archives with pointer instances which contain self reference cycles in 1.55,Brandon Kohn,Robert Ramey,"First the original pointer is loaded like so:
{{{
#!c++
// because the following operation could move the items
// don't use co after this
// add to list of serialized objects so that we can properly handle
// cyclic strucures
//! Note: t's value is undefined at this point. It's whatever value it had when serialization was called.
object_id_vector.push_back(aobject(t, cid));
		
// remember that that the address of these elements could change
// when we make another call so don't use the address
bpis_ptr->load_object_ptr(
    ar,
    t,
    m_pending.version
);
BOOST_ASSERT(NULL != t);
//! Note: The object_id_vector element's address is not updated until the load is complete.
[1]  object_id_vector[ui].address = t;
}}}

load_object_ptr will eventually lead to:
{{{
#!c++
template<class Archive, class T>
BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
    basic_iarchive & ar, 
    void * & x,
    const unsigned int file_version
) const
{
...
//! This serializes an instance of T	
    ar_impl >> boost::serialization::make_nvp(NULL, * t);
}
}}}
If t contains a cyclic reference to itself
then the following is called:
{{{
#!c++
// extra line to evade borland issue
const bool tracking = co.tracking_level;
// if we're tracking and the pointer has already been read
if(tracking && ! track(ar, t))
    // we're done
    return bpis_ptr;
}}}
track will check if the oid is already loaded
and assign the address of the previously loaded pointer.
{{{
#!c++
bool
basic_iarchive_impl::track(
    basic_iarchive & ar,
    void * & t
){
    ...
    // if its a reference to a old object
    if(object_id_type(object_id_vector.size()) > oid){
        // we're done
//! Note this line: ***
[2]     t = object_id_vector[oid].address;
        return false;
    }
    return true;
}
}}}
Recall back at the original scope [1]:
remember that that the address of these elements could change
{{{
#!c++
// when we make another call so don't use the address
bpis_ptr->load_object_ptr(
    ar,
    t,
    m_pending.version
);
BOOST_ASSERT(NULL != t);
//! The assignment to object_id_vector[ui].address takes place after the cycle is loaded.
//! This means means the value assigned to t at [2] is undefined.
object_id_vector[ui].address = t;
}}}

Here's a unit test that illustrates the issue:
{{{
#!c++
namespace TestPointerSerializationReferenceCycle
{
    struct PointerHolder
    {
        PointerHolder(PointerHolder* ptr = nullptr)
        : Ptr(ptr)
        {}

        PointerHolder* Ptr;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned int v)
        {
            ar & Ptr;
        }
    };
}

BOOST_AUTO_TEST_CASE(TestPointerReferenceCycleLoad)
{
    using namespace TestPointerSerializationReferenceCycle;

    std::stringstream buff(std::stringstream::in | std::stringstream::out);

    //! Write it.
    {
        PointerHolder* pPtrHldr = new PointerHolder();
        pPtrHldr->Ptr = pPtrHldr;
                
        boost::archive::text_oarchive ar(buff);
        ar & pPtrHldr;
    }

    //! Read it.
    {
        buff.seekg(0);

        PointerHolder* pPtrHldr = reinterpret_cast<PointerHolder*>(0xBAADF00D);

        boost::archive::text_iarchive ar(buff);
        ar & pPtrHldr;

        BOOST_CHECK(pPtrHldr != nullptr);
        if (pPtrHldr != nullptr)
        {
            BOOST_CHECK(pPtrHldr->Ptr == pPtrHldr);//! At this point pPtrHldr->Ptr == 0xBAADFOOD.
        }
    }
}
}}}
",Bugs,closed,To Be Determined,serialization,Boost 1.55.0,Problem,fixed,,