source: XMLIO_V2/dev/dev_rv/src/xmlio/node/context.cpp @ 276

Last change on this file since 276 was 276, checked in by hozdoba, 10 years ago

Corrections de bugs

File size: 10.4 KB
Line 
1#include "context.hpp"
2
3#include "tree_manager.hpp"
4
5#include "attribute_template_impl.hpp"
6#include "object_template_impl.hpp"
7#include "group_template_impl.hpp"
8
9#include "calendar_type.hpp"
10#include "duration.hpp"
11
12#include "data_treatment.hpp"
13
14namespace xmlioserver {
15namespace tree {
16   
17   /// ////////////////////// Définitions ////////////////////// ///
18
19   CContext::CContext(void)
20      : CObjectTemplate<CContext>(), CContextAttributes()
21      , calendar()
22   { /* Ne rien faire de plus */ }
23
24   CContext::CContext(const StdString & id)
25      : CObjectTemplate<CContext>(id), CContextAttributes()
26      , calendar()
27   { /* Ne rien faire de plus */ }
28
29   CContext::~CContext(void)
30   { /* Ne rien faire de plus */ }
31
32   //----------------------------------------------------------------
33
34   StdString CContext::GetName(void)   { return (StdString("context")); }
35   StdString CContext::GetDefName(void){ return (CContext::GetName()); }
36   ENodeType CContext::GetType(void)   { return (eContext); }
37
38   //----------------------------------------------------------------
39
40   boost::shared_ptr<CContextGroup> CContext::GetContextGroup(void)
41   { 
42      static boost::shared_ptr<CContextGroup> group_context
43                          (new CContextGroup(xml::CXMLNode::GetRootName()));
44      return (group_context); 
45   }
46   
47   //----------------------------------------------------------------
48   void CContext::setDataTreatment(boost::shared_ptr<data::CDataTreatment> ndatat)
49   {
50      this->datat = ndatat;
51   }
52
53   //----------------------------------------------------------------
54   boost::shared_ptr<data::CDataTreatment> CContext::getDataTreatment(void) const
55   {
56      return (this->datat);
57   }
58
59   //----------------------------------------------------------------
60
61   boost::shared_ptr<date::CCalendar> CContext::getCalendar(void) const
62   {
63      return (this->calendar);
64   }
65   
66   //----------------------------------------------------------------
67   
68   void CContext::setCalendar(boost::shared_ptr<date::CCalendar> newCalendar)
69   {
70      this->calendar = newCalendar;
71      calendar_type.setValue(this->calendar->getId());
72      start_date.setValue(this->calendar->getInitDate().toString());
73   }
74   
75   //----------------------------------------------------------------
76
77   void CContext::solveCalendar(void)
78   {
79      if (this->calendar.get() != NULL) return;
80      if (calendar_type.isEmpty() || start_date.isEmpty())
81         ERROR(" CContext::solveCalendar(void)",
82               << "[ context id = " << this->getId() << " ] "
83               << "Impossible de définir un calendrier (un attribut est manquant).");
84
85#define DECLARE_CALENDAR(MType  , mtype)                            \
86   if (calendar_type.getValue().compare(#mtype) == 0)               \
87   {                                                                \
88      this->calendar =  boost::shared_ptr<date::CCalendar>          \
89         (new date::C##MType##Calendar(start_date.getValue()));     \
90      if (!this->timestep.isEmpty())                                \
91       this->calendar->setTimeStep                                  \
92          (date::CDuration::FromString(this->timestep.getValue())); \
93      return;                                                       \
94   }
95#include "calendar_type.conf"
96
97      ERROR("CContext::solveCalendar(void)",
98            << "[ calendar_type = " << calendar_type.getValue() << " ] "
99            << "Le calendrier n'est pas définie dans le code !");
100   }
101   
102   //----------------------------------------------------------------
103
104   void CContext::parse(xml::CXMLNode & node)
105   {
106      CContext::SuperClass::parse(node);
107
108      // PARSING POUR GESTION DES ENFANTS
109      xml::THashAttributes attributes;
110
111      if (node.getElementName().compare(CContext::GetName()))
112         DEBUG("Le noeud est mal nommé mais sera traité comme un contexte !");
113
114      if (!(node.goToChildElement()))
115      {
116         DEBUG("Le context ne contient pas d'enfant !");
117      }
118      else
119      {
120         do { // Parcours des contextes pour traitement.
121
122            StdString name = node.getElementName();
123            attributes.clear();
124            attributes = node.getAttributes();
125
126            if (attributes.end() != attributes.find("id"))
127            { DEBUG(<< "Le noeud de définition possÚde un identifiant,"
128                    << " ce dernier ne sera pas pris en compte lors du traitement !"); }
129
130#define DECLARE_NODE(Name_, name_)    \
131   if (name.compare(C##Name_##Definition::GetDefName()) == 0) \
132   { CObjectFactory::CreateObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) -> parse(node); \
133   continue; }
134#define DECLARE_NODE_PAR(Name_, name_)
135#include "node_type.conf"
136            std::cout << name << std::endl;
137            DEBUG(<< "L'élément nommé \'"     << name
138                  << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId()
139                  << "\' ne représente pas une définition !");
140
141         } while (node.goToNextElement());
142
143         node.goToParentElement(); // Retour au parent
144      }
145   }
146
147   //----------------------------------------------------------------
148
149   void CContext::ShowTree(StdOStream & out)
150   {
151      StdString currentContextId =
152         CObjectFactory::GetCurrentContextId();
153      std::vector<boost::shared_ptr<CContext> > def_vector =
154         CContext::GetContextGroup()->getChildList();
155      std::vector<boost::shared_ptr<CContext> >::iterator
156         it = def_vector.begin(), end = def_vector.end();
157
158      out << "<? xml version=\"1.0\" ?>" << std::endl;
159      out << "<"  << xml::CXMLNode::GetRootName() << " >" << std::endl;
160     
161      for (; it != end; it++)
162      {
163         boost::shared_ptr<CContext> context = *it;         
164         CTreeManager::SetCurrentContextId(context->getId());         
165         out << *context << std::endl;
166      }
167     
168      out << "</" << xml::CXMLNode::GetRootName() << " >" << std::endl;
169      CTreeManager::SetCurrentContextId(currentContextId); 
170   }
171   
172   //----------------------------------------------------------------
173   
174   void CContext::toBinary(StdOStream & os) const
175   {
176      SuperClass::toBinary(os);
177       
178#define DECLARE_NODE(Name_, name_)                                         \
179   {                                                                       \
180      ENodeType renum = C##Name_##Definition::GetType();                   \
181      bool val = CObjectFactory::HasObject<C##Name_##Definition>           \
182                     (C##Name_##Definition::GetDefName());                 \
183      os.write (reinterpret_cast<const char*>(&renum), sizeof(ENodeType)); \
184      os.write (reinterpret_cast<const char*>(&val), sizeof(bool));        \
185      if (val) CObjectFactory::GetObject<C##Name_##Definition>             \
186                     (C##Name_##Definition::GetDefName())->toBinary(os);   \
187   }   
188#define DECLARE_NODE_PAR(Name_, name_)
189#include "node_type.conf"
190   }
191   
192   //----------------------------------------------------------------
193   
194   void CContext::fromBinary(StdIStream & is)
195   {
196      SuperClass::fromBinary(is);
197#define DECLARE_NODE(Name_, name_)                                         \
198   {                                                                       \
199      bool val = false;                                                    \
200      ENodeType renum = Unknown;                                           \
201      is.read (reinterpret_cast<char*>(&renum), sizeof(ENodeType));        \
202      is.read (reinterpret_cast<char*>(&val), sizeof(bool));               \
203      if (renum != C##Name_##Definition::GetType())                        \
204         ERROR("CContext::fromBinary(StdIStream & is)",                    \
205               << "[ renum = " << renum << "] Bad type !");                \
206      if (val) CObjectFactory::CreateObject<C##Name_##Definition>          \
207                   (C##Name_##Definition::GetDefName()) -> fromBinary(is); \
208   }   
209#define DECLARE_NODE_PAR(Name_, name_)
210#include "node_type.conf"
211     
212   }
213   
214   
215   //----------------------------------------------------------------
216
217   StdString CContext::toString(void) const
218   {
219      StdOStringStream oss;
220      oss << "<" << CContext::GetName()
221          << " id=\"" << this->getId() << "\" "
222          << SuperClassAttribute::toString() << ">" << std::endl;
223      if (!this->hasChild())
224      {
225         //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrémentation
226      }
227      else
228      {
229
230#define DECLARE_NODE(Name_, name_)    \
231   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
232   oss << *CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) << std::endl;
233#define DECLARE_NODE_PAR(Name_, name_)
234#include "node_type.conf"
235
236      }
237
238      oss << "</" << CContext::GetName() << " >";
239
240      return (oss.str());
241   }
242
243   //----------------------------------------------------------------
244
245   void CContext::solveDescInheritance(const CAttributeMap * const UNUSED(parent))
246   {
247#define DECLARE_NODE(Name_, name_)    \
248   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
249   CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())->solveDescInheritance();
250#define DECLARE_NODE_PAR(Name_, name_)
251#include "node_type.conf"
252   }
253
254   //----------------------------------------------------------------
255
256   bool CContext::hasChild(void) const
257   {
258      return (
259#define DECLARE_NODE(Name_, name_)    \
260   CObjectFactory::HasObject<C##Name_##Definition>  (C##Name_##Definition::GetDefName())   ||
261#define DECLARE_NODE_PAR(Name_, name_)
262#include "node_type.conf"
263      false);
264}
265
266   //----------------------------------------------------------------
267
268   void CContext::solveFieldRefInheritance(void)
269   {
270      if (!this->hasId()) return;
271      std::vector<boost::shared_ptr<CField> > allField
272               = CObjectTemplate<CField>::GetAllVectobject(this->getId());
273      std::vector<boost::shared_ptr<CField> >::iterator
274         it = allField.begin(), end = allField.end();
275           
276      for (; it != end; it++)
277      {
278         boost::shared_ptr<CField> field = *it;
279         field->solveRefInheritance();
280      }
281   }
282
283   //----------------------------------------------------------------
284
285   void CContext::CleanTree(void)
286   {
287#define DECLARE_NODE(Name_, name_) C##Name_##Group::ClearAllAttributes();
288#define DECLARE_NODE_PAR(Name_, name_)
289#include "node_type.conf"
290   }
291   ///---------------------------------------------------------------
292
293} // namespace tree
294} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.