composition_object.hpp

Go to the documentation of this file.

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

#ifndef incCOMMON_COMPOSITION_OBJECT
#define incCOMMON_COMPOSITION_OBJECT

namespace ph {
namespace common {

class composite_object_base;

class composition_object_base
/**
        Abstract class representing a component object for composition.
        
        This class is the "Component" in the "Composite" pattern.
*/
{
public:
        virtual ~composition_object_base() {}
        
        // composite pattern
        virtual composite_object_base *composite()
                { return 0; }
        virtual const composite_object_base *composite() const
                { return 0; }
};

class composite_object_base : public composition_object_base
/**
        Abstract class representing a composite object.

        This class is the "Composite" in the "Composite" pattern.
*/
{
public:
        virtual bool add(object_base *obj, bool owned) = 0;
                //!< Add a new object to the composite object.
                //! The client passes in their understanding of the 
                //! ownership policy to make sure that it fits in with
                //! the composites ownership. If they don't match, then
                //! the object won't be added, and the client can take
                //! appropriate action.

        virtual bool remove(object_base *obj) = 0;
                //!< Remove and object from the composite.
                //! Objects which are removed are not subject
                //! to the ownership policy of the composite, since
                //! they are simply forgotten by it.
                
        virtual bool owned() const { return true; }
        virtual void owned(bool owned) { }
                //!< Return true of the collection is owned.
                //! normally this means that when the composite is deleted,
                //! the objects it contains are deleted with it, but on
                //! in a more complex system (which would need to 
                //! provide the ability to clone objects), this 
                //! could be used to provide owned/non-owned composites.
                
        virtual bool singleton() const = 0;
                //!< If the composite can only hold one value (so a second add() will
                //! fail for example), then this returns true. It is used
                //! when reflecting through composites to prevent subscripts
                //! being required.

        virtual int count() const = 0;
                //!< Return the number of objects contained in this
                //! composite object.
                
        // composite pattern
        virtual composite_object_base *composite()
                { return this; }
        virtual const composite_object_base *composite() const
                { return this; }
};

}; // common
}; // ph

#endif // incCOMMON_COMPOSITION_OBJECT

---