D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_tmpl_dbl_mngr.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_TMPL_DBL_MNGR.h
 * \brief Template double manager to manage all kind of object, and access them via two different ID.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_CL_TMPL_MNGR_H
#define SG_TLS_CL_TMPL_MNGR_H



#include "SugoiTools\config.h"
#include "SugoiTools\cl_base_obj.h"
#include "SugoiTools\cl_template_manager.h"
#include "SugoiTools\cl_base_dbl_obj.h"


namespace SGE{


template <class T, typename P1=std::string, typename P2=int>  
class CL_TMPL_DBL_MANAGER 

{
          public:
                    typedef typename CL_BASE_DBL_OBJ<P1, P2>          TplObj;             
                    typedef typename CL_BASE_OBJ<P1>                            TplObj1;  
                    typedef typename CL_BASE_OBJ<P2>                            TplObj2;  
                    typedef typename CL_TEMPLATE_OBJECT_MANAGER<TplObj1, P1>    TMngr1;
                    typedef typename CL_TEMPLATE_OBJECT_MANAGER<TplObj2, P2>    TMngr2;
                    typedef   typename CL_TMPL_DBL_MANAGER<T,P1, P2>  TplDblManager;
                    typedef typename TplObj *                                             TplHdle;  
                    typedef   P1&                                                                                       IDRef1;             
                    typedef   P2&                                                                                       IDRef2;             
                    typedef   P1                                                                                        IDRef1Cst;          
                    typedef   P2                                                                                        IDRef2Cst;          
                    typedef typename std::map<P1, TplObj1 *>          TplMap1;  
                    typedef typename std::map<P2, TplObj2 *>          TplMap2;  
                    typedef typename std::pair<P1,          TplObj1 *>          TplPair1; 
                    typedef typename std::pair<P2,          TplObj2 *>          TplPair2; 
                    typedef typename TplMap1::iterator                          iterator1;          
                    typedef typename TplMap2::iterator                          iterator2;          
                    

          protected :
                    TMngr1    *Mngr1;   
                    TMngr2    *Mngr2; 


          public:

                    _SG_TLS_INLINE
                    CL_TMPL_DBL_MANAGER(TplDblManager *_RemoteManager)
                    {
                              if (_RemoteManager)
                              {
                                        Mngr1 = new TMngr1(_RemoteManager->GetMngr1());
                                        Mngr2 = new TMngr2(_RemoteManager->GetMngr2());                       
                              }
                              else
                              {
                                        Mngr1 = new TMngr1(NULL);
                                        Mngr2 = new TMngr2(NULL);                         
                              }
                    }

                    _SG_TLS_INLINE 
                    ~CL_TMPL_DBL_MANAGER          (void)
                    {
                              delete Mngr1;
                              delete Mngr2;
                    };

                    _SG_TLS_INLINE 
                    TMngr1 *GetMngr1()
                    {         return Mngr1;                 }

                    _SG_TLS_INLINE 
                    TMngr2 *GetMngr2()
                    {         return Mngr2;                 }


