CORE_MemoryStack.h

#ifndef CORE_MemoryStack_H
#define CORE_MemoryStack_H
 
//include map
#include<map>
 
 
 
template<class T>
class CORE_MemoryStack   { // class MemoryStack
    
    // ATTRIBUTES
 
    
  
    
private:
 
 
  
    // ASSOCIATIONS
private:
 
    //list of objects
    std::map<std::string,const T*> mObjects;
    
    
 
public:
    // CONSTRUCTORS
    CORE_MemoryStack() {
    }
    
    // DESTRUCTORS
    virtual ~CORE_MemoryStack(){
    }
 
 
    
   
    
public:
 
    //operator methods
    //================
 
    inline tMemSize getMemorySize() const  {
        return sizeof(*this)+getContentsMemorySize();
    }
    inline tMemSize getContentsMemorySize() const  {
        return mObjects.size()*(sizeof(tString)+sizeof(T*));
    }
public:
    inline void registerClass(const T* obj) {
        ASSERT_IN(obj!=null);
        mObjects[functions_type::pointerToString(obj)]=obj;
    }
    
    inline void unregisterClass(const T* obj) {
        ASSERT_IN(obj!=null);
        typename std::map<std::string,const T*>::iterator iter=mObjects.find(functions_type::pointerToString(obj));
        if (iter!=mObjects.end()) {
            mObjects.erase(iter);
        } 
    }
 
 
    //get methods
    //===========
 
    inline tIndex getRegistredClassesNumber() const {
        return mObjects.size(); 
    }
    
    //string representation
    //====================
    inline std::string toString() const {
        std::stringstream cstr;
        
        cstr<<"registered objects:"<<std::endl;
    
        //number of registered objects
        tInteger n=0;
        std::for_each(mObjects.cbegin(),mObjects.cend(),
                      [&](const auto& obj) {
                          cstr<<"\t"<<obj.first<<"->"<<obj.second->getIdentityString();
                          cstr<<std::endl;
                          n++;
                      });
        cstr<<"number of registered objects :"<<n<<std::endl;
        
        
        return cstr.str();
    }
};
 
#endif