D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_xml_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_xml_mngr.h
 * \brief Template manager to manage all kind of object, with XML loading and saving.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_CL_XML_MNGR_H
#define SG_TLS_CL_XML_MNGR_H

#include "SugoiTools\xml.h"
#include "SugoiTools\cl_template_manager.h"


#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new.h"
#endif 

namespace SGE{


template <class T, typename P=std::string>  
          class CL_XML_MNGR
                    :public CL_TEMPLATE_OBJECT_MANAGER<T,P>,
                    public CL_XML_OBJ 
{
public: //Definitions
          typedef  T                                                                                TplObj;
          typedef  TplObj                                                       *         TplObjHdle;
          typedef    typename CL_XML_MNGR<T, P>             TplManager;
          typedef    typename TplManager::iterator          iterator;
private:
          std::string                   SubTagName;                   
          std::string                   SubTagID;           
public:
          

          CL_XML_MNGR(TplManager *_RemoteManager,
                                                  const std::string &_TagName,
                                                  const std::string &_SubTagName, 
                                                  const std::string &_SubTagID)
                              :         CL_TEMPLATE_OBJECT_MANAGER<T,P>(_RemoteManager), 
                                        CL_XML_OBJ(_TagName),
                                        SubTagName(_SubTagName),
                                        SubTagID(_SubTagID)
                    {}

          
          ~CL_XML_MNGR()
          {};

          const std::string & 
                    GetSubTagName()const
                    {return SubTagName;};

          const std::string & 
                    GetSubTagID()const
                    {return SubTagID;}; 

          void 
                    SetSubTagName(const std::string _Name)
                    {SubTagName = _Name;};

          void 
                    SetSubTagID(const std::string _ID)
                    {SubTagID = _ID;};



#if _SG_TLS_XML
protected:
          virtual 
                    T*        
                    XMLLoadObject(TiXmlElement* _XML_Root, IDRefCst _ID, std::string _TagName, std::string Type)
                    {
                              SG_Assert(_XML_Root, "No XML Root");
                              T* NewObj;

                              if (Type!="")
                              {         
                                        NewObj = Add(_ID);//???take care of type???...not in default manager
                              }
                              else
                                        NewObj = Add(_ID);//add new obj...

                              NewObj->SetMainTag(GetSubTagName());

                              SG_Assert(NewObj, "Error creating new object");
                              NewObj->XMLLoad(_XML_Root);
                              return NewObj;
                    }
          virtual 
                    TiXmlElement*       
                    XMLLoadObjects(TiXmlElement* _XML_Root)
          {
                    //SG_NOTICE_LOG("XMLLoadObjects()");
                    if (!_XML_Root)
                              return NULL;

                    TiXmlElement*XML_MAIN = XMLGetElement(_XML_Root, SubTagName.data());
                    if (!XML_MAIN)
                              return NULL;
                    //<..>< T type name><obj>===============================
                    
                    P ID_Val;
                    std::string Type;
                    std::string SubTagName;
                    CL_TEMPLATE_OBJECT_MANAGER<T,P>::TplHdle NewObj;
                    
                    while(XML_MAIN)
                    {
                              try
                              {
                                        //Init values
                                        //XMLInitVal(ID_Val);
                                        //Name              = NULL;
                                        NewObj              = NULL;
                                        //i_Option          = 0;
                                        Type                = "";
                                        //===============
                                        
                                        //get Name and ID
                                        
                                        SubTagName = XML_MAIN->Value();

                                        if(!XMLReadVal(XML_MAIN, SubTagID.data(), ID_Val))
                                        {
                                                  //SG_Assert(, );
                                                  SG_WARNING_LOG("Parsing XML file in <SubTagID ID_Val='?'>, ID field is not specified!");
                                                  std::cout << std::endl << "MainTag :" << GetMainTag         () ;
                                                  std::cout << std::endl << "SubTag :"    << GetSubTagName() ;
                                                  std::cout << std::endl << "SubTagID :"<< GetSubTagID        () << std::endl ;
                                        }
                                        else
                                        {
                                                  XMLReadVal(XML_MAIN, "Type", Type);
                                                  XMLLoadObject(XML_MAIN, ID_Val, SubTagName, Type);
                                        }
                                        

                                        //get next element
                                        XML_MAIN=XML_MAIN->NextSiblingElement();
                              }

                              catch(CException &e)
                              {
                                        //if (ID_Val != 0)
                                        {
                                                  SG_ERROR_LOG ("Exception catched while reading XMLtag '" << GetMainTag() << "'.\n");
                                        }
                    /*else{
                                                  SG_ERROR_LOG ("Exception catched while reading XMLtag <" << ID_Val << "> in <" << GetMainTag() << ">.\n");
                                        }*/
                                        std::cerr << "Exception catched : " << e.what() << endl;

                                        if (NewObj)
                                        {
                                                  //we delete it, cause they where some errors
                                                  this->Delete(NewObj->GetID());
                                        }
                                        //we continue and get next element
                                        XML_MAIN=XML_MAIN->NextSiblingElement();
                              }
                    }
                    
                    _SG_DEBUG_MNGR (std::cout << "Mngr <" << GetMainTag() << "> " << (unsigned int)GetCount() << " obj loaded!" << endl);
                    
                    return _XML_Root;
          }


          
          virtual 
                    TiXmlElement*       
                    XMLLoadHead(TiXmlElement* _XML_Root)
          {
                    SG_Assert(GetMainTag()!="",             "Error in CL_XML_MNGR<T,P>::XMLLoadHead(), MainTag is empty.");
                    SG_Assert(GetSubTagName()!="",          "Error in CL_XML_MNGR<T,P>::XMLLoadHead(), SubTagName is empty.");
                    SG_Assert(GetSubTagID()!="",  "Error in CL_XML_MNGR<T,P>::XMLLoadHead(), SubTagID is empty.");
                    SG_Assert(_XML_Root, "Error in CL_XML_MNGR<T,P>::XMLLoadHead(), XML entry is empty.");

                    
                    TiXmlElement* XML_MAIN        = CL_XML_OBJ::XMLLoad(_XML_Root);//, GetMainTag());

                    if (!XML_MAIN)
                              return NULL;//nothing found, but no error
                    
                    //no parameters to read yet...may be later
                    return XML_MAIN;
          }

public:
          virtual 
                    TiXmlElement*       
                    XMLLoad(TiXmlElement* _XML_Root)
          {
                    //read header tag
                    TiXmlElement* XML_MAIN        = XMLLoadHead (_XML_Root);

                    if (!XML_MAIN)
                              return NULL;
                    else//load objects
                              return XMLLoadObjects(XML_MAIN);        
          }

protected:

                    virtual 
                    TiXmlElement* 
                    XMLSaveObject(TiXmlElement* _XML_Root, T* Obj)
                    {
                              SG_Assert(_XML_Root, "No XML Root");
                              SG_Assert(Obj, "No obj to save");
                              return Obj->XMLSave(_XML_Root);
                    }

                    virtual 
                    TiXmlElement*       
                    XMLSaveObjects(TiXmlElement* _XML_Root)
                    {
                              SG_Assert(_XML_Root, "No XML Root");

                              if (!GetCount())
                return NULL;

                              TiXmlElement* XML_ELM = NULL;

                                        //<..>< obj >===============================
                                        iterator i;//to manipulate the vector object

                                        //Look into the vector for the following name
                                        for ( i = GetFirstIter( ) ; i != GetLastIter( ) ; i++ )
                                        {
                                                  try
                                                  {
                                                            XML_ELM = new TiXmlElement( SubTagName.data() );
                                                            XMLWriteVal(XML_ELM, SubTagID.data(), (*i).second->GetID());
                                                            XMLSaveObject(XML_ELM,(*i).second);
                                                            _XML_Root->InsertEndChild(*XML_ELM);
                                                  }

                                                  catch(CException &e)
                                                  {
                                                            SG_ERROR_LOG ("Error while saving XMLtag '<" << 
                                                                                GetMainTag() << 
                                                                                "><" << 
                                                                                SubTagName << 
                                                                                " " <<  
                                                                                SubTagID  << 
                                                                                "?>'");
                                                            /*from object '" <<
                                                                                (*i).second->GetID() <<
                                                                                "'.\n");
*/
                                                            std::cerr << "Exception catched : " << e.what() << endl;

                                                            if (XML_ELM)//we delete it, cause they where some errors
                                                                      delete XML_ELM;
                                                            
                                                            continue;//we continue and get next element
                                                  }
                                        }
                                        _SG_DEBUG_MNGR(std::cout << "Mngr <" << GetMainTag() << "> " << (unsigned int)GetCount() << " obj saved!" << endl;);
                              return _XML_Root;                       
                    }

          virtual 
                    TiXmlElement*       
                              XMLSaveHead(TiXmlElement* _XML_Root)
                              {
                                        SG_Assert(GetMainTag()!="",             "Error in CL_XML_MNGR<T,P>::XMLSaveHead(), MainTag is empty.");
                                        SG_Assert(GetSubTagName()!="",          "Error in CL_XML_MNGR<T,P>::XMLSaveHead(), SubTagName is empty.");
                                        SG_Assert(GetSubTagID()!="",  "Error in CL_XML_MNGR<T,P>::XMLSaveHead(), SubTagID is empty.");
                                        SG_Assert(_XML_Root,                              "Error in CL_XML_MNGR<T,P>::XMLSaveHead(), XML entry is empty.");
                              
                                        TiXmlElement* XML_MAIN        = CL_XML_OBJ::XMLSave(_XML_Root);// 
                                                  //new TiXmlElement( GetMainTag().data() );
                              
                                        return XML_MAIN;
                              }
public:

          virtual 
                    TiXmlElement*       
                    XMLSave   (TiXmlElement* _XML_Root)
          {
                    if (!_XML_Root)
                              return NULL;

                    //read header tag
                    TiXmlElement* XML_MAIN        = XMLSaveHead(_XML_Root);//new TiXmlElement(GetMainTag().c_str());// XMLSaveHead (_XML_Root);

                    if (XMLSaveObjects(XML_MAIN))
                    {
                              _XML_Root->InsertEndChild(*XML_MAIN);
                              return XML_MAIN;
                    }
                    else
                    {
                              delete XML_MAIN;
                              return NULL;
                    }         
          }
#endif              //XML
};

#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new_off.h"                       //Must be the last....
#endif 

};                            //namespace SGE

#endif              //SG_TLS_CL_XML_MNGR_H

---