cloneable_object.hpp

Go to the documentation of this file.

//
// See license.txt for license information.
//
// cloneable_object.hpp
//
// 17-Jul-2003  phamilton  Created
//

#ifndef incCOMMON_CLONEABLE_OBJECT
#define incCOMMON_CLONEABLE_OBJECT

// forwards
#include <string>

namespace ph {
namespace common {

class cloneable_object_context;
class object_base;

class cloneable_object_base
/**
        Abstract class representing the interface for an object to be cloned.
        
        This is an important part of allowing objects to be used in the
        Abstract Factory pattern, which is used heavily in persistance.
*/
{
public:
        virtual ~cloneable_object_base() {}
                                
        virtual bool construct(cloneable_object_context *context) = 0;
                //!< Allow objects to construct themselves WITH inheritence.
                //! it's up to the impementation to call this on the object
                //! when it is created (or cloned from another).
                
        virtual object_base *clone(
                const std::string &name, 
                cloneable_object_context *context) const = 0;
                //!< Clone this object.
                //!
                
        virtual object_base *subclass(
                const std::string &name, 
                cloneable_object_context *context) const = 0;
                //!< Subclassing copies the object,but makes it's "type" the
                //! name of this object, and makes the "name" equal to the name passed in.
                //! This allows an object to be a virtual copy of another, except
                //! for the type identifier. This feature is used in template
                //! systems.
};

class cloneable_object_context
/**
        Abstract class representing a context that is passed when objects
        are cloned.
*/
{
public:
        virtual ~cloneable_object_context() {};
};

}; // common
}; // ph

#endif // incCOMMON_CLONEABLE_OBJECT

---