hdicoreMemory.h

#ifndef __HDI_CORE_MEMORY__
#define __HDI_CORE_MEMORY__
 
#include <list>
#include <map>
#include <set>
#include <vector>
 
namespace hdi
{
    namespace core
    {
        template <typename Contained>
        void cleanupList(std::list< Contained* >& l_)
        {
            for(typename std::list< Contained* >::iterator iter = l_.begin(); iter != l_.end(); ++iter)
            {
                delete (*iter);
                (*iter) = NULL;
            }
            
            l_.clear();
        }
        
        template <typename Contained>
        void cleanupSet(std::set< Contained* >& s_)
        {
            for(typename std::set< Contained* >::iterator iter = s_.begin(); iter != s_.end(); ++iter)
            {
                delete (*iter);
//              (*iter) = NULL;
            }
            
            s_.clear();
        }
        
        template <typename Contained>
        void cleanupVector(std::vector< Contained* >& v_)
        {
            for(typename std::vector< Contained* >::iterator iter = v_.begin(); iter != v_.end(); ++iter)
            {
                delete (*iter);
                (*iter) = NULL;
            }
            
            v_.clear();
        }
        
        template <typename Contained1, typename Contained2>
        void cleanupMap(std::map< Contained1, Contained2* >& m_)
        {
            for(typename std::map< Contained1, Contained2* >::iterator iter = m_.begin(); iter != m_.end(); ++iter)
            {
                delete iter->second;
                iter->second = NULL;
            }
            
            m_.clear();
        }
        
        template <typename Contained1, typename Contained2>
        void cleanupMap(std::map< Contained1*, Contained2 >& m_)
        {
            for(typename std::map< Contained1*, Contained2 >::iterator iter = m_.begin(); iter != m_.end(); ++iter)
            {
                delete iter->first;
                // iter->first = NULL;
            }
            
            m_.clear();
        }
        
        template <typename Contained1, typename Contained2>
        void cleanupMap(std::map< Contained1*, Contained2* >& m_)
        {
            for(typename std::map< Contained1*, Contained2* >::iterator iter = m_.begin(); iter != m_.end(); ++iter)
            {
                delete iter->first;
                // iter->first = NULL;
                
                delete iter->second;
                iter->second = NULL;
            }
            
            m_.clear();
        }
    }
}
 
#endif
// __HDI_CORE_MEMORY__