          //=============================================================
          //================= Add Functions  ============================
          //=============================================================
                    virtual 
                    _SG_TLS_INLINE
                              bool IsObjValide(TplHdle _Obj)
                              {
                                        if (_Obj)
                                                  return true;
                                        return false;
                              }
                    _SG_TLS_INLINE 
                    TplHdle   
                    Add(IDRef1Cst _ID1, IDRef2Cst _ID2)
                    {
                              //can't ask the manager 1 and 2 to create the obj
                              //so we first look for it, and then create if manually if needed...
                              TplObj1 * Obj1 = Mngr1->Get(_ID1);
                              TplObj2 * Obj2 = Mngr2->Get(_ID2);
                              
                              if(!Obj1 && !Obj2)
                              {//create the obj and add it
                                        TplHdle Obj = new TplObj(_ID1, _ID2);
                                        Mngr1->AddObj(Obj);
                                        Mngr2->AddObj(Obj);
                              }
                              else if(Obj1 && !Obj2)
                              {
                                        Obj2 = Mngr2->AddObj(dynamic_cast<TplObj2* >(Obj1));                                      
                                        
                              }
                              else if(!Obj1 && Obj2)
                              {
                                        Obj1 = Mngr1->AddObj(dynamic_cast<TplObj1* >(Obj2));                                      
                              }

                              return (TplObj*)Obj1;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    Add(IDRef1Cst _ID1)
                    {
                              //can't ask the manager 1 
                              //so we first look for it, and then create if manually if needed...
                              TplObj1 * Obj1 = Mngr1->Get(_ID1);
                              
                              if(!Obj1)
                              {//create the obj and add it
                                        TplObj1 * Obj1 = new TplObj(_ID1);
                                        Mngr1->AddObj(Obj1);

                              }
                              return (TplObj*)Obj1;
                    }



                    _SG_TLS_INLINE 
                    TplHdle   
                    Add(IDRef2Cst _ID2)
                    {
                              //can't ask the manager 2
                              //so we first look for it, and then create if manually if needed...
                              TplObj2 * Obj2 = Mngr2->Get(_ID2);
                              
                              if(!Obj2)
                              {//create the obj and add it
                                        TplObj2 * Obj2 = new TplObj(_ID2);
                                        Mngr2->AddObj(Obj2);

                              }
                              return (TplObj*)Obj2;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    AddObj(TplHdle _Obj)
                    {
                              TplHdle Obj = Mngr1->AddObj(_Obj);
                              if (IsObjValide(Obj))
                                         Mngr2->AddObj(Obj);
                              SG_Assert(IsObjValide(Obj), "Could not add existing object");
                              return Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    UpdateID(IDRef1Cst _IDsrc, IDRef1Cst _IDnew)
                    {
                              return (TplHdle) Mngr1->UpdateID(_IDsrc, _IDnew);
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    UpdateID(IDRef2Cst _IDsrc, IDRef2Cst _IDnew)
                    {
                              return (TplHdle)Mngr2->UpdateID(_IDsrc, _IDnew);
                    }


                    _SG_TLS_INLINE 
                    TplHdle   
                    UpdateID(IDRef1Cst _ID1src, IDRef2Cst _ID2new)
                    {
                              TplObj* Obj = (TplHdle) Mngr1->Get(_ID1src);
                              TplObj2* Obj2_new = Mngr2->Get(_ID2new);

                              if(Obj2_new)//new ID exists
                                        return NULL;

                              if(!Obj)//object not found
                                        return NULL;

                              //get ID 2 for update.
                              P2 ID2old = Obj->GetID<P2>();
                              return (TplHdle)Mngr2->UpdateID(ID2old, _ID2new);
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    UpdateID(IDRef2Cst _ID2src, IDRef1Cst _ID1new)
                    {
                              TplObj* Obj = (TplHdle) Mngr2->Get(_ID2src);
                              TplObj1* Obj1_new = Mngr1->Get(_ID1new);

                              if(Obj1_new)//new ID exists
                                        return NULL;

                              if(!Obj2)//object not found
                                        return NULL;

                              //get ID 1 for update.
                              P1 ID1old = Obj->GetID<P1>();
                              return Mngr1->UpdateID(ID1old, _ID1new);
                    }

                    _SG_TLS_INLINE 
                    TplHdle             
                    GetLastAdded()
                    {
                              return Mngr1->GetLastAdded();
                    }

          //=============================================================
          //================= Find Functions ============================
          //=============================================================
          

                    _SG_TLS_INLINE 
                    TplHdle   
                    Find(IDRef1Cst _ID1)
                    {
                              TplObj1 * Obj1 = Mngr1->Find(_ID1);
                              TplHdle Obj = (TplObj*)Obj1;
                              return Obj;
                    }

                    _SG_TLS_INLINE 
                    TplHdle   
                    Find(IDRef2Cst _ID2)
                    {
                              return (TplObj*)Mngr2->Find(_ID2);
                    }

                    virtual _SG_TLS_INLINE  
                    size_t 
                    Delete(IDRef1Cst _ID1)
                    {
                              TplHdle iHdle = Find(_ID1);
                              if (iHdle)
                              {
                                        Mngr1->Delete(_ID1);
                                        CL_BASE_OBJ<P2> * Obj2 = (CL_BASE_OBJ<P2>*)iHdle->GetObj<CL_BASE_OBJ<P2> >();
                                        P2 ID2 =  Obj2->GetID();
                                        return Mngr2->Delete(ID2);
                              }
                              return 0;
                    }

                    virtual _SG_TLS_INLINE  
                    size_t 
                    Delete(IDRef2Cst _ID2)
                    {
                              TplHdle iHdle = Find(_ID2);
                              if (iHdle)
                              {
                                        Mngr2->Delete(_ID2);
                                        CL_BASE_OBJ<P1> * Obj1 = (CL_BASE_OBJ<P1>*)iHdle->GetObj<CL_BASE_OBJ<P1> >();
                                        P1 ID1 =  Obj1->GetID();
                                        return Mngr1->Delete(ID1);
                              }
                              return 0;
                    }

                    virtual _SG_TLS_INLINE  
                    size_t    
                    DeleteAllLocal()
                    {
                              Mngr1->DeleteAllLocal();
                              return Mngr2->DeleteAllLocal();;
                    }

                    _SG_TLS_INLINE 
                    TplHdle
                    Get(IDRef1Cst _ID)
                    {
                              return Find(_ID);
                    }

                    _SG_TLS_INLINE 
                    TplHdle
                    Get(IDRef2Cst _ID)
                    {
                              return Find(_ID);
                    }

                    _SG_TLS_INLINE 
                    bool
                    SwapID(IDRef1Cst _ID1, IDRef2Cst _ID2)
                    {
                              TplHdle Obj1 = Get(_ID1);
                              TplHdle Obj2 = Get(_ID2);
                              if(!Mngr1->SwapID(Obj1, Obj2))
                                        return false;
                              if(!Mngr2->SwapID(Obj1, Obj2))
                                        return false;
                              return true;
                    }

                    _SG_TLS_INLINE 
                    void
                    PrintAllObjects()
                    {
                              std::cout << "Manager 1============" << std::endl;
                              Mngr1->PrintAllObjects();
                              std::cout << "Manager 1============" << std::endl;
                              std::cout << "Manager 2============" << std::endl;
                              Mngr2->PrintAllObjects();
                              std::cout << "Manager 2============" << std::endl;
                    }
};

}




#endif

---