common/vector_object.hpp

Go to the documentation of this file.

//
// See license.txt for license information.
//
// vector_object.hpp
//
// 4-Jul-2003  phamilton  Created
//

#ifndef incCOMMON_VECTOR_OBJECT
#define incCOMMON_VECTOR_OBJECT

// forwards
#include <vector>
#include "object.hpp"
#include "deletable_object.hpp"
#include "outerable_object.hpp"
#include "comparable_object.hpp"
#include <boost/bind.hpp>
#include <algorithm>

namespace ph {
namespace common {

class vector_object_helper
/**
        Helper for an object which contains a vector of other objects.
*/
{
public:

        void helper_delete_object(bool owned)
        /**
                Delete the objects attached. Only deletes if the
                objects are actually owned by this.
        */
        {
                // only delete sub objects if this is owned.
                if (owned)
                        std::for_each(_vector.begin(), _vector.end(),
                                boost::bind(&helper_delete_1, _1));
                _vector.clear();
        }
        
        bool helper_add(object_base *parent, 
                        object_base *obj, bool own, bool owned)
        /**
                Add a new object to the collection.
        */
        {
                // ownership policies must match.
                if (own != owned)
                        return false;
                if (obj->outerable())
                        obj->outerable()->outer(parent);
                _vector.push_back(obj);
                return true;
        }
        
        bool helper_remove(object_base *obj)
        /**
                remove an object from the collection.
        */
        {
                std::vector<object_base *>::iterator i=std::find_if(_vector.begin(), _vector.end(),
                        boost::bind(is_equal, _1, obj));
                if (i == _vector.end())
                        return false;
                _vector.erase(i);
                return true;
        }
        
        bool helper_singleton() const
        /**
                Vectors are not singleton objects.
        */
        {
                return false;
        }
        
        bool helper_count() const
        /**
                Return the number of objects in the vector.
        */
        {
                return _vector.size();
        }
        
protected:
        std::vector<object_base *> _vector;

private:

        static void helper_delete_1(object_base *obj)
        {
                // if the object has a delete interface, then use that.
                if (obj->deletable())
                        obj->deletable()->delete_object();
                else
                        delete obj;
        }
        
        static bool is_equal(object_base *obj1, object_base *obj2)
        {
                // if the object has an equal interface, then use that.
                if (obj1->comparable())
                {
                        if (obj1->comparable()->equal(obj2))
                                return true;
                }
                else if (obj1 == obj2)
                        return true;
                        
                return false;
        }
        
};

}; // common
}; // ph

#endif // incCOMMON_VECTOR_OBJECT

---