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.
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 }