Re: [boost] How to create a shallow copy without calling aconstructor?

Subject: Re: [boost] How to create a shallow copy without calling aconstructor?
From: Stefan Strasser (strasser_at_[hidden])
Date: 2010-01-02 22:55:28

Am Saturday 02 January 2010 23:34:51 schrieb vicente.botet:
>   class base_transaction_object {
>   public:
>     virtual base_transaction_object* shallow_clone() const = 0;
>     virtual void copy_state(base_transaction_object const * const) = 0;
>     virtual void cache_deallocate()=0;
>     virtual ~base_transaction_object() {};
>     ...
>   };
>
> The user can define a shallow copy himself as follows
>
> class C : public base_transaction_object {
>     C(C const& rhs, shallow_copy_t) {
>     // do a shallow copy
>     }
> public:
>   base_transaction_object* shallow_clone() {
>      C* p = reinterpret_cast<C>(new char[sizeof(C)]);
>       return new (p) C(*this, shallow_copy);
>   }
>   void copy_state(base_transaction_object const * const rhs) {
>     // do a shallow assignement
>   }
>   void cache_deallocate() {
>         delete[] reinterpret_cast<char*>(this);
>   }
> };
>
> I want to define a generic mixin that define these function, something
> like:
>
>   template <class Derived, typename Base=base_transaction_object>
>   class shallow_transaction_object : public Base
>   {
>     typedef Base base_type;
>   public:
>     base_transaction_object* shallow_clone() const {
>       Derived* p = reinterpret_cast<Derived*>( new char[sizeof(Derived)]);
>       std::memcpy(p, static_cast<Derived const*>(this), sizeof(Derived));
>       return p;
>     }
>
>     void cache_deallocate() {
>         delete[] reinterpret_cast<char*>(this);
>     }
>
>     void copy_state(base_transaction_object const * const rhs) {
>       std::memcpy(static_cast<Derived *>(this), static_cast<Derived const *
> const>(rhs), sizeof(Derived )); }
>   };
>
> So the user can just declare its own class as
>
>  class C : public shallow_transaction_object<C> {
>     // members concerning the user space
>  };
>
> Can this be done in a portable way?

depends on if you really mean portable or "defined" (by C++ standard).
I doubt memcpy()ing objects with a virtual pointer is defined, but I think 
it'll work on all implementations I know of if you always copy the most 
derived type.
what types can class C : shallow_transaction_object contain? can it contain 
pointers or is it limited to "shallow types"?
for the latter, you might want to make the decision if memcpy() can be used 
based on boost::serialization::is_bitwise_serializable.

is the object in the cache used or is it only stored to be copied back to the 
exact same position of the original object, in case the transaction fails?