Changeset 580


Ignore:
Timestamp:
03/23/15 11:29:48 (8 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.

Location:
XIOS
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • XIOS/branchs/xios-1.0/src/attribute_enum_impl.hpp

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

  • 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.