Ignore:
Timestamp:
04/07/11 15:04:00 (13 years ago)
Author:
hozdoba
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • XMLIO_V2/dev/dev_rv/src/xmlio/node/field.cpp

    r152 r168  
    77#include "node_type.hpp" 
    88 
    9 namespace xmlioserver 
    10 { 
    11    namespace tree 
    12    { 
    13       /// ////////////////////// Définitions ////////////////////// /// 
    14  
    15       CField::CField(void) 
    16          : CObjectTemplate<CField>(), CFieldAttributes() 
    17          , baseRefObject(), refObject(), grid(), file(), foperation(NULL) 
    18       { /* Ne rien faire de plus */ } 
    19  
    20       CField::CField(const StdString & id) 
    21          : CObjectTemplate<CField>(id), CFieldAttributes() 
    22          , baseRefObject(), refObject(), foperation(NULL) 
    23       { /* Ne rien faire de plus */ } 
    24  
    25       CField::~CField(void) 
    26       { 
    27          if (this->foperation == NULL) 
    28             delete this->foperation; 
    29       } 
    30  
    31       void CField::setRelFile(const boost::shared_ptr<CFile> _file) 
    32       { this->file = _file; } 
    33  
    34       //---------------------------------------------------------------- 
    35  
    36       StdString CField::GetName(void)   { return (StdString("field")); } 
    37       StdString CField::GetDefName(void){ return (CField::GetName()); } 
    38  
    39       boost::shared_ptr<CGrid> CField::getRelGrid(void) const 
    40       { return (this->grid); } 
    41  
    42       boost::shared_ptr<CFile> CField::getRelFile(void) const 
    43       { return (this->file); } 
    44  
    45       boost::shared_ptr<CField> CField::getDirectFieldReference(void) const 
    46       { 
    47          if (this->field_ref.isEmpty()) 
    48             return (this->getBaseFieldReference()); 
    49  
    50          if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue())) 
    51             ERROR("CField::getDirectFieldReference(void)", 
    52                   << "[ ref_name = " << this->field_ref.getValue() << "]" 
    53                   << " invalid field name !"); 
    54  
    55          return (CObjectFactory::GetObject<CField>(this->field_ref.getValue())); 
    56       } 
    57  
    58       const boost::shared_ptr<CField> 
    59          CField::getBaseFieldReference(void) const { return (baseRefObject); } 
    60  
    61       const std::vector<boost::shared_ptr<CField> > & 
    62          CField::getAllReference(void) const { return (refObject); } 
    63  
    64       const StdString & CField::getBaseFieldId(void) const 
    65       { return (this->getBaseFieldReference()->getId()); } 
    66  
    67       bool CField::hasDirectFieldReference(void) const 
    68       { return (!this->field_ref.isEmpty()); } 
    69  
    70       //---------------------------------------------------------------- 
    71  
    72       void CField::solveRefInheritance(void) 
    73       { 
    74          std::set<CField *> sset; 
    75          boost::shared_ptr<CField> refer_sptr; 
    76          CField * refer_ptr = this; 
    77          this->baseRefObject = CObjectFactory::GetObject<CField>(this); 
    78          while (refer_ptr->hasDirectFieldReference()) 
     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)) 
    79114         { 
    80             refer_sptr = refer_ptr->getDirectFieldReference(); 
    81             refer_ptr  = refer_sptr.get(); 
    82  
    83             if(sset.end() != sset.find(refer_ptr)) 
    84             { 
    85                DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur " 
    86                       << "\"" + refer_ptr->getId() + "\" !"); 
    87                break; 
    88             } 
    89  
    90             SuperClassAttribute::setAttributes(refer_ptr); 
    91             sset.insert(refer_ptr); 
    92             baseRefObject = refer_sptr; 
    93             refObject.push_back(refer_sptr); 
     115            DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur " 
     116                   << "\"" + refer_ptr->getId() + "\" !"); 
     117            break; 
    94118         } 
    95       } 
    96  
    97       //---------------------------------------------------------------- 
    98  
    99       void  CField::solveOperation(void) 
    100       { 
    101          // TODO : à compléter; 
    102       } 
    103  
    104       //---------------------------------------------------------------- 
    105  
    106       void CField::solveGridReference(void) 
    107       { 
    108          boost::shared_ptr<CDomain> domain; 
    109          boost::shared_ptr<CAxis> axis; 
    110  
     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::solveGridReference(void) 
     137   { 
     138      boost::shared_ptr<CDomain> domain; 
     139      boost::shared_ptr<CAxis> axis; 
     140 
     141      if (!domain_ref.isEmpty()) 
     142      { 
     143         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue())) 
     144            domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ; 
     145         else 
     146            ERROR("CField::solveGridReference(void)", 
     147                  << "Référence au domaine nommé \'" 
     148                  << domain_ref.getValue() << "\' incorrecte") ; 
     149      } 
     150 
     151      if (!axis_ref.isEmpty()) 
     152      { 
     153         if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue())) 
     154            axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ; 
     155         else 
     156            ERROR("CField::solveGridReference(void)", 
     157                  << "Référence à l'axe nommé \'" 
     158                  << axis_ref.getValue() <<"\' incorrecte") ; 
     159      } 
     160 
     161      if (!grid_ref.isEmpty()) 
     162      { 
     163         if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue())) 
     164            this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ; 
     165         else 
     166            ERROR("CField::solveGridReference(void)", 
     167                  << "Référence à la grille nommée \'" 
     168                  << grid_ref.getValue() << "\' incorrecte"); 
     169         if (!domain_ref.isEmpty()) 
     170            DEBUG(<< "Définition conjointe de la grille " 
     171                  << "et du domaine, la grille prévaut..." ); 
     172         if (!axis_ref.isEmpty()) 
     173            DEBUG(<< "Définition conjointe de la grille " 
     174                  << "et de l'axe vertical, la grille prévaut...") ; 
     175      } 
     176      else 
     177      { 
    111178         if (!domain_ref.isEmpty()) 
    112179         { 
    113             if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue())) 
    114                domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ; 
    115             else 
    116                ERROR("CField::solveGridReference(void)", 
    117                      << "Référence au domaine nommé \'" 
    118                      << domain_ref.getValue() << "\' incorrecte") ; 
    119          } 
    120  
    121          if (!axis_ref.isEmpty()) 
    122          { 
    123             if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue())) 
    124                axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ; 
    125             else 
    126                ERROR("CField::solveGridReference(void)", 
    127                      << "Référence à l'axe nommé \'" 
    128                      << axis_ref.getValue() <<"\' incorrecte") ; 
    129          } 
    130  
    131          if (!grid_ref.isEmpty()) 
    132          { 
    133             if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue())) 
    134                this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ; 
    135             else 
    136                ERROR("CField::solveGridReference(void)", 
    137                      << "Référence à la grille nommée \'" 
    138                      << grid_ref.getValue() << "\' incorrecte"); 
    139             if (!domain_ref.isEmpty()) 
    140                DEBUG(<< "Définition conjointe de la grille " 
    141                      << "et du domaine, la grille prévaut..." ); 
    142180            if (!axis_ref.isEmpty()) 
    143                DEBUG(<< "Définition conjointe de la grille " 
    144                      << "et de l'axe vertical, la grille prévaut...") ; 
    145          } 
    146          else 
    147          { 
    148             if (!domain_ref.isEmpty()) 
    149181            { 
    150                if (!axis_ref.isEmpty()) 
    151                { 
    152                   this->grid = CGrid::CreateGrid(domain, axis) ; 
    153                   this->grid_ref.setValue(this->grid->getId()); 
    154                } 
    155                else 
    156                { 
    157                   this->grid = CGrid::CreateGrid(domain) ; 
    158                   this->grid_ref.setValue(this->grid->getId()); 
    159                } 
     182               this->grid = CGrid::CreateGrid(domain, axis) ; 
     183               this->grid_ref.setValue(this->grid->getId()); 
    160184            } 
    161185            else 
    162186            { 
    163                ERROR("CField::solveGridReference(void)", 
    164                      << "Le domaine horizontal pour le champ X n'est pas défini"); 
     187               this->grid = CGrid::CreateGrid(domain) ; 
     188               this->grid_ref.setValue(this->grid->getId()); 
    165189            } 
    166190         } 
    167          grid->solveReference() ; 
    168       } 
     191         else 
     192         { 
     193            ERROR("CField::solveGridReference(void)", 
     194                  << "Le domaine horizontal pour le champ X n'est pas défini"); 
     195         } 
     196      } 
     197      grid->solveReference() ; 
     198   } 
     199 
    169200   } // namespace tree 
    170201 
Note: See TracChangeset for help on using the changeset viewer.