Ignore:
Timestamp:
11/23/18 14:48:14 (5 years ago)
Author:
oabramkina
Message:

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_olga/src/node/domain.cpp

    r1600 r1612  
    5858 
    5959   void CDomain::assignMesh(const StdString meshName, const int nvertex) 
     60   TRY 
    6061   { 
    6162     mesh = CMesh::getMesh(meshName, nvertex); 
    6263   } 
     64   CATCH_DUMP_ATTR 
    6365 
    6466   CDomain* CDomain::createDomain() 
     67   TRY 
    6568   { 
    6669     CDomain* domain = CDomainGroup::get("domain_definition")->createChild(); 
    6770     return domain; 
    6871   } 
     72   CATCH 
    6973 
    7074   std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>(); 
    … …  
    7276 
    7377   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     78   TRY 
    7479   { 
    7580     m["zoom_domain"] = TRANS_ZOOM_DOMAIN; 
    … …  
    8186     m["extract_domain"] = TRANS_EXTRACT_DOMAIN; 
    8287   } 
     88   CATCH 
    8389 
    8490   const std::set<StdString> & CDomain::getRelFiles(void) const 
     91   TRY 
    8592   { 
    8693      return (this->relFiles); 
    8794   } 
    88  
     95   CATCH 
    8996 
    9097   /*! 
    … …  
    93100   */ 
    94101   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     102   TRY 
    95103   { 
    96104     int writtenSize; 
    … …  
    98106     return numberWrittenIndexes_[writtenSize]; 
    99107   } 
     108   CATCH_DUMP_ATTR 
    100109 
    101110   /*! 
    … …  
    104113   */ 
    105114   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     115   TRY 
    106116   { 
    107117     int writtenSize; 
    … …  
    109119     return totalNumberWrittenIndexes_[writtenSize]; 
    110120   } 
     121   CATCH_DUMP_ATTR 
    111122 
    112123   /*! 
    … …  
    115126   */ 
    116127   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     128   TRY 
    117129   { 
    118130     int writtenSize; 
    … …  
    120132     return offsetWrittenIndexes_[writtenSize]; 
    121133   } 
     134   CATCH_DUMP_ATTR 
    122135 
    123136   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     137   TRY 
    124138   { 
    125139     int writtenSize; 
    … …  
    127141     return compressedIndexToWriteOnServer[writtenSize]; 
    128142   } 
     143   CATCH_DUMP_ATTR 
    129144 
    130145   //---------------------------------------------------------------- 
    … …  
    136151    */ 
    137152   std::map<int, StdSize> CDomain::getAttributesBufferSize(CContextClient* client, bool bufferForWriting /*= false*/) 
     153   TRY 
    138154   { 
    139155 
    … …  
    176192     return attributesSizes; 
    177193   } 
     194   CATCH_DUMP_ATTR 
    178195 
    179196   //---------------------------------------------------------------- 
    180197 
    181198   bool CDomain::isEmpty(void) const 
     199   TRY 
    182200   { 
    183201     return ((this->i_index.isEmpty()) || (0 == this->i_index.numElements())); 
    184202   } 
     203   CATCH 
    185204 
    186205   //---------------------------------------------------------------- 
    187206 
    188207   bool CDomain::IsWritten(const StdString & filename) const 
     208   TRY 
    189209   { 
    190210      return (this->relFiles.find(filename) != this->relFiles.end()); 
    191211   } 
     212   CATCH 
    192213 
    193214   bool CDomain::isWrittenCompressed(const StdString& filename) const 
     215   TRY 
    194216   { 
    195217      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end()); 
    196218   } 
     219   CATCH 
    197220 
    198221   //---------------------------------------------------------------- 
    199222 
    200223   bool CDomain::isDistributed(void) const 
     224   TRY 
    201225   { 
    202226      bool distributed =  !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) || 
    … …  
    206230      return distributed; 
    207231   } 
     232   CATCH 
    208233 
    209234   //---------------------------------------------------------------- 
    … …  
    215240    */ 
    216241   bool CDomain::isCompressible(void) const 
     242   TRY 
    217243   { 
    218244      return isCompressible_; 
    219245   } 
     246   CATCH 
    220247 
    221248   void CDomain::addRelFile(const StdString & filename) 
     249   TRY 
    222250   { 
    223251      this->relFiles.insert(filename); 
    224252   } 
     253   CATCH_DUMP_ATTR 
    225254 
    226255   void CDomain::addRelFileCompressed(const StdString& filename) 
     256   TRY 
    227257   { 
    228258      this->relFilesCompressed.insert(filename); 
    229259   } 
     260   CATCH_DUMP_ATTR 
    230261 
    231262   StdString CDomain::GetName(void)   { return (StdString("domain")); } 
    … …  
    240271   */ 
    241272   bool CDomain::distributionAttributesHaveValue() const 
     273   TRY 
    242274   { 
    243275      bool hasValues = true; 
    … …  
    251283      return hasValues; 
    252284   } 
     285   CATCH 
    253286 
    254287   /*! 
    … …  
    260293   */ 
    261294   void CDomain::redistribute(int nbLocalDomain) 
     295   TRY 
    262296   { 
    263297     if (this->isRedistributed_) return; 
    … …  
    422456     checkDomain(); 
    423457   } 
     458   CATCH_DUMP_ATTR 
    424459 
    425460   /*! 
    … …  
    427462   */ 
    428463   void CDomain::fillInLonLat() 
     464   TRY 
    429465   { 
    430466     switch (type) 
    … …  
    444480     } 
    445481     completeLonLatClient() ; 
    446  
    447    } 
     482   } 
     483   CATCH_DUMP_ATTR 
    448484 
    449485   /*! 
    … …  
    453489   */ 
    454490   void CDomain::fillInRectilinearLonLat() 
     491   TRY 
    455492   { 
    456493     if (!lonvalue_rectilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty()) 
    … …  
    462499       lon_end.setValue(lonvalue_rectilinear_read_from_file(ni_glo-1)); 
    463500     } 
    464      else 
     501     else if (!hasLonInReadFile_) 
    465502     { 
    466503       if (!lonvalue_2d.isEmpty()) lonvalue_2d.free(); 
    … …  
    496533       lat_end.setValue(latvalue_rectilinear_read_from_file(nj_glo-1)); 
    497534     } 
    498      else 
     535     else if (!hasLatInReadFile_) 
    499536     { 
    500537       if (!latvalue_2d.isEmpty()) latvalue_1d.free(); 
    … …  
    521558     } 
    522559   } 
     560   CATCH_DUMP_ATTR 
    523561 
    524562    /* 
    … …  
    527565    */ 
    528566   void CDomain::fillInCurvilinearLonLat() 
     567   TRY 
    529568   { 
    530569     if (!lonvalue_curvilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty()) 
    … …  
    569608       bounds_latvalue_curvilinear_read_from_file.free(); 
    570609     } 
    571  
    572    } 
     610   } 
     611   CATCH_DUMP_ATTR 
    573612 
    574613    /* 
    … …  
    577616    */ 
    578617   void CDomain::fillInUnstructuredLonLat() 
     618   TRY 
    579619   { 
    580620     if (i_index.isEmpty()) 
    … …  
    628668     } 
    629669   } 
     670   CATCH_DUMP_ATTR 
    630671 
    631672  /* 
    … …  
    633674  */ 
    634675   void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g) 
     676   TRY 
    635677   { 
    636678     CContext* context = CContext::getCurrent(); 
    … …  
    664706      delete[] nj_g ; 
    665707   } 
     708   CATCH_DUMP_ATTR 
    666709 
    667710   void CDomain::fillInRectilinearBoundLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
    668711                                              CArray<double,2>& boundsLon, CArray<double,2>& boundsLat) 
    669    { 
     712   TRY 
     713  { 
    670714     int i,j,k; 
    671715 
    … …  
    766810      } 
    767811   } 
     812   CATCH_DUMP_ATTR 
    768813 
    769814   /* 
    … …  
    771816   */ 
    772817   void CDomain::checkDomain(void) 
     818   TRY 
    773819   { 
    774820     if (type.isEmpty()) 
    … …  
    862908     } 
    863909   } 
     910   CATCH_DUMP_ATTR 
    864911 
    865912   size_t CDomain::getGlobalWrittenSize(void) 
    … …  
    871918   // Check validity of local domain on using the combination of 3 parameters: ibegin, ni and i_index 
    872919   void CDomain::checkLocalIDomain(void) 
     920   TRY 
    873921   { 
    874922      // If ibegin and ni are provided then we use them to check the validity of local domain 
    … …  
    929977      } 
    930978   } 
     979   CATCH_DUMP_ATTR 
    931980 
    932981   // Check validity of local domain on using the combination of 3 parameters: jbegin, nj and j_index 
    933982   void CDomain::checkLocalJDomain(void) 
     983   TRY 
    934984   { 
    935985    // If jbegin and nj are provided then we use them to check the validity of local domain 
    … …  
    9801030     } 
    9811031   } 
     1032   CATCH_DUMP_ATTR 
    9821033 
    9831034   //---------------------------------------------------------------- 
    9841035 
    9851036   void CDomain::checkMask(void) 
     1037   TRY 
    9861038   { 
    9871039      if (!mask_1d.isEmpty() && !mask_2d.isEmpty()) 
    … …  
    10291081     } 
    10301082   } 
     1083   CATCH_DUMP_ATTR 
    10311084 
    10321085   //---------------------------------------------------------------- 
    10331086 
    10341087   void CDomain::checkDomainData(void) 
     1088   TRY 
    10351089   { 
    10361090      if (data_dim.isEmpty()) 
    … …  
    10721126      } 
    10731127   } 
     1128   CATCH_DUMP_ATTR 
    10741129 
    10751130   //---------------------------------------------------------------- 
    10761131 
    10771132   void CDomain::checkCompression(void) 
     1133   TRY 
    10781134   { 
    10791135     int i,j,ind; 
    … …  
    12021258      } 
    12031259   } 
     1260   CATCH_DUMP_ATTR 
    12041261 
    12051262   //---------------------------------------------------------------- 
    12061263   void CDomain::computeLocalMask(void) 
     1264   TRY 
    12071265   { 
    12081266     localMask.resize(i_index.numElements()) ; 
    … …  
    12361294     } 
    12371295   } 
     1296   CATCH_DUMP_ATTR 
    12381297 
    12391298   void CDomain::checkEligibilityForCompressedOutput(void) 
     1299   TRY 
    12401300   { 
    12411301     // We don't check if the mask or the indexes are valid here, just if they have been defined at this point. 
    12421302     isCompressible_ = !mask_1d.isEmpty() || !mask_2d.isEmpty() || !data_i_index.isEmpty(); 
    12431303   } 
     1304   CATCH_DUMP_ATTR 
    12441305 
    12451306   //---------------------------------------------------------------- 
    … …  
    12501311   */ 
    12511312   void CDomain::completeLonLatClient(void) 
     1313   TRY 
    12521314   { 
    12531315     bool lonlatValueExisted = (0 != lonvalue.numElements()) || (0 != latvalue.numElements()); 
    … …  
    13631425     } 
    13641426   } 
     1427   CATCH_DUMP_ATTR 
    13651428 
    13661429   /* 
    … …  
    13681431   */ 
    13691432   void CDomain::convertLonLatValue(void) 
     1433   TRY 
    13701434   { 
    13711435     bool lonlatValueExisted = (0 != lonvalue.numElements()) || (0 != latvalue.numElements()); 
    … …  
    14651529     } 
    14661530   } 
    1467  
     1531   CATCH_DUMP_ATTR 
    14681532 
    14691533   void CDomain::checkBounds(void) 
     1534   TRY 
    14701535   { 
    14711536     bool hasBoundValues = (0 != bounds_lonvalue.numElements()) || (0 != bounds_latvalue.numElements()); 
    … …  
    15591624     } 
    15601625   } 
     1626   CATCH_DUMP_ATTR 
    15611627 
    15621628   void CDomain::checkArea(void) 
     1629   TRY 
    15631630   { 
    15641631     bool hasAreaValue = (!areavalue.isEmpty() && 0 != areavalue.numElements()); 
    … …  
    15881655     } 
    15891656   } 
     1657   CATCH_DUMP_ATTR 
    15901658 
    15911659   void CDomain::checkLonLat() 
     1660   TRY 
    15921661   { 
    15931662     if (!hasLonLat) hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) || 
    … …  
    16491718     } 
    16501719   } 
     1720   CATCH_DUMP_ATTR 
    16511721 
    16521722   void CDomain::checkAttributesOnClientAfterTransformation() 
     1723   TRY 
    16531724   { 
    16541725     CContext* context=CContext::getCurrent() ; 
    … …  
    16651736     this->isClientAfterTransformationChecked = true; 
    16661737   } 
     1738   CATCH_DUMP_ATTR 
    16671739 
    16681740   //---------------------------------------------------------------- 
    … …  
    16701742   // This function only checks all attributes of current domain 
    16711743   void CDomain::checkAttributesOnClient() 
     1744   TRY 
    16721745   { 
    16731746     if (this->isClientChecked) return; 
    … …  
    16951768      this->isClientChecked = true; 
    16961769   } 
     1770   CATCH_DUMP_ATTR 
    16971771 
    16981772   // Send all checked attributes to server 
    16991773   void CDomain::sendCheckedAttributes() 
     1774   TRY 
    17001775   { 
    17011776     if (!this->isClientChecked) checkAttributesOnClient(); 
    … …  
    17101785     this->isChecked = true; 
    17111786   } 
     1787   CATCH_DUMP_ATTR 
    17121788 
    17131789   void CDomain::checkAttributes(void) 
     1790   TRY 
    17141791   { 
    17151792      if (this->isChecked) return; 
    … …  
    17411818      this->isChecked = true; 
    17421819   } 
     1820   CATCH_DUMP_ATTR 
    17431821 
    17441822  /*! 
    … …  
    17491827  */ 
    17501828  void CDomain::computeConnectedClients() 
     1829  TRY 
    17511830  { 
    17521831    CContext* context=CContext::getCurrent() ; 
    … …  
    18761955    } 
    18771956  } 
     1957  CATCH_DUMP_ATTR 
    18781958 
    18791959   /*! 
    … …  
    18831963   */ 
    18841964   void CDomain::computeWrittenIndex() 
     1965   TRY 
    18851966   {   
    18861967      if (computedWrittenIndex_) return; 
    … …  
    19202001      } 
    19212002   } 
     2003   CATCH_DUMP_ATTR 
    19222004 
    19232005  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     2006  TRY 
    19242007  { 
    19252008    int writtenCommSize; 
    … …  
    19892072      } 
    19902073  } 
     2074  CATCH_DUMP_ATTR 
    19912075 
    19922076  /*! 
    … …  
    19952079  */ 
    19962080  void CDomain::sendAttributes() 
     2081  TRY 
    19972082  { 
    19982083    sendDistributionAttributes(); 
    … …  
    20022087    sendDataIndex(); 
    20032088  } 
    2004  
     2089  CATCH 
    20052090  /*! 
    20062091    Send global index from client to connected client(s) 
    20072092  */ 
    20082093  void CDomain::sendIndex() 
     2094  TRY 
    20092095  { 
    20102096    int ns, n, i, j, ind, nv, idx; 
    … …  
    20492135    } 
    20502136  } 
     2137  CATCH_DUMP_ATTR 
    20512138 
    20522139  /*! 
    … …  
    20562143  */ 
    20572144  void CDomain::sendDistributionAttributes(void) 
     2145  TRY 
    20582146  { 
    20592147    std::list<CContextClient*>::iterator it; 
    … …  
    21022190    } 
    21032191  } 
     2192  CATCH_DUMP_ATTR 
    21042193 
    21052194  /*! 
    … …  
    21072196  */ 
    21082197  void CDomain::sendArea() 
     2198  TRY 
    21092199  { 
    21102200    if (!hasArea) return; 
    … …  
    21502240    } 
    21512241  } 
     2242  CATCH_DUMP_ATTR 
    21522243 
    21532244  /*! 
    … …  
    21572248  */ 
    21582249  void CDomain::sendLonLat() 
     2250  TRY 
    21592251  { 
    21602252    if (!hasLonLat) return; 
    … …  
    22452337    } 
    22462338  } 
     2339  CATCH_DUMP_ATTR 
    22472340 
    22482341  /*! 
    … …  
    22532346  */ 
    22542347  void CDomain::sendDataIndex() 
     2348  TRY 
    22552349  { 
    22562350    int ns, n, i, j, ind, nv, idx; 
    … …  
    23212415    } 
    23222416  } 
     2417  CATCH 
    23232418   
    23242419  bool CDomain::dispatchEvent(CEventServer& event) 
     2420  TRY 
    23252421  { 
    23262422    if (SuperClass::dispatchEvent(event)) return true; 
    … …  
    23602456    } 
    23612457  } 
     2458  CATCH 
    23622459 
    23632460  /*! 
    … …  
    23662463  */ 
    23672464  void CDomain::recvIndex(CEventServer& event) 
     2465  TRY 
    23682466  { 
    23692467    string domainId; 
    … …  
    23792477    get(domainId)->recvIndex(rankBuffers); 
    23802478  } 
     2479  CATCH 
    23812480 
    23822481  /*! 
    … …  
    23862485  */ 
    23872486  void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers) 
     2487  TRY 
    23882488  { 
    23892489    int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex; 
    … …  
    24452545    domainMask.resize(0); // Mask is not defined anymore on servers 
    24462546  } 
     2547  CATCH 
    24472548 
    24482549  /*! 
    … …  
    24512552  */ 
    24522553  void CDomain::recvDistributionAttributes(CEventServer& event) 
     2554  TRY 
    24532555  { 
    24542556    CBufferIn* buffer=event.subEvents.begin()->buffer; 
    … …  
    24572559    get(domainId)->recvDistributionAttributes(*buffer); 
    24582560  } 
     2561  CATCH 
    24592562 
    24602563  /*! 
    … …  
    24642567  */ 
    24652568  void CDomain::recvDistributionAttributes(CBufferIn& buffer) 
     2569  TRY 
    24662570  { 
    24672571    int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp; 
    … …  
    24792583 
    24802584  } 
    2481  
     2585 CATCH_DUMP_ATTR 
    24822586  /*! 
    24832587    Receive longitude event from clients(s) 
    … …  
    24852589  */ 
    24862590  void CDomain::recvLon(CEventServer& event) 
     2591  TRY 
    24872592  { 
    24882593    string domainId; 
    … …  
    24982603    get(domainId)->recvLon(rankBuffers); 
    24992604  } 
     2605  CATCH 
    25002606 
    25012607  /*! 
    … …  
    25042610  */ 
    25052611  void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers) 
     2612  TRY 
    25062613  { 
    25072614    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
    … …  
    25632670    } 
    25642671  } 
     2672  CATCH_DUMP_ATTR 
    25652673 
    25662674  /*! 
    … …  
    25692677  */ 
    25702678  void CDomain::recvLat(CEventServer& event) 
     2679  TRY 
    25712680  { 
    25722681    string domainId; 
    … …  
    25822691    get(domainId)->recvLat(rankBuffers); 
    25832692  } 
     2693  CATCH 
    25842694 
    25852695  /*! 
    … …  
    25882698  */ 
    25892699  void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers) 
     2700  TRY 
    25902701  { 
    25912702    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
    … …  
    26492760    } 
    26502761  } 
     2762  CATCH_DUMP_ATTR 
    26512763 
    26522764  /*! 
    … …  
    26552767  */ 
    26562768  void CDomain::recvArea(CEventServer& event) 
     2769  TRY 
    26572770  { 
    26582771    string domainId; 
    … …  
    26682781    get(domainId)->recvArea(rankBuffers); 
    26692782  } 
     2783  CATCH 
    26702784 
    26712785  /*! 
    … …  
    26742788  */ 
    26752789  void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers) 
     2790  TRY 
    26762791  { 
    26772792    int nbReceived = rankBuffers.size(), i, ind, index, lInd; 
    … …  
    27192834    } 
    27202835  } 
     2836  CATCH_DUMP_ATTR 
    27212837 
    27222838  /*! 
    … …  
    27282844  */ 
    27292845  bool CDomain::isEqual(CDomain* obj) 
     2846  TRY 
    27302847  { 
    27312848    vector<StdString> excludedAttr; 
    … …  
    27502867    return objEqual; 
    27512868  } 
     2869  CATCH_DUMP_ATTR 
    27522870 
    27532871  /*! 
    … …  
    27562874  */ 
    27572875  void CDomain::recvDataIndex(CEventServer& event) 
     2876  TRY 
    27582877  { 
    27592878    string domainId; 
    … …  
    27692888    get(domainId)->recvDataIndex(rankBuffers); 
    27702889  } 
     2890  CATCH 
    27712891 
    27722892  /*! 
    … …  
    27802900  */ 
    27812901  void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers) 
     2902  TRY 
    27822903  { 
    27832904    int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;     
    … …  
    28462967    data_jbegin.setValue(0); 
    28472968  } 
     2969  CATCH_DUMP_ATTR 
    28482970 
    28492971  CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id) 
     2972  TRY 
    28502973  { 
    28512974    transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id))); 
    28522975    return transformationMap_.back().second; 
    28532976  } 
     2977  CATCH_DUMP_ATTR 
    28542978 
    28552979  /*! 
    … …  
    28582982  */ 
    28592983  bool CDomain::hasTransformation() 
     2984  TRY 
    28602985  { 
    28612986    return (!transformationMap_.empty()); 
    28622987  } 
     2988  CATCH_DUMP_ATTR 
    28632989 
    28642990  /*! 
    … …  
    28672993  */ 
    28682994  void CDomain::setTransformations(const TransMapTypes& domTrans) 
     2995  TRY 
    28692996  { 
    28702997    transformationMap_ = domTrans; 
    28712998  } 
     2999  CATCH_DUMP_ATTR 
    28723000 
    28733001  /*! 
    … …  
    28763004  */ 
    28773005  CDomain::TransMapTypes CDomain::getAllTransformations(void) 
     3006  TRY 
    28783007  { 
    28793008    return transformationMap_; 
    28803009  } 
     3010  CATCH_DUMP_ATTR 
    28813011 
    28823012  void CDomain::duplicateTransformation(CDomain* src) 
     3013  TRY 
    28833014  { 
    28843015    if (src->hasTransformation()) 
    … …  
    28873018    } 
    28883019  } 
     3020  CATCH_DUMP_ATTR 
    28893021 
    28903022  /*! 
    … …  
    28923024   */ 
    28933025  void CDomain::solveInheritanceTransformation() 
     3026  TRY 
    28943027  { 
    28953028    if (hasTransformation() || !hasDirectDomainReference()) 
    … …  
    29083041        refDomains[i]->setTransformations(domain->getAllTransformations()); 
    29093042  } 
     3043  CATCH_DUMP_ATTR 
    29103044 
    29113045  void CDomain::setContextClient(CContextClient* contextClient) 
     3046  TRY 
    29123047  { 
    29133048    if (clientsSet.find(contextClient)==clientsSet.end()) 
    … …  
    29173052    } 
    29183053  } 
     3054  CATCH_DUMP_ATTR 
    29193055 
    29203056  /*! 
    … …  
    29243060  */ 
    29253061  void CDomain::parse(xml::CXMLNode & node) 
     3062  TRY 
    29263063  { 
    29273064    SuperClass::parse(node); 
    … …  
    29543091    } 
    29553092  } 
     3093  CATCH_DUMP_ATTR 
    29563094   //---------------------------------------------------------------- 
    29573095 
Note: See TracChangeset for help on using the changeset viewer.