object.hpp

Go to the documentation of this file.

//
// See license.txt for license information.
//
// object.hpp
//
// 15-jul-2003  phamilton  Created
//

#ifndef incCOMMON_OBJECT
#define incCOMMON_OBJECT

// forwards
#include <string>

namespace ph {
namespace common {

// forwards
class outerable_object_base;
class composition_object_base;
class deletable_object_base;
class comparable_object_base;
class visitable_object_base;
class persistable_object_base;
class cloneable_object_base;
class pretendable_object_base;
class importable_object_base;
class nameable_object_base;

class object_base
/**
        Abstract class representing an object which contains various
        interfaces used in persistance, reflection, and patterns.
        
        None of these interfaces are mandatory, so it is up to the systems 
        using them to test for the interface before using it, 
        and gracefully fail if not found.
*/
{
public:
        virtual ~object_base() {}
        
        virtual outerable_object_base *outerable()
                { return 0; }
                //!< Outerable objects contain some type of pointer to
                //! the parent object.
        virtual const outerable_object_base *outerable() const
                { return 0; }
                //!< Outerable objects contain some type of pointer to
                //! the parent object. This interface is used in circumstances
                //! where the class won't be modified.
        
        virtual composition_object_base *composition() 
                { return 0; }
                //!< Composition objects follow the Composition pattern.
                //!
        virtual const composition_object_base *composition() const 
                { return 0; }
                //!< Composition objects follow the Composition pattern. 
                //! This interface is used in circumstances
                //! where the class won't be modified.
        
        virtual deletable_object_base *deletable() 
                { return 0; }
                //!< Deletable objects use a member to delete the object rather
                //! than a destructor.
        virtual const comparable_object_base *comparable() const 
                { return 0; }
                //!< Deletable objects use a member to delete the object rather
                //! than a destructor. This interface is used in circumstances
                //! where the class won't be modified.

        virtual visitable_object_base *visitable() 
                { return 0; }
                //!< Visitable objects follow the Visitor pattern.
        virtual const visitable_object_base *visitable() const 
                { return 0; }
                //!< Visitable objects follow the Visitor pattern. This interface is used in circumstances
                //! where the class won't be modified.
        
        virtual persistable_object_base *persistable() 
                { return 0; }
                //!< Persistable objects can be written and read to some type of
                //! external storage.
        virtual const persistable_object_base *persistable() const 
                { return 0; }
                //!< Persistable objects can be written and read to some type of
                //! external storage. This interface is used in circumstances
                //! where the class won't be modified.
        
        virtual cloneable_object_base *cloneable() 
                { return 0; }
                //!< Cloneable objects allow objects to be used in the abstract
                //! factory pattern.
        virtual const cloneable_object_base *cloneable() const 
                { return 0; }
                //!< Cloneable objects allow objects to be used in the abstract
                //! factory pattern. This interface is used in circumstances
                //! where the class won't be modified.
                
        virtual pretendable_object_base *pretendable()
                { return 0; }
                //!< Pretendable objects can pretend to be other objects.
        virtual const pretendable_object_base *pretendable() const
                { return 0; }
                //!< Pretendable objects can pretend to be other objects.
                //! This interface is used in circumstances
                //! where the class won't be modified.          

        virtual importable_object_base *importable()
                { return 0; }
                //!< Importable objects can be imported.
        virtual const importable_object_base *importable() const
                { return 0; }
                //!< Importable objects can be imported.
                //! This interface is used in circumstances
                //! where the class won't be modified.          

        virtual nameable_object_base *nameable()
                { return 0; }
                //!< Nameable objects can be named.
        virtual const nameable_object_base *nameable() const
                { return 0; }
                //!< Nameable objects can be named.
                //! This interface is used in circumstances
                //! where the class won't be modified.          
};

}; // common
}; // ph

#endif // incCOMMON_OBJECT

---