Changeset 750


Ignore:
Timestamp:
10/21/15 13:40:58 (6 years ago)
Author:
rlacroix
Message:

Reference macros: Reduce the visibility of some member variables and functions.

Various code simplifications and cosmetics.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/declare_ref_func.hpp

    r749 r750  
    55   \since 02 Dec 2014 
    66 
    7    \brief Macro for some functions to solve reference of base object which are used in class Domain, Axis and Field 
     7   \brief Macros to add functions used to solve references in class CDomain, CAxis and CField 
    88 */ 
    99#ifndef __XIOS_DECLARE_REF_FUNC_HPP__ 
    1010#define __XIOS_DECLARE_REF_FUNC_HPP__ 
    1111 
    12 #define DECLARE_REF_FUNC(type,name)  \ 
    13 public:                                                             \ 
    14  bool hasDirect##type##Reference(void) const;                       \ 
    15  C##type * getDirect##type##Reference(void) const;                 \ 
    16  C##type * getBase##type##Reference(void) const;                   \ 
    17  void addReference(C##type * field);                               \ 
    18  const std::vector<C##type *> & getAllReference(void) const;       \ 
    19  void removeRefInheritance();                                       \ 
    20  const StdString& getBase##type##Id(void) const;                   \ 
    21  void solveRefInheritance(bool apply = true);                             \ 
    22  void solveBaseReference(void);                                                                    \ 
    23  std::vector<C##type *> refObject;                                 \ 
    24  C##type * baseRefObject;                                          \ 
     12// Declarations 
    2513 
    26 // Defition of some function for solving reference in class Domain, Axis and Field 
     14#define DECLARE_REF_FUNC(type, name)                        \ 
     15public:                                                     \ 
     16  bool hasDirect##type##Reference(void) const;              \ 
     17  C##type* getDirect##type##Reference(void) const;          \ 
     18  C##type* getBase##type##Reference(void) const;            \ 
     19  const std::vector<C##type*>& getAllReference(void) const; \ 
     20  void removeRefInheritance();                              \ 
     21  const StdString& getBase##type##Id(void) const;           \ 
     22  void solveRefInheritance(bool apply = true);              \ 
     23  void solveBaseReference(void);                            \ 
     24                                                            \ 
     25private:                                                    \ 
     26  void addReference(C##type* _##name##_);                   \ 
     27                                                            \ 
     28  std::vector<C##type*> refObject;                          \ 
     29  C##type* baseRefObject;                                   \ 
    2730 
    28 #define DEFINE_REF_FUNC(type,name) \ 
     31// Definitions 
     32 
     33#define DEFINE_REF_FUNC(type, name)                                    \ 
    2934void C##type::solveRefInheritance(bool apply)                          \ 
    30 {                                                                     \ 
    31   std::set<C##type *> sset;                                            \ 
    32   C##type * refer_sptr;                                                 \ 
    33   C##type * refer_ptr = this;                                          \ 
    34                                                                       \ 
    35   while (refer_ptr->hasDirect##type##Reference())                        \ 
    36   {                                                                   \ 
    37      refer_sptr = refer_ptr->getDirect##type##Reference();               \ 
    38      refer_ptr  = refer_sptr;                                         \ 
    39                                                                       \ 
    40      if(sset.end() != sset.find(refer_ptr))                           \ 
    41      {                                                                \ 
    42         DEBUG (<< "Circular dependency stopped for #name object on "  \ 
    43                << "\"" + refer_ptr->getId() + "\" !");                \ 
    44         break;                                                        \ 
    45      }                                                                \ 
    46                                                                       \ 
    47      SuperClassAttribute::setAttributes(refer_ptr, apply);            \ 
    48      sset.insert(refer_ptr);                                          \ 
    49   }                                                                   \ 
    50 }                                                                     \ 
    51                                                                       \ 
     35{                                                                      \ 
     36  std::set<C##type*> sset;                                             \ 
     37  C##type* refer_ptr = this;                                           \ 
     38                                                                       \ 
     39  while (refer_ptr->hasDirect##type##Reference())                      \ 
     40  {                                                                    \ 
     41    refer_ptr = refer_ptr->getDirect##type##Reference();               \ 
     42                                                                       \ 
     43    if (sset.end() != sset.find(refer_ptr))                            \ 
     44    {                                                                  \ 
     45      DEBUG(<< "Circular dependency stopped for #name object on "      \ 
     46            << "\"" + refer_ptr->getId() + "\" !");                    \ 
     47      break;                                                           \ 
     48    }                                                                  \ 
     49                                                                       \ 
     50    SuperClassAttribute::setAttributes(refer_ptr, apply);              \ 
     51    sset.insert(refer_ptr);                                            \ 
     52  }                                                                    \ 
     53}                                                                      \ 
     54                                                                       \ 
    5255void C##type::removeRefInheritance()                                   \ 
    53 {                                                                     \ 
    54  if (this->name##_ref.isEmpty()) return;                              \ 
    55  this->clearAttribute("name##_ref");                                  \ 
    56 }                                                                     \ 
    57                                                                       \ 
     56{                                                                      \ 
     57  if (!this->name##_ref.isEmpty())                                     \ 
     58    this->name##_ref.reset();                                          \ 
     59}                                                                      \ 
     60                                                                       \ 
    5861void C##type::solveBaseReference(void)                                 \ 
    59 {                                                                     \ 
    60   std::set<C##type *> sset;                                            \ 
    61   C##type * refer_sptr;                                                 \ 
    62   C##type * refer_ptr = this;                                          \ 
    63                                                                       \ 
    64   if (this->hasDirect##type##Reference())  baseRefObject = getDirect##type##Reference(); \ 
    65   else  baseRefObject = C##type::get(this);                                         \ 
    66                                                                                    \ 
    67   while (refer_ptr->hasDirect##type##Reference())                                     \ 
    68   {                                                                                \ 
    69      refer_sptr = refer_ptr->getDirect##type##Reference();                            \ 
    70      refer_ptr  = refer_sptr;                                                      \ 
    71                                                                                    \ 
    72      if(sset.end() != sset.find(refer_ptr))                                        \ 
    73      {                                                                             \ 
    74         DEBUG (<< "Circular dependency stopped for #name object on "              \ 
    75                << "\"" + refer_ptr->getId() + "\" !");                             \ 
    76         break;                                                                     \ 
    77      }                                                                             \ 
    78                                                                                    \ 
    79      sset.insert(refer_ptr);                                                       \ 
    80   }                                                                                \ 
    81   baseRefObject = refer_ptr;                                                      \ 
    82                                                                                    \ 
    83   if (hasDirect##type##Reference()) baseRefObject->addReference(this) ;               \ 
    84 }                                                                                  \ 
    85                                                                                    \ 
    86 C##type * C##type::getDirect##type##Reference(void) const                                \ 
    87 {                                                                                  \ 
    88   if (this->name##_ref.isEmpty())                                                   \ 
    89      return (this->getBase##type##Reference());                                       \ 
    90                                                                                    \ 
    91   if (! C##type::has(this->name##_ref.getValue()))                                   \ 
    92      ERROR("C##type::getDirect##type##Reference(void)",                                \ 
    93            << "[ ref_name = " << this->name##_ref.getValue() << "]"                 \ 
    94            << " invalid #name name !");                                            \ 
    95                                                                                    \ 
    96   return (C##type::get(this->name##_ref.getValue()));                                \ 
    97 }                                                                                  \ 
    98                                                                                    \ 
    99 C##type * C##type::getBase##type##Reference(void) const                                  \ 
    100 {                                                                                  \ 
    101   return (baseRefObject);                                                          \ 
    102 }                                                                                  \ 
    103                                                                                    \ 
    104 const std::vector<C##type *>& C##type::getAllReference(void) const                    \ 
    105 {                                                                                  \ 
    106   return (refObject);                                                              \ 
    107 }                                                                                  \ 
    108                                                                                    \ 
    109 const StdString & C##type::getBase##type##Id(void) const                               \ 
    110 {                                                                                  \ 
    111   return (this->getBase##type##Reference()->getId());                                 \ 
    112 }                                                                                  \ 
    113                                                                                    \ 
    114 void C##type::addReference(C##type * _##name##_)                                           \ 
    115 {                                                                                  \ 
    116   refObject.push_back(_##name##_) ;                                                     \ 
    117 }                                                                                   \ 
    118                                                                                     \ 
    119 bool C##type::hasDirect##type##Reference(void) const                                \ 
    120 {                                                                                   \ 
    121  return (!this->name##_ref.isEmpty());                                               \ 
    122 }                                                                                   \ 
     62{                                                                      \ 
     63  std::set<C##type*> sset;                                             \ 
     64  baseRefObject = C##type::get(this);                                  \ 
     65                                                                       \ 
     66  while (baseRefObject->hasDirect##type##Reference())                  \ 
     67  {                                                                    \ 
     68    baseRefObject = baseRefObject->getDirect##type##Reference();       \ 
     69                                                                       \ 
     70    if (sset.end() != sset.find(baseRefObject))                        \ 
     71    {                                                                  \ 
     72      DEBUG(<< "Circular dependency stopped for #name object on "      \ 
     73            << "\"" + baseRefObject->getId() + "\" !");                \ 
     74      break;                                                           \ 
     75    }                                                                  \ 
     76                                                                       \ 
     77    sset.insert(baseRefObject);                                        \ 
     78  }                                                                    \ 
     79                                                                       \ 
     80  if (hasDirect##type##Reference()) baseRefObject->addReference(this); \ 
     81}                                                                      \ 
     82                                                                       \ 
     83C##type* C##type::getDirect##type##Reference(void) const               \ 
     84{                                                                      \ 
     85  if (this->name##_ref.isEmpty())                                      \ 
     86    return this->getBase##type##Reference();                           \ 
     87                                                                       \ 
     88  if (!C##type::has(this->name##_ref))                                 \ 
     89    ERROR("C##type::getDirect##type##Reference(void)",                 \ 
     90          << "[ ref_name = " << this->name##_ref.getValue() << "]"     \ 
     91          << " invalid #name name !");                                 \ 
     92                                                                       \ 
     93  return C##type::get(this->name##_ref);                               \ 
     94}                                                                      \ 
     95                                                                       \ 
     96C##type* C##type::getBase##type##Reference(void) const                 \ 
     97{                                                                      \ 
     98  return baseRefObject;                                                \ 
     99}                                                                      \ 
     100                                                                       \ 
     101const std::vector<C##type*>& C##type::getAllReference(void) const      \ 
     102{                                                                      \ 
     103  return refObject;                                                    \ 
     104}                                                                      \ 
     105                                                                       \ 
     106const StdString& C##type::getBase##type##Id(void) const                \ 
     107{                                                                      \ 
     108  return this->getBase##type##Reference()->getId();                    \ 
     109}                                                                      \ 
     110                                                                       \ 
     111void C##type::addReference(C##type* _##name##_)                        \ 
     112{                                                                      \ 
     113  refObject.push_back(_##name##_);                                     \ 
     114}                                                                      \ 
     115                                                                       \ 
     116bool C##type::hasDirect##type##Reference(void) const                   \ 
     117{                                                                      \ 
     118  return !this->name##_ref.isEmpty();                                  \ 
     119}                                                                      \ 
    123120 
    124121#endif // __XIOS_DECLARE_REF_FUNC_HPP__ 
Note: See TracChangeset for help on using the changeset viewer.