D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_template_manager.h

/* LICENSE_BEGIN
SutoiTools library supply support for debugging, testing and 
setting good bases for you application. It is part of the 
SugoiEngine project.
Copyright (C) 2006 Allusse Yannick (yannick dot allusse at laposte dot net)


This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
LICENSE_END
*/

/* \file SG_TLS_cl_template_manager.h
 * \brief Template manager to manage all kind of object.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_CL_TEMPLATE_MANAGER_H
#define SG_TLS_CL_TEMPLATE_MANAGER_H

#include "SugoiTools\config.h"
#include "SugoiTools\cl_base_obj.h"
#include "SugoiTools\tools.h"
#include "SugoiTools\logger_main.h"
#include "SugoiTools\smart_ptr.h"
#include <map>  // Include algorithms

namespace SGE{
template <class T, typename P=std::string>  
          class CL_TEMPLATE_OBJECT_MANAGER
          {
          public:
                    typedef typename T *                                                            TplHdle;  
                    typedef   P&                                                                                        IDRef;              
                    typedef   const P&                                                              IDRefCst; 
                    typedef typename std::map<P,  TplHdle>  TplMap;             
                    typedef typename std::pair<P, TplHdle>  TplPair;  
                    typedef typename TplMap::iterator                           iterator; 
                    typedef   CL_TEMPLATE_OBJECT_MANAGER<T,P>                   TplManager;

          public:

          //=============================================================
          //================= Base Functions ============================
          //=============================================================
                    _SG_TLS_INLINE
                    CL_TEMPLATE_OBJECT_MANAGER(TplManager *_RemoteManager):
                              RemoteManager(_RemoteManager),//set this manager to local or remote
                              DfltObj(NULL),
                              LastAdded(0)
                    {
                    };

                    
                    _SG_TLS_INLINE 
                    ~CL_TEMPLATE_OBJECT_MANAGER   (void)
                    {
                              DeleteAllLocal();
                    };

          //=============================================================
          //================= Add Functions  ============================
          //=============================================================
          protected:
                    virtual 
                    _SG_TLS_INLINE
                              bool IsObjValide(TplHdle _Obj)
                              {
                                        if (_Obj)
                                                  return true;
                                        return false;
                              }

                    //
                    virtual 
                    _SG_TLS_INLINE
                    TplHdle CreateObj(IDRefCst _ID, std::string _ObjType="")
                              {
                                        return new T(_ID);
                              }


          public:
                    _SG_TLS_INLINE 
                    TplHdle   
                    Add(IDRefCst _ID)
                    {
                              TplHdle Obj = AddRemote(_ID);
                              if (!IsObjValide(Obj))
                                         Obj = AddLocal(_ID);
                              //else
                              SG_Assert(IsObjValide(Obj), "Could not create new object");
                              LastAdded = Obj;
                              return Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    AddObj(TplHdle _Obj)
                    {
                              TplHdle Obj = AddRemoteObj(_Obj);
                              if (!IsObjValide(Obj))
                                         Obj = AddLocalObj(_Obj);
                              //else
                              SG_Assert(IsObjValide(Obj), "Could not add existing object");
                              LastAdded = _Obj;
                              return _Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle             
                    GetLastAdded()
                    {
                              return LastAdded;
                    }

          protected:
                    _SG_TLS_INLINE 
                    TplHdle   
                    AddLocal(IDRefCst _ID)
                    {
                              TplHdle Obj = FindLocal(_ID);
                              if (IsObjValide(Obj))
                              {
                                        _SG_DEBUG_MNGR(SG_NOTICE_LOG("CL_TEMPLATE_OBJECT_MANAGER<T,P>::AddLocal()=> object already exist."));
                                        return Obj;//already exist
                              }
                              //we create it:
                              Obj = CreateObj(_ID);
                              TMap.insert( TplPair(_ID, Obj));
                              LastAdded = Obj;
                              
                              //else
                              return Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    AddLocalObj(TplHdle _Obj)
                    {
                              TplHdle Obj = FindLocal(_Obj->GetID());
                              if (IsObjValide(Obj))
                              {
                                        _SG_DEBUG_MNGR(SG_NOTICE_LOG("CL_TEMPLATE_OBJECT_MANAGER<T,P>::AddLocal()=> object already exist."));
                                        return Obj;//already exist
                              }
                              //we insert it:
                              TMap.insert(TplPair(_Obj->GetID(), _Obj));
                              LastAdded = _Obj;
                              //else
                              return _Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle
                    AddRemote(IDRefCst _ID)
                    {
                              if(!RemoteManager)
                                        return NULL;
                              return RemoteManager->Add(_ID);         //ask for remote manager
                    }

                    _SG_TLS_INLINE 
                    TplHdle
                    AddRemoteObj(TplHdle _Obj)
                    {
                              if(!RemoteManager)
                                        return NULL;
                              return RemoteManager->AddObj(_Obj);     //ask for remote manager
                    }

          //=============================================================
          //================= Find Functions ============================
          //=============================================================
          public:
                    _SG_TLS_INLINE 
                    TplHdle   
                    Find(IDRefCst _ID)
                    {
                              TplHdle Obj = FindLocal(_ID);
                              if (IsObjValide(Obj))
                                        return Obj;
                              //else
                              return FindRemote(_ID);
                    }

                    _SG_TLS_INLINE 
                    iterator
                    FindLocalPair(IDRefCst _ID)
                    {
                              return TMap.find(_ID);
                    }

          protected:
                    _SG_TLS_INLINE 
                    TplHdle   
                    FindLocal(IDRefCst _ID)
                    {
                              iterator iObj = TMap.find(_ID);
                              if (iObj!= TMap.end())
                                        return (*iObj).second;//found
                              //else
                              return NULL;
                    }

                    _SG_TLS_INLINE 
                    TplHdle
                    FindRemote(IDRefCst _ID)
                    {
                              if(!RemoteManager)
                                        return NULL;

                              return RemoteManager->Find(_ID);        //ask for remote manager
                    }


          //=============================================================
          //================= Delete Functions    =======================
          //=============================================================
                    
          public:
                    virtual _SG_TLS_INLINE  
                    size_t 
                    Delete(IDRefCst _ID)
                    {
                              TplHdle iHdle = FindLocal(_ID);
                              if (iHdle != GetDefaultObj())
                              {
                                        //delete(iHdle);//Erase the data
                                        return TMap.erase(_ID);       //erase the pair
                              }
                              return 0;
                    }

                    virtual _SG_TLS_INLINE  
                    size_t    
                    DeleteAllLocal()
                    {
                              //we delete all local TplSmartP objects containing T* objects
                              //if no other manager point to T*, the T* is deleted with the TplSmartP
                              //else only the TplSmartP is deleted

                              iterator it_T;
                              //delete all TplSmartP
                              //for ( it_T = GetFirstIter( ) ; it_T!= GetLastIter( ) ;it_T++ )
                              //        delete((*it_T).second);

                              //erase all pairs
                              size_t Nbr = TMap.size();
                              if(Nbr)
                                        TMap.clear();
                              return Nbr;
                    }

          //=============================================================
          //================= Management Functions=======================
          //=============================================================
          public:
                    _SG_TLS_INLINE 
                    TplHdle
                    Get(IDRefCst _ID)
                    {
                              TplHdle Result = Find(_ID);
                              if (!IsObjValide(Result))
                                        return DfltObj;
                              return Result;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    operator [] (IDRefCst _ID)
                    {
                              return Get(_ID);
                    }

          public:
          //        _SG_TLS_INLINE 
                    iterator
                    GetFirstIter()
                    {
                              //if (TMap.size())
                                        return TMap.begin();
                              //else
                              //        return NULL;
                    }

          //        _SG_TLS_INLINE 
                    iterator
                    GetLastIter()
                    {
                              //if (GetCount())
                                        return TMap.end();
                              //else
                              //        return NULL;
                    }

          //        _SG_TLS_INLINE 
                    TplHdle
                    GetFirstObj()
                    {
                              iterator  iObj = GetFirstIter();
                              if (iObj != GetLastIter())
                                        if (IsObjValide((*iObj).second))
                                                  return (*iObj).second;
                              
                              return NULL;
                    }

          //        _SG_TLS_INLINE 
                    TplHdle
                    GetLastObj()
                    {
                              iterator  iObj = GetLastIter();
                              if (IsObjValide((*iObj).second))
                                        return (*iObj).second;
                              else
                                        return NULL;
                    }

                    _SG_TLS_INLINE 
                    size_t
                    GetCount()
                    {
                              return TMap.size();
                    }

                    _SG_TLS_INLINE 
                    TplHdle 
                    SetDefaultObj(IDRefCst _ID)
                    {
                              return DfltObj = Add(_ID);
                    }

                    _SG_TLS_INLINE 
                    TplHdle 
                    GetDefaultObj()
                    {
                              return DfltObj;
                    }

                    _SG_TLS_INLINE 
                    void
                    PrintAllObjects()
                    {
                              iterator  iObj;
                              for (iObj = GetFirstIter(); iObj != GetLastIter(); iObj++)
                                        std::cout << "ID: " << (*iObj).second->GetIDStr() << " => " << (*iObj).second->GetValStr() <<  endl;
                    }

                    _SG_TLS_INLINE 
                    bool
                    SwapID(IDRefCst _ID1, IDRefCst _ID2)
                    {
                              iterator it1 = FindLocalPair(_ID1);
                              iterator it2 = FindLocalPair(_ID2);

                              if (it1!= TMap.end() & 
                                        it2!= TMap.end())   
                              {
                                        TplHdle TempObj = (*it1).second;
                                        
                                        (*it1).second       = (*it2).second;
                                        (*it2).second       = TempObj;

                                        P TempID = (*it1).second->ID;
                                        (*it1).second->ID = (*it1).first;
                                        (*it2).second->ID = (*it2).first;

                                        return true;
                              }
                              return false;
                    }

                    _SG_TLS_INLINE 
                    bool
                    SwapID(TplHdle _Obj1, TplHdle _Obj2)
                    {
                              return SwapID(_Obj1->ID, _Obj2->ID);
                    }


                    _SG_TLS_INLINE 
                    TplHdle   
                    UpdateID(IDRefCst _IDsrc, IDRefCst _IDnew)
                    {         
                              TplHdle Obj = NULL;
                              //if we have a remote manager, we start from here
                              if (RemoteManager)
                              {
                                        Obj = RemoteManager->UpdateID(_IDsrc,_IDnew);
                                        if (Obj)
                                        {//delete the local version
                                                  Delete(_IDsrc);
                                                  AddObj(Obj);//add the new version
                                                  return Obj;
                                        }
                                        return NULL;
                              }

                              //no Remote manager

                              //check the new ID.?
                              if(Get(_IDnew))
                                        return NULL;

                              //proceed update
                              Obj = Get(_IDsrc);
                              if(!Obj)
                                        return NULL;

                              //delete local version
                              Delete(_IDsrc);

                              //update the ID
                              Obj->SetID(_IDnew);
                              AddObj(Obj);
                              return Obj;
                    }
          private:
                    TplHdle                       LastAdded;                    
                    TplHdle                       DfltObj;            
                    TplManager *        RemoteManager;      
                    TplMap                        TMap;                         
};






template <class T, typename P=std::string>
          class CL_SMART_MANAGER :
                    public  CL_TEMPLATE_OBJECT_MANAGER<CSmartPtr<T>, P>
{
public:
          typedef   CSmartPtr<T>                                                TplSmartP;
          typedef TplSmartP                                                     TplHdle;
          typedef typename std::map<P,  TplHdle>  TplMap;
          typedef typename std::pair<P, TplHdle>  TplPair;
          typedef typename TplMap::iterator                 iterator;
          //typedef P&                                                                              IDRef;
          //typedef const P&                                                    IDRefCst;
          typedef   CL_SMART_MANAGER<T,P>         TplSmartManager;

public:
//=============================================================
//================= Base Functions ============================
//=============================================================
          _SG_TLS_INLINE
          CL_SMART_MANAGER(TplSmartManager *_RemoteManager):
                    CL_TEMPLATE_OBJECT_MANAGER<CSmartPtr<T>, P>(_RemoteManager)
          {
          };

          
          _SG_TLS_INLINE 
          ~CL_SMART_MANAGER   (void)
          {
          };

public:
          virtual 
          _SG_TLS_INLINE
                    bool IsObjValide(TplHdle _Obj)
                    {
                              return _Obj.IsValide();
                    }


//=============================================================
//================= Delete Functions    =======================
//=============================================================
          
public:
          _SG_TLS_INLINE 
          size_t 
          Delete(IDRefCst _ID)
          {
                    TplHdle iHdle = FindLocal(_ID);
                    if (iHdle != GetDefaultObj())
                    {
                              //delete(iHdle);//Erase the data
                              return TMap.erase(_ID);       //erase the pair
                    }
                    return 0;
          }

          _SG_TLS_INLINE 
          int       
          DeleteAllLocal()
          {
                    //we delete all local TplSmartP objects containing T* objects
                    //if no other manager point to T*, the T* is deleted with the TplSmartP
                    //else only the TplSmartP is deleted

                    iterator it_T;
                    //delete all TplSmartP
                    //for ( it_T = GetFirstIter( ) ; it_T!= GetLastIter( ) ;it_T++ )
                    //        delete((*it_T).second);

                    //erase all pairs
                    int Nbr = TMap.size();
                    if(Nbr)
                              TMap.clear();
                    return Nbr;
          }

};
};//namespace SGE
#endif //SG_TLS_CL_TEMPLATE_MANAGER_H

---