Ignore:
Timestamp:
03/23/15 11:29:48 (9 years ago)
Author:
rlacroix
Message:

Fix: getInheritedStringValue could return an incorrect value.

The non-inherited value was always used even when it was empty and inheritence should have been used.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/attribute_enum_impl.hpp

    r501 r580  
    88#include "attribute_enum.hpp" 
    99 
    10    
    1110namespace xios 
    1211{ 
    13  
    14       /// ////////////////////// Définitions ////////////////////// /// 
    15       template <class T> 
    16          CAttributeEnum<T>::CAttributeEnum(const StdString & id) 
    17          : CAttribute(id) 
    18       { /* Ne rien faire de plus */ } 
    19  
    20       template <class T> 
    21          CAttributeEnum<T>::CAttributeEnum(const StdString & id, const T_enum & value) 
    22          : CAttribute(id) 
    23       { 
    24          this->setValue(value); 
    25       } 
    26  
    27       template <class T> 
    28       CAttributeEnum<T>::CAttributeEnum(const StdString & id, 
    29                               xios_map<StdString, CAttribute*> & umap) 
    30          : CAttribute(id) 
    31       { 
    32          umap.insert(umap.end(), std::make_pair(id, this)); 
    33       } 
    34  
    35       template <class T> 
    36          CAttributeEnum<T>::CAttributeEnum 
    37             (const StdString & id, const T_enum & value, 
    38              xios_map<StdString, CAttribute*> & umap) 
    39          : CAttribute(id) 
    40       { 
    41          this->setValue(value); 
    42          umap.insert(umap.end(), std::make_pair(id, this)); 
    43       } 
    44  
    45       ///-------------------------------------------------------------- 
    46       template <class T> 
    47       void CAttributeEnum<T>::reset(void) 
    48       { 
    49          CEnum<T>::reset() ; 
    50          inheritedValue.reset() ; 
    51       } 
    52        
    53       template <class T> 
    54       typename T::t_enum CAttributeEnum<T>::getValue(void) const 
    55       { 
    56          return CEnum<T>::get() ; 
    57       } 
    58  
    59       template <class T> 
    60          string CAttributeEnum<T>::getStringValue(void) const 
    61       { 
    62          return CEnum<T>::toString() ; 
    63       } 
    64  
    65       template <class T> 
    66          void CAttributeEnum<T>::setValue(const typename T::t_enum & value) 
    67       { 
    68          CEnum<T>::set(value) ; 
    69       } 
    70  
    71     template <class T> 
    72     void CAttributeEnum<T>::set(const CAttribute& attr) 
    73     { 
    74       this->set(dynamic_cast<const CAttributeEnum<T>& >(attr)) ; 
    75     }  
    76  
    77    template <class T> 
    78     void CAttributeEnum<T>::set(const CAttributeEnum& attr) 
    79     { 
    80       CEnum<T>::set(attr) ; 
    81     }  
    82  
    83      
    84     template <class T> 
    85     void CAttributeEnum<T>::setInheritedValue(const CAttribute& attr) 
    86     { 
    87       this->setInheritedValue(dynamic_cast<const CAttributeEnum<T>& >(attr)) ; 
    88     }  
    89  
    90     template <class T> 
    91     void CAttributeEnum<T>::setInheritedValue(const CAttributeEnum& attr) 
    92     { 
    93       if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()) ; 
    94     }  
    95  
    96     template <class T> 
    97     typename T::t_enum CAttributeEnum<T>::getInheritedValue(void) const 
    98     { 
    99       if (this->isEmpty()) return inheritedValue.get() ; 
    100       else return getValue() ; 
    101     }  
    102      
    103     template <class T> 
    104     string CAttributeEnum<T>::getInheritedStringValue(void) const 
    105     { 
    106        return CEnum<T>::toString() ; 
    107        if (this->isEmpty()) return inheritedValue.toString() ; 
    108        else return CEnum<T>::toString() ; ; 
    109     } 
    110      
    111     template <class T> 
    112     bool CAttributeEnum<T>::hasInheritedValue(void) const 
    113     { 
    114       return !this->isEmpty() || !inheritedValue.isEmpty() ; 
    115     }  
    116      
    117       //--------------------------------------------------------------- 
    118  
    119       template <class T> 
    120       CAttributeEnum<T>& CAttributeEnum<T>::operator=(const T_enum & value) 
    121       { 
    122          this->setValue(value); 
    123          return *this; 
    124       } 
    125  
    126       //--------------------------------------------------------------- 
    127  
    128       template <class T> 
    129          StdString CAttributeEnum<T>::_toString(void) const 
    130       { 
    131          StdOStringStream oss; 
    132          if (!CEnum<T>::isEmpty() && this->hasId()) 
    133             oss << this->getName() << "=\"" << CEnum<T>::toString() << "\""; 
    134          return (oss.str()); 
    135       } 
    136  
    137       template <class T> 
    138          void CAttributeEnum<T>::_fromString(const StdString & str) 
    139       { 
    140         CEnum<T>::fromString(str) ; 
    141       } 
    142  
    143       template <class T> 
    144       bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
    145       { 
    146          return CEnum<T>::toBuffer(buffer) ; 
    147       } 
    148  
    149       template <class T> 
    150       bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
    151       { 
    152         return CEnum<T>::fromBuffer(buffer) ; 
    153       } 
    154  
    155       template <typename T> 
    156       void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
    157       { 
    158         CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()) ; 
    159       } 
    160        
    161       template <typename T> 
    162       void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
    163       { 
    164         CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()) ; 
    165       } 
    166        
    167       template <typename T> 
    168       void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
    169       { 
    170         CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_") ; 
    171       } 
    172   
    173       template <typename T> 
    174       void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
    175       { 
    176         CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()) ; 
    177       } 
    178  
    179       template <typename T> 
    180       void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
    181       { 
    182         CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()) ; 
    183       } 
    184        
    185       template <typename T> 
    186       void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
    187       { 
    188         CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_") ; 
    189       } 
    190   
    191       template <typename T> 
    192       void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
    193       { 
    194         CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()) ; 
    195       } 
    196  
    197       template <typename T> 
    198       void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
    199       { 
    200         CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()) ; 
    201       } 
    202   
     12  /// ////////////////////// Définitions ////////////////////// /// 
     13  template <class T> 
     14  CAttributeEnum<T>::CAttributeEnum(const StdString & id) 
     15     : CAttribute(id) 
     16  { /* Ne rien faire de plus */ } 
     17 
     18  template <class T> 
     19  CAttributeEnum<T>::CAttributeEnum(const StdString & id, const T_enum & value) 
     20     : CAttribute(id) 
     21  { 
     22     this->setValue(value); 
     23  } 
     24 
     25  template <class T> 
     26  CAttributeEnum<T>::CAttributeEnum(const StdString & id, 
     27                                    xios_map<StdString, CAttribute*> & umap) 
     28     : CAttribute(id) 
     29  { 
     30     umap.insert(umap.end(), std::make_pair(id, this)); 
     31  } 
     32 
     33  template <class T> 
     34  CAttributeEnum<T>::CAttributeEnum 
     35        (const StdString & id, const T_enum & value, 
     36         xios_map<StdString, CAttribute*> & umap) 
     37     : CAttribute(id) 
     38  { 
     39     this->setValue(value); 
     40     umap.insert(umap.end(), std::make_pair(id, this)); 
     41  } 
     42 
     43  ///-------------------------------------------------------------- 
     44  template <class T> 
     45  void CAttributeEnum<T>::reset(void) 
     46  { 
     47     CEnum<T>::reset(); 
     48     inheritedValue.reset(); 
     49  } 
     50 
     51  template <class T> 
     52  typename T::t_enum CAttributeEnum<T>::getValue(void) const 
     53  { 
     54     return CEnum<T>::get(); 
     55  } 
     56 
     57  template <class T> 
     58  string CAttributeEnum<T>::getStringValue(void) const 
     59  { 
     60     return CEnum<T>::toString(); 
     61  } 
     62 
     63  template <class T> 
     64  void CAttributeEnum<T>::setValue(const typename T::t_enum & value) 
     65  { 
     66     CEnum<T>::set(value); 
     67  } 
     68 
     69  template <class T> 
     70  void CAttributeEnum<T>::set(const CAttribute& attr) 
     71  { 
     72    this->set(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
     73  } 
     74 
     75 template <class T> 
     76  void CAttributeEnum<T>::set(const CAttributeEnum& attr) 
     77  { 
     78    CEnum<T>::set(attr); 
     79  } 
     80 
     81  template <class T> 
     82  void CAttributeEnum<T>::setInheritedValue(const CAttribute& attr) 
     83  { 
     84    this->setInheritedValue(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
     85  } 
     86 
     87  template <class T> 
     88  void CAttributeEnum<T>::setInheritedValue(const CAttributeEnum& attr) 
     89  { 
     90    if (this->isEmpty() && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()); 
     91  } 
     92 
     93  template <class T> 
     94  typename T::t_enum CAttributeEnum<T>::getInheritedValue(void) const 
     95  { 
     96    if (this->isEmpty()) return inheritedValue.get(); 
     97    else return getValue(); 
     98  } 
     99 
     100  template <class T> 
     101  string CAttributeEnum<T>::getInheritedStringValue(void) const 
     102  { 
     103     if (this->isEmpty()) return inheritedValue.toString(); 
     104     else return CEnum<T>::toString();; 
     105  } 
     106 
     107  template <class T> 
     108  bool CAttributeEnum<T>::hasInheritedValue(void) const 
     109  { 
     110    return !this->isEmpty() || !inheritedValue.isEmpty(); 
     111  } 
     112 
     113  //--------------------------------------------------------------- 
     114 
     115  template <class T> 
     116  CAttributeEnum<T>& CAttributeEnum<T>::operator=(const T_enum & value) 
     117  { 
     118     this->setValue(value); 
     119     return *this; 
     120  } 
     121 
     122  //--------------------------------------------------------------- 
     123 
     124  template <class T> 
     125  StdString CAttributeEnum<T>::_toString(void) const 
     126  { 
     127     StdOStringStream oss; 
     128     if (!CEnum<T>::isEmpty() && this->hasId()) 
     129        oss << this->getName() << "=\"" << CEnum<T>::toString() << "\""; 
     130     return (oss.str()); 
     131  } 
     132 
     133  template <class T> 
     134  void CAttributeEnum<T>::_fromString(const StdString & str) 
     135  { 
     136    CEnum<T>::fromString(str); 
     137  } 
     138 
     139  template <class T> 
     140  bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
     141  { 
     142     return CEnum<T>::toBuffer(buffer); 
     143  } 
     144 
     145  template <class T> 
     146  bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
     147  { 
     148    return CEnum<T>::fromBuffer(buffer); 
     149  } 
     150 
     151  template <typename T> 
     152  void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
     153  { 
     154    CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()); 
     155  } 
     156 
     157  template <typename T> 
     158  void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
     159  { 
     160    CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()); 
     161  } 
     162 
     163  template <typename T> 
     164  void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
     165  { 
     166    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_"); 
     167  } 
     168 
     169  template <typename T> 
     170  void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
     171  { 
     172    CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()); 
     173  } 
     174 
     175  template <typename T> 
     176  void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
     177  { 
     178    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()); 
     179  } 
     180 
     181  template <typename T> 
     182  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
     183  { 
     184    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_"); 
     185  } 
     186 
     187  template <typename T> 
     188  void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
     189  { 
     190    CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()); 
     191  } 
     192 
     193  template <typename T> 
     194  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
     195  { 
     196    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()); 
     197  } 
    203198} // namespace xios 
    204199 
Note: See TracChangeset for help on using the changeset viewer.