Re: [Boost-users] Serialization of pointers with custom allocators

From: Anders Sundman (anders.sundman_at_[hidden])
Date: 2007-02-08 03:35:32

Thank you for your prompt answer.

Unfortunately, that doesn't seem to work. It doesn't matter that I pass 
a ref. to a pointer to the load_construct_data function. Since the 
library function:

template<class Archive, class T>
inline void load_construct_data_adl(
     Archive & ar,
     T * t,
     const unsigned int file_version
)

in the serialization.hpp takes a pointer, and not a pointer ref. All 
changes to the pointer it self will be lost. And the pointer passed to 
the serialize function will not be the newly created one.

Any other idéas that I could try?

Perhaps it's time to bite the bullet and implement a custom in-place 
cvCreateImage function. Thank god that it's open source.

Here is a real example that will not work:

namespace boost {
   namespace serialization {
     template<class Archive>
     void serialize(Archive & ar, _IplImage& img, unsigned int version) {
       // <<<< The img input parameter here is the old img that was
       // originally allocated and passed to load_construct_data
       ar & img.roi;
       ar & make_binary_object(img.imageData, img.imageSize);
     }

     template<class Archive>
     inline void save_construct_data(Archive & ar, const _IplImage * 
const img, const unsigned int file_version){
       ar << img->width;
       ar << img->height;
       ar << img->depth;
       ar << img->nChannels;
     }

     template<class Archive>
     inline void load_construct_data(Archive & ar, _IplImage * & img, 
const unsigned int file_version){
       int w, h, d, c;
       ar >> w;
       ar >> h;
       ar >> d;
       ar >> c;
        
       img = cvCreateImage(cvSize(w, h), d, c);  // <<< The new img I 
create here will never be passed to the serialize function
     }
   }
}

Robert Ramey skrev:
> Try avoiding the default handling that serialization uses.
> 
> template<class Archive>
> void save_image_ptr(Archive & ar, IplImage const * const iptr){
>     ar << binary_object(iptr, sizeof(IplImage));
> }
> 
> template<class Archive>
> void load_image_ptr(Archive & ar, IplImage * & iptr){
>     iptr = cvCreateImage(...);
>     ar >> binary_object(iptr, sizeof(IplImage)
> }
> 
> Robert Ramey
> 
> Anders Sundman wrote:
>> Hi!
>>
>> Is it possible to serialize a class A by pointer using a custom
>> allocator? (Not the custom in-place allocator approach).
>>
>> I'm trying to serialize the (OpenCV) class IplImage. The class is used
>> like this:
>>
>> IplImage* img = cvCreateImage(...);
>> ...
>> cvReleaseImage(&img);
>>
>> I've tried the following:
>>
>> template<class Archive>
>> inline void load_construct_data(Archive & ar, IplImage * img, const
>> unsigned int file_version){
>>   ...
>>   IplImage* tmpImg = cvCreateImage(...);
>>   memcpy(img, tmpImg, sizeof(IplImage));
>> }
>>
>> But I get exceptions later, when releasing the loaded image. As far
>> as I can tell, the image class data is identical before and after
>> serialization, so I guess that the cvCreateImage/cvReleaseImage keep
>> track of pointers somehow and things go bad when the ReleaseImage is
>> called by a pointer not returned by the CreateImage function?
>>
>> Can the allocation of the IplImage used as input to
>> load_construct_data be customized somehow?
>>
>> I also tried using an IplImage * & as input to load_construct_data:
>>
>> template<class Archive>
>> inline void load_construct_data(Archive & ar, _IplImage * & img, const
>> unsigned int file_version){
>>   _IplImage* tmpImg = cvCreateImage(...);
>>   delete img;
>>   img = tmpImg;
>> }
>>
>> But that screws up the (de)serialization.
>>
>> Any suggestions or thoughts anyone?
>>
>>
>> // Anders Sundman