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

8 Feb 2007

      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