Re: [Boost-users] [Serialization] Problem serializingviabaseclassptr

From: Robert Ramey (ramey_at_[hidden])
Date: 2006-08-07 13:18:04

Guy Létourneau wrote:
> Hello Robert,
>
> Sorry for not giving you feedback earlier, I was on vacation.  I've
> included your proposed changes in my test application but I still get
> the same compile error:
>
> C:/Boost/include/boost-1_33_1/boost/archive/detail/oserializer.hpp:
> In function `void boost::archive::save(Archive&, T&) [with Archive =
> boost::archive::text_oarchive, T = const A*]':
> C:/Boost/include/boost-1_33_1/boost/archive/basic_text_oarchive.hpp:78:
> instantiated from `void
> boost::archive::basic_text_oarchive<Archive>::save_override(T&, int)
> [with T = const A*, Archive = boost::archive::text_oarchive]'
> C:/Boost/include/boost-1_33_1/boost/archive/detail/interface_oarchive.hpp:78:
> instantiated from `Archive&
> boost::archive::detail::interface_oarchive<Archive>::operator<<(T&)
> [with T = const A*, Archive = boost::archive::text_oarchive]'
> ../main.cpp:101:   instantiated from here
> C:/Boost/include/boost-1_33_1/boost/archive/detail/oserializer.hpp:567:
> error: incomplete type `boost::STATIC_ASSERTION_FAILURE<false>' does
> not have member `value'
> make: *** [main.o] Error 1
>
> Could you tell me what I'm missing?
>
> Thanks again for your help,
>
> Guy Letourneau
>
>
> Test application:
>
> #include <iostream>
> #include <fstream>
>
> #include <boost/archive/text_oarchive.hpp>
> #include <boost/archive/text_iarchive.hpp>
> #include <boost/serialization/export.hpp>
>
> class A
> {
>    public:
>
>        A()
>        {
>            i = 1;
>        };
>
>        virtual ~A()
>        {
>        };
>
>        virtual void Dummy() = 0;
>
>    private:
>
>        int i;
>
>        friend
>        class boost::serialization::access;
>
>        template <class Archive>
>        void serialize( Archive& ar, const unsigned int version )
>        {
>            std::cout << "Serialization of A" << std::endl;
>            std::cout.flush();
>        }
> };
> BOOST_IS_ABSTRACT(A)
>
>
> class B : public A
> {
>    public:
>
>        B()
>        {
>        };
>
>        virtual ~B()
>        {
>        };
>
>        void Dummy()
>        {
>        };
>
>        void SetValue( std::string& value )
>        {
>            Data = value;
>        }
>
>    private:
>
>        friend
>        class boost::serialization::access;
>
>        template <class Archive>
>        void serialize( Archive& ar, const unsigned int version )
>        {
>            ar & boost::serialization::base_object<A>( *this );
>            ar & Data;
>            std::cout << "Serialization of B" << std::endl;
>            std::cout.flush();
>        }
>
>        std::string Data;
> };
> BOOST_CLASS_EXPORT(B)
>
>
> int main()
> {
>    // Create a B object
>    B* Child = new B;
>
>    // Set some data
>    std::string Data = "test";
>    Child->SetValue( Data );
>
>    // Assign it to a A ptr

****
// >    const A* Parent = Child; // Parent is now const
// nope- Parent is not const - it points to a const A - not the same thing 
!!!
// try

    const A * const Parent = Child; // const pointer to a const A

// also the following will work - I believe

    A * const Parent = Child;
>
>    // create and open a character archive for output
>    std::ofstream ofs( "filename" );
>
>    // save data to archive
>    {
>        try
>        {
>            boost::archive::text_oarchive oa( ofs );
>            // write class instance to archive
>            oa << Parent; // Ptr dereferencing is performed by the
>        library }
>        catch( boost::archive::archive_exception& e )
>        {
>            std::cout << "Save failed! : " << e.what();
>            std::cout.flush();
>
>            return false;
>        }
>        catch( ... )
>        {
>            std::cerr << "Unknown Exception " << std::endl;
>
>            return false;
>        }
>
>    // archive and stream closed when destructors are called
>    }
>
>    delete Child;
> }
>
> -----Original Message-----
> From: boost-users-bounces_at_[hidden]
> [mailto:boost-users-bounces_at_[hidden]] On Behalf Of Robert
> Ramey
> Sent: Saturday, July 22, 2006 6:43 PM
> To: boost-users_at_[hidden]
> Subject: Re: [Boost-users] [Serialization] Problem
> serializingviabaseclassptr
>
> Three show stopping problems in this code:
>
> a) A doesn't have serialize method even though
> such a method is invoked by base object. see:
> http://www.boost.org/libs/serialization/doc/serialization.html
>
> b) saving a non-const object - see rationale section
>
> c) Main show stopper:
>
>> int main()
>> {
>>     // Create a B object
>>     B* Child = new B;
>>
>>     // Set some data
>>     std::string Data = "test";
>>     Child->SetValue( Data );
>>
>>     // Assign it to a A ptr
>>     // const A* Parent = Child;  // ****** note new const - see
>> rationale
>>
>>     // create and open a character archive for output
>>     std::ofstream ofs( "filename" );
>>
>>     // save data to archive
>>     {
>>         try
>>         {
>>             boost::archive::text_oarchive oa( ofs );
>>             // write class instance to archive
>               // *** big problem here.  Dereferecing pointer to A
> yields a
> ref
>               // *** to an A - regardless that ptr was a B.  What you
> really want is:
>                oa << Parent; // *** let serialization handle
>                dererencing // *** instead of:
>>             //oa << *Parent;
>>         }
>>         catch( boost::archive::archive_exception& e )
>>         {
>>             std::cout << "Save failed! : " << e.what();
>>             std::cout.flush();
>>
>>             return false;
>>         }
>>         catch( ... )
>>         {
>>             std::cerr << "Unknown Exception " << std::endl;
>>
>>             return false;
>>         }
>>
>>     // archive and stream closed when destructors are called
>>     }
>>
>>     delete Child;
>> }
>>
>
>
>
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users