source: XMLIO_V2/dev/dev_rv/src/xmlio/node/field.cpp @ 181

Last change on this file since 181 was 181, checked in by hozdoba, 12 years ago
File size: 7.7 KB
Line 
1#include "field.hpp"
2
3#include "attribute_template_impl.hpp"
4#include "object_template_impl.hpp"
5#include "group_template_impl.hpp"
6
7#include "node_type.hpp"
8
9namespace xmlioserver{
10namespace tree {
11   
12   /// ////////////////////// Définitions ////////////////////// ///
13
14   CField::CField(void)
15      : CObjectTemplate<CField>(), CFieldAttributes()
16      , baseRefObject(), refObject(), grid(), file(), foperation(NULL)
17   { /* Ne rien faire de plus */ }
18
19   CField::CField(const StdString & id)
20      : CObjectTemplate<CField>(id), CFieldAttributes()
21      , baseRefObject(), refObject(), foperation(NULL)
22   { /* Ne rien faire de plus */ }
23
24   CField::~CField(void)
25   {
26      if (this->foperation == NULL)
27         delete this->foperation;
28   }
29
30   //----------------------------------------------------------------
31
32   void CField::setRelFile(const boost::shared_ptr<CFile> _file)
33   { 
34      this->file = _file; 
35   }
36
37   //----------------------------------------------------------------
38
39   StdString CField::GetName(void)   { return (StdString("field")); }
40   StdString CField::GetDefName(void){ return (CField::GetName()); }
41   ENodeType CField::GetType(void)   { return (eField); }
42
43   //----------------------------------------------------------------
44
45   boost::shared_ptr<CGrid> CField::getRelGrid(void) const
46   { 
47      return (this->grid); 
48   }
49
50   //----------------------------------------------------------------
51
52   boost::shared_ptr<CFile> CField::getRelFile(void) const
53   { 
54      return (this->file);
55   }
56
57   //----------------------------------------------------------------
58
59   boost::shared_ptr<CField> CField::getDirectFieldReference(void) const
60   {
61      if (this->field_ref.isEmpty())
62         return (this->getBaseFieldReference());
63
64      if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue()))
65         ERROR("CField::getDirectFieldReference(void)",
66               << "[ ref_name = " << this->field_ref.getValue() << "]"
67               << " invalid field name !");
68
69      return (CObjectFactory::GetObject<CField>(this->field_ref.getValue()));
70   }
71
72   //----------------------------------------------------------------
73
74   const boost::shared_ptr<CField> CField::getBaseFieldReference(void) const
75   { 
76      return (baseRefObject); 
77   }
78
79   //----------------------------------------------------------------
80
81   const std::vector<boost::shared_ptr<CField> > & CField::getAllReference(void) const 
82   { 
83      return (refObject);
84   }
85
86   //----------------------------------------------------------------
87
88   const StdString & CField::getBaseFieldId(void) const
89   { 
90      return (this->getBaseFieldReference()->getId());
91   }
92
93   //----------------------------------------------------------------
94
95   bool CField::hasDirectFieldReference(void) const
96   { 
97      return (!this->field_ref.isEmpty()); 
98   }
99
100   //----------------------------------------------------------------
101
102   void CField::solveRefInheritance(void)
103   {
104      std::set<CField *> sset;
105      boost::shared_ptr<CField> refer_sptr;
106      CField * refer_ptr = this;
107      this->baseRefObject = CObjectFactory::GetObject<CField>(this);
108      while (refer_ptr->hasDirectFieldReference())
109      {
110         refer_sptr = refer_ptr->getDirectFieldReference();
111         refer_ptr  = refer_sptr.get();
112
113         if(sset.end() != sset.find(refer_ptr))
114         {
115            DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur "
116                   << "\"" + refer_ptr->getId() + "\" !");
117            break;
118         }
119
120         SuperClassAttribute::setAttributes(refer_ptr);
121         sset.insert(refer_ptr);
122         baseRefObject = refer_sptr;
123         refObject.push_back(refer_sptr);
124      }
125   }
126
127   //----------------------------------------------------------------
128
129   void  CField::solveOperation(void)
130   {
131      // TODO : à compléter;
132   }
133   
134   //----------------------------------------------------------------
135   
136   void CField::fromBinary(StdIStream & is)
137   {
138      SuperClass::fromBinary(is);
139#define CLEAR_ATT(name_)\
140      SuperClassAttribute::operator[](#name_)->clear()
141
142         CLEAR_ATT(domain_ref);
143         CLEAR_ATT(axis_ref);
144#undef CLEAR_ATT
145
146   }
147
148   //----------------------------------------------------------------
149
150   void CField::solveGridReference(void)
151   {
152      boost::shared_ptr<CDomain> domain;
153      boost::shared_ptr<CAxis> axis;
154
155      if (!domain_ref.isEmpty())
156      {
157         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
158            domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
159         else
160            ERROR("CField::solveGridReference(void)",
161                  << "Référence au domaine nommé \'"
162                  << domain_ref.getValue() << "\' incorrecte") ;
163      }
164
165      if (!axis_ref.isEmpty())
166      {
167         if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue()))
168            axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
169         else
170            ERROR("CField::solveGridReference(void)",
171                  << "Référence à l'axe nommé \'"
172                  << axis_ref.getValue() <<"\' incorrecte") ;
173      }
174
175      if (!grid_ref.isEmpty())
176      {
177         if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue()))
178            this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ;
179         else
180            ERROR("CField::solveGridReference(void)",
181                  << "Référence à la grille nommée \'"
182                  << grid_ref.getValue() << "\' incorrecte");
183         if (!domain_ref.isEmpty())
184            DEBUG(<< "Définition conjointe de la grille "
185                  << "et du domaine, la grille prévaut..." );
186         if (!axis_ref.isEmpty())
187            DEBUG(<< "Définition conjointe de la grille "
188                  << "et de l'axe vertical, la grille prévaut...") ;
189      }
190      else
191      {
192         if (!domain_ref.isEmpty())
193         {
194            if (!axis_ref.isEmpty())
195            {
196               this->grid = CGrid::CreateGrid(domain, axis) ;
197               this->grid_ref.setValue(this->grid->getId());
198            }
199            else
200            {
201               this->grid = CGrid::CreateGrid(domain) ;
202               this->grid_ref.setValue(this->grid->getId());
203            }
204         }
205         else
206         {
207            ERROR("CField::solveGridReference(void)",
208                  << "Le domaine horizontal pour le champ X n'est pas défini");
209         }
210      }
211      grid->solveReference() ;
212   }
213
214   } // namespace tree
215
216   ///-------------------------------------------------------------------
217
218   template <>
219      void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
220   {
221      if (this->group_ref.isEmpty()) return;
222      StdString gref = this->group_ref.getValue();
223
224      if (!CObjectFactory::HasObject<CFieldGroup>(gref))
225         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
226               << "[ gref = " << gref << "]"
227               << " invalid group name !");
228
229      boost::shared_ptr<CFieldGroup> group
230               = CObjectFactory::GetObject<CFieldGroup>(gref);
231      boost::shared_ptr<CFieldGroup> owner
232               = CObjectFactory::GetObject<CFieldGroup>
233                  (boost::polymorphic_downcast<CFieldGroup*>(this));
234
235      std::vector<boost::shared_ptr<CField> > allChildren  = group->getAllChildren();
236      std::vector<boost::shared_ptr<CField> >::iterator
237         it = allChildren.begin(), end = allChildren.end();
238     
239      for (; it != end; it++)
240      {
241         boost::shared_ptr<CField> child = *it;
242         if (child->hasId())
243            CGroupFactory::CreateChild(owner)->field_ref.setValue(child->getId());
244      }
245   }
246
247   ///-------------------------------------------------------------------
248
249} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.