Changeset 175

Timestamp:

04/14/11 10:46:37 (13 years ago)

Author:

hozdoba

Message:

 

Location:

XMLIO_V2/dev/dev_rv/src/xmlio

Files:

• main_server.cpp (modified) (2 diffs)
• manager/tree_manager.cpp (modified) (1 diff)
• manager/tree_manager.hpp (modified) (1 diff)

XMLIO_V2/dev/dev_rv/src/xmlio/main_server.cpp

@@ -14 +14 @@
       comm::CMPIManager::Initialise(&argc, &argv); // < seulement en mode connecté
 
-      /*CTreeManager::ParseFile  ("test/iodef_simple_test.xml");
+      //CTreeManager::ParseFile  ("test/iodef_simple_test.xml");
             
-      StdOFStream ofs("data/data.bin");
+      /*StdOFStream ofs("data/data.bin");
       CTreeManager::ToBinary(ofs);
-      ofs.close();*/
+      ofs.close();
+      
+      StdOFStream ofs_("data/data_domain.bin");
+      CTreeManager::DomainsToBinary(ofs_);
+      ofs_.close();*/
       
       StdIFStream ifs("data/data.bin");    
@@ -24 +28 @@
       ifs.close();
       
-      StdIFStream ifss("data/data.bin");    
-      CTreeManager::FromBinary(ifss);
+      StdIFStream ifss("data/data_domain.bin");    
+      CTreeManager::DomainsFromBinary(ifss);
       ifss.close();
       

XMLIO_V2/dev/dev_rv/src/xmlio/manager/tree_manager.cpp

@@ -157 +157 @@
          }
       }
+      
+      //--------------------------------------------------------------
+      
+      void CTreeManager::DomainsToBinary  (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();
+         const ENodeType denum = CDomain::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));         
+            } 
+            
+            std::vector<boost::shared_ptr<CDomain> > & alldomain = 
+               CDomain::GetAllVectobject(context->getId());
+            const StdSize alldomain_size = alldomain.size(); 
+            
+            os.write (reinterpret_cast<const char*>(&alldomain_size), sizeof(StdSize));
+            
+            for (StdSize j = 0; j < alldomain_size; j++)
+            {
+               boost::shared_ptr<CDomain> domain = alldomain[j];
+               bool hid = domain->hasId();
+               
+               os.write (reinterpret_cast<const char*>(&denum), sizeof(ENodeType)); 
+               os.write (reinterpret_cast<const char*>(&hid), sizeof(bool));
+               
+               if (hid)
+               {
+                  const StdString & id = domain->getId();
+                  const StdSize idsize   = id.size();
+                     
+                  os.write (reinterpret_cast<const char*>(&idsize), sizeof(StdSize));
+                  os.write (id.data(), idsize * sizeof(char));         
+               }         
+               domain->toBinary(os);
+               
+            }
+         }
+         CTreeManager::SetCurrentContextId(currentContextId); 
+         
+      }
+      
+      void CTreeManager::DomainsFromBinary(StdIStream & is)
+      {
+         StdSize ctxtnb = 0;
+         ENodeType renum = Unknown;
+         
+         boost::shared_ptr<CContextGroup> group_context =
+                           CContext::GetContextGroup();
+         std::vector<boost::shared_ptr<CContext> > def_vector =
+            CContext::GetContextGroup()->getChildList();
+            
+         const StdSize size = def_vector.size();  
+                  
+         is.read (reinterpret_cast<char*>(&renum), sizeof(StdSize));   
+         is.read (reinterpret_cast<char*>(&ctxtnb), sizeof(ENodeType));
+
+         if (renum != CContextGroup::GetType())
+            ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
+                  << "[ renum = " << renum << "] Bad type !");
+                  
+         if (size != ctxtnb)
+            ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
+                  << "[ size = " << size << "] Bad context group size !");
+                  
+         for (StdSize i = 0; i < ctxtnb; i++)
+         {
+            boost::shared_ptr<CContext> context = def_vector[i];
+            bool hid = false;
+            is.read (reinterpret_cast<char*>(&renum), sizeof(ENodeType));
+            is.read (reinterpret_cast<char*>(&hid), sizeof(bool));
+            
+            if (renum != CContext::GetType())
+               ERROR("CTreeManager::DomainsFromBinary(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);
+            }
+            
+            std::vector<boost::shared_ptr<CDomain> > & alldomain = 
+               CDomain::GetAllVectobject(context->getId());
+            const StdSize alldomain_size = alldomain.size(); 
+            StdSize read_alldomain_size = 0; 
+            
+            is.read (reinterpret_cast<char*>(&read_alldomain_size), sizeof(StdSize));
+            
+            if (alldomain_size != read_alldomain_size)
+               ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
+                     << "[ read_alldomain_size = " << read_alldomain_size 
+                     << "] Bad domain group size !");
+                     
+            for (StdSize j = 0; j < alldomain_size; j++)
+            {
+               boost::shared_ptr<CDomain> domain = alldomain[j];
+               bool hid = domain->hasId();
+               ENodeType rrenum = Unknown;
+               
+               is.read (reinterpret_cast<char*>(&rrenum), sizeof(ENodeType));
+               is.read (reinterpret_cast<char*>(&hid), sizeof(bool));
+               
+               if (rrenum != CDomain::GetType())
+                  ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
+                        << "[ rrenum = " << rrenum << "] 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));
+                  
+                  if (domain->getId().compare(id) != 0)
+                     ERROR("CTreeManager::DomainsFromBinary(StdIStream & is)",
+                           << "[ id = " << id << "] Bad id !"); 
+               }
+               domain->fromBinary(is);
+            }
+         }
+      }
 
       ///-------------------------------------------------------------

XMLIO_V2/dev/dev_rv/src/xmlio/manager/tree_manager.hpp

@@ -37 +37 @@
             static void ToBinary  (StdOStream & os);
             static void FromBinary(StdIStream & is);
+            
+            static void DomainsToBinary  (StdOStream & os);
+            static void DomainsFromBinary(StdIStream & is);
 
       }; // class CTreeManager