source: XMLIO_V2/dev/dev_rv/src/xmlio/manager/tree_manager.cpp @ 173

#include "tree_manager.hpp"

#include "attribute_template_impl.hpp"
#include "object_template_impl.hpp"
#include "group_template_impl.hpp"

namespace xmlioserver
{
   namespace tree
   {
      /// ////////////////////// Définitions ////////////////////// ///

      void CTreeManager::SetCurrentContextId(const StdString & id)
      {
         CObjectFactory::SetCurrentContextId(id);
         CGroupFactory::SetCurrentContextId(id);
      }

      boost::shared_ptr<CContext> CTreeManager::CreateContext(const StdString & id)
      {
         boost::shared_ptr<CContextGroup> group_context = CContext::GetContextGroup();
         CTreeManager::SetCurrentContextId(id);
         bool hasctxt = CObjectFactory::HasObject<CContext>(id);
         
         boost::shared_ptr<tree::CContext> context =
               CObjectFactory::CreateObject<tree::CContext>(id);
         if (!hasctxt) CGroupFactory::AddChild(group_context, context);

#define DECLARE_NODE(Name_, name_) \
   CObjectFactory::CreateObject<C##Name_##Definition>(C##Name_##Definition::GetDefName());
#define DECLARE_NODE_PAR(Name_, name_)
#include "../config/node_type.conf"

         return (context);
   }

      //--------------------------------------------------------------
      void CTreeManager::PrintTreeToFile(const StdString & path)
      {
         StdOFStream ofs(path.c_str());
         CTreeManager::PrintTreeToStream(ofs);
         ofs.close();
      }

      void CTreeManager::PrintTreeToString(StdString & content)
      {
         StdOStringStream ostrstream;
         tree::CContext::ShowTree(ostrstream);
         content.assign(CIndentedXml::Indented(ostrstream.str()));
      }

      void CTreeManager::PrintTreeToStream(StdOStream & out)
      {
         StdOStringStream ostrstream;
         tree::CContext::ShowTree(ostrstream);
         out << CIndentedXml::Indented(ostrstream.str());
      }

      //--------------------------------------------------------------

      void CTreeManager::ParseFile(const StdString & filename)
      { 
         xml::CXMLParser::ParseFile(filename); 
      }

      void CTreeManager::ParseString(const StdString & xmlContent)
      { 
         xml::CXMLParser::ParseString(xmlContent); 
      }

      void CTreeManager::ParseStream(StdIStream & stream)
      { 
         xml::CXMLParser::ParseStream(stream); 
      }
      
      //--------------------------------------------------------------
      
      void CTreeManager::ToBinary(StdOStream & os)
      {
         StdString currentContextId =
            CObjectFactory::GetCurrentContextId();
         std::vector<boost::shared_ptr<CContext> > def_vector =
            CContext::GetContextGroup()->getChildList();
            
         const StdSize size = def_vector.size();         
         const ENodeType cenum = CContext::GetType();
         const ENodeType genum = CContextGroup::GetType();
         
         os.write (reinterpret_cast<const char*>(&genum) , sizeof(ENodeType)); 
         os.write (reinterpret_cast<const char*>(&size) , sizeof(StdSize));
         
         for (StdSize i = 0; i < size; i++)
         {
            boost::shared_ptr<CContext> context = def_vector[i];         
            CTreeManager::SetCurrentContextId(context->getId());                
            const bool hid = context->hasId(); // Toujours vrai
            
            os.write (reinterpret_cast<const char*>(&cenum), sizeof(ENodeType));      
            os.write (reinterpret_cast<const char*>(&hid), sizeof(bool));
            
            if (hid)
            {
               const StdString & id = context->getId();
               const StdSize size   = id.size();
                  
               os.write (reinterpret_cast<const char*>(&size), sizeof(StdSize));
               os.write (id.data(), size * sizeof(char));         
            } 
            
            context->toBinary(os);
         }
         CTreeManager::SetCurrentContextId(currentContextId);          
      }
      
      void CTreeManager::FromBinary(StdIStream & is)
      {
         StdSize ctxtnb = 0;
         ENodeType renum = Unknown;
         
         boost::shared_ptr<CContextGroup> group_context =
                           CContext::GetContextGroup();
                           
         is.read (reinterpret_cast<char*>(&renum), sizeof(StdSize));   
         is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(ENodeType));

         if (renum != CContextGroup::GetType())
            ERROR("CTreeManager::FromBinary(StdIStream & is)",
                  << "[ renum = " << renum << "] Bad type !");

         for (StdSize i = 0; i < ctxtnb; i++)
         {
            bool hid = false;
            is.read (reinterpret_cast<char*>(&renum), sizeof(tree::ENodeType));
            is.read (reinterpret_cast<char*>(&hid), sizeof(bool));
            
            if (renum != CContext::GetType())
               ERROR("CTreeManager::FromBinary(StdIStream & is)",
                     << "[ renum = " << renum << "] Bad type !");
                           
            if (hid)
            {
               StdSize size  = 0;
               is.read (reinterpret_cast<char*>(&size), sizeof(StdSize));
               StdString id(size, ' ');
               is.read (const_cast<char *>(id.data()), size * sizeof(char));
               
               CTreeManager::SetCurrentContextId(id);               
               bool hasctxt = CObjectFactory::HasObject<CContext>(id);
               
               boost::shared_ptr<CContext> context =
                  CObjectFactory::CreateObject<CContext>(id);
                  
               if (!hasctxt)
                  CGroupFactory::AddChild(group_context, context);
               context->fromBinary(is);
            }
         }
      }

      ///-------------------------------------------------------------

   } // namespace tree
} // namespace xmlioserver