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

Subject: Re: [boost] How to create a shallow copy without callingaconstructor?
From: Vicente Botet Escriba (vicente.botet_at_[hidden])
Date: 2010-01-08 05:52:15

Stefan Strasser-2 wrote:
> 
> Am Monday 04 January 2010 10:12:03 schrieb Vicente Botet Escriba:
> 
>> Stefan Strasser-2 wrote:
>> > unfortunately there is no such concept of a "deep copy" in c++ either,
>> so
>> > my
>> > approach is to use Boost.Serialization for cloning objects (or a
>> > user-supplied function).
>> > Using serialization you can decide on a case to case basis if the
>> object
>> > behind a pointer should be copied. (depending on if the type is
>> > transactional, in your case).
>> > of course, that'd introduce the Serializable requirement and I don't
>> know
>> > how
>> > well that fits into your design.
>>
>> Non , serialization don't fits my requirements as I need to use the
>> object
>> when deferred updating policy is used.
> 
> I didn't mean using the serialized stream, you can create deep copies
> using 
> Boost.Serialization: serialize the object to memory and then deserialize
> it. 
> 
> if you keep the object that was used for serialization you have a clone,
> that 
> is a deep copy by definition because boost.serialization is designed to 
> reconstruct the exact same object graph that was used for serialization.
> 
> by writing your own serialization archive you could make pointers to 
> transactional objects shared among the clones.
> 
> 
Definitely I will not use Boost.Serialization for STM.

Stefan Strasser-2 wrote:
> 
>>
>> Stefan Strasser-2 wrote:
>> > this may be different in your case though because of the requirement to
>> > derive
>> > from *_transaction_object, that could be used to detect which types
>> ought
>> > to
>> > provide a special copy constructor.
>>
>> Sorry, I don't understand how the fact the type must derive from
>> base_transaction_object can help to define the
>> has_shallow_copy_constructor.
> 
> no, the user does have to express in some detectable way that he has a 
> implemented a special copy constructor (if it is optional).
> this could be a type trait, or a special base class instead of 
> transaction_object, that can be checked for using a standard type trait. 
> (that's what I meant above).
> 
> or you could use inline friend functions like I do, because I wanted to
> avoid 
> a user-defined trait:
> 
> template<class T>
> T *clone(T const &original){
>   //default implementation
> }
> 
> class user_type{
>   friend user_type *clone(user_type const &original){
>     //user-supplied implementation
>   }
> };
> 
> int main(){
>   user_type t1;
>   other_user_type t2;
> 
>   clone(t1); //calls user-supplied implementation
>   clone(t2); //calls default implementation
> }
> 
> 
> 

Thanks for the friend to the free function hint, I will use the free
function when the class is know statically. Obviously this can not be used
when it is know at run-time so in this case I will use the virtual function.
Both functions will be needed, but the virtual function can be defined by a
mixin that call the static function.

Vicente

-- 
View this message in context: http://old.nabble.com/How-to-create-a-shallow-copy-without-calling-a-constructor--tp26994004p27074245.html
Sent from the Boost - Dev mailing list archive at Nabble.com.