src/MEDMEM_I/MEDMEM_Field_i.cxx

   1 //=============================================================================
   2 // File      : MEDMEM_Field_i.cxx
   3 // Created   : mer fév 20 15:47:57 CET 2002
   4 // Author    : EDF
   5 // Project   : SALOME
   6 // Copyright : EDF 2002
   7 // $Header: /export/home/PAL/MED_SRC/src/MEDMEM_I/MEDMEM_Field_i.cxx
   8 //=============================================================================
   9 #include "MEDMEM_Field_i.hxx"
  10
  11 using namespace MEDMEM;
  12 using namespace MED_EN;
  13
  14 map < int, ::FIELD_ * > FIELD_i::fieldMap ;
  15 int  FIELD_i::fieldIndex = 0;
  16 //=============================================================================
  17 /*!
  18  * Default constructor
  19  */
  20 //=============================================================================
  21
  22 //FIELD_i::FIELD_i():_fieldTptr(FIELD_i::constructConstField())
  23 FIELD_i::FIELD_i():_fieldTptr(constructConstField()),_corbaIndex(FIELD_i::fieldIndex++)
  24 {
  25         BEGIN_OF("Default Constructor Field_i");
  26         END_OF(" Default Constructor Field_i");
  27 }
  28 //=============================================================================
  29 /*!
  30  * Destructor
  31  */
  32 //=============================================================================
  33 FIELD_i::~FIELD_i()
  34 {
  35   if (_ownCppPtr) delete _fieldTptr;
  36 }
  37 //=============================================================================
  38 /*!
  39  * Constructor
  40  */
  41 //=============================================================================
  42 FIELD_i::FIELD_i(::FIELD_ * const field, bool ownCppPtr):
  43   _fieldTptr(field),
  44   _corbaIndex(FIELD_i::fieldIndex++),
  45   _FieldId(""),
  46   _ownCppPtr(ownCppPtr)
  47 {
  48   BEGIN_OF("Constructor FIELD_i(SALOME_MED::SUPPORT_ptr support,::FIELD<T> * const field)");
  49   FIELD_i::fieldMap[_corbaIndex]=_fieldTptr;
  50
  51   MESSAGE("FIELD_i::FIELD_i  Checking of pointeurs !!!");
  52
  53   SCRUTE(_fieldTptr);
  54
  55   END_OF("Constructor FIELD_i(SALOME_MED::SUPPORT_ptr support,::FIELD<T> * const field)");
  56 }
  57
  58 //=============================================================================
  59 /*!
  60  * Constructor par recopie
  61  */
  62 //=============================================================================
  63 FIELD_i::FIELD_i( FIELD_i & f):_fieldTptr(f._fieldTptr),
  64                                _corbaIndex(FIELD_i::fieldIndex++),
  65                                _FieldId(""), _ownCppPtr(false)
  66 {
  67         BEGIN_OF("Constructor Field_i");
  68         FIELD_i::fieldMap[_corbaIndex]=_fieldTptr;
  69         END_OF("Constructor Field_i");
  70 }
  71 //=============================================================================
  72 /*!
  73  * Constructor d un pointeur constant
  74  */
  75 //=============================================================================
  76  ::FIELD_ * FIELD_i::constructConstField() const
  77 {
  78         ::FIELD_ * const ptrField =new ::FIELD_();
  79         return ptrField;
  80 }
  81 //=============================================================================
  82 /*!
  83  * CORBA: Accessor for Fields's Name
  84  */
  85 //=============================================================================
  86 char * FIELD_i::getName()
  87 throw (SALOME::SALOME_Exception)
  88 {
  89         if (_fieldTptr==NULL)
  90                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
  91                                              SALOME::INTERNAL_ERROR);
  92         try
  93         {
  94                 return CORBA::string_dup(_fieldTptr->getName().c_str());
  95         }
  96         catch (MEDEXCEPTION &ex)
  97         {
  98                 MESSAGE("Exception en accedant au nom");
  99                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 100         }
 101 }
 102 //=============================================================================
 103 /*!
 104  * CORBA: Accessor for Fields's Description
 105  */
 106 //=============================================================================
 107 char * FIELD_i::getDescription()
 108 throw (SALOME::SALOME_Exception)
 109 {
 110         if (_fieldTptr==NULL)
 111                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 112                                              SALOME::INTERNAL_ERROR);
 113         try
 114         {
 115                 return CORBA::string_dup(_fieldTptr->getDescription().c_str());
 116         }
 117         catch (MEDEXCEPTION &ex)
 118         {
 119                 MESSAGE("Exception en accedant a la description");
 120                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 121         }
 122 }
 123 //=============================================================================
 124 /*!
 125  * CORBA: Accessor for Fields's Support
 126  */
 127 //=============================================================================
 128
 129 SALOME_MED::SUPPORT_ptr FIELD_i::getSupport()
 130   throw (SALOME::SALOME_Exception)
 131 {
 132   BEGIN_OF("SALOME_MED::SUPPORT_ptr FIELD_i::getSupport()");
 133
 134   if (_fieldTptr==NULL)
 135     THROW_SALOME_CORBA_EXCEPTION("No associated Field",
 136                                  SALOME::INTERNAL_ERROR);
 137
 138   SUPPORT_i* servant = new SUPPORT_i(_fieldTptr->getSupport());
 139
 140   SALOME_MED::SUPPORT_ptr support=servant->_this();
 141
 142   SCRUTE(_fieldTptr);
 143
 144   END_OF("SALOME_MED::SUPPORT_ptr FIELD_i::getSupport()");
 145
 146   return support ;
 147 }
 148 //=============================================================================
 149 /*!
 150  * CORBA: Accessor for Fields's Number of components
 151  */
 152 //=============================================================================
 153 CORBA::Long FIELD_i::getNumberOfComponents()
 154 throw (SALOME::SALOME_Exception)
 155 {
 156         if (_fieldTptr==NULL)
 157                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 158                                              SALOME::INTERNAL_ERROR);
 159         try
 160         {
 161                 return _fieldTptr->getNumberOfComponents();
 162         }
 163         catch (MEDEXCEPTION &ex)
 164         {
 165                 MESSAGE("Exception en accedant au support");
 166                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 167         }
 168 }
 169 //=============================================================================
 170 /*!
 171  * CORBA: Accessor for names of component I
 172  */
 173 //=============================================================================
 174 char * FIELD_i::getComponentName(CORBA::Long i)
 175 throw (SALOME::SALOME_Exception)
 176 {
 177         if (_fieldTptr==NULL)
 178                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 179                                              SALOME::INTERNAL_ERROR);
 180         try
 181         {
 182                 return CORBA::string_dup(_fieldTptr->getComponentName(i).c_str());
 183         }
 184         catch (MEDEXCEPTION &ex)
 185         {
 186                 MESSAGE("Exception en accedant au nom d un component");
 187                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 188         }
 189 }
 190 //=============================================================================
 191 /*!
 192  * CORBA: Accessor for unit of component I
 193  */
 194 //=============================================================================
 195 char * FIELD_i::getComponentUnit(CORBA::Long i)
 196 throw (SALOME::SALOME_Exception)
 197 {
 198         if (_fieldTptr==NULL)
 199                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 200                                              SALOME::INTERNAL_ERROR);
 201         try
 202         {
 203                 return CORBA::string_dup(_fieldTptr->getMEDComponentUnit(i).c_str());
 204         }
 205         catch (MEDEXCEPTION &ex)
 206         {
 207                 MESSAGE("Exception en accedant au nom d un component");
 208                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 209         }
 210 }
 211 //=============================================================================
 212 /*!
 213  * CORBA: Accessor for description of component I
 214  */
 215 //=============================================================================
 216 char * FIELD_i::getComponentDescription(CORBA::Long i)
 217 throw (SALOME::SALOME_Exception)
 218 {
 219         if (_fieldTptr==NULL)
 220                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 221                                              SALOME::INTERNAL_ERROR);
 222         try
 223         {
 224                 return CORBA::string_dup(_fieldTptr->getComponentDescription(i).c_str());
 225         }
 226         catch (MEDEXCEPTION &ex)
 227         {
 228                 MESSAGE("Exception en accedant a la description d un component");
 229                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 230         }
 231 }
 232 //=============================================================================
 233 /*!
 234  * CORBA: Accessor for iteration number
 235  */
 236 //=============================================================================
 237 CORBA::Long FIELD_i::getIterationNumber()
 238 throw (SALOME::SALOME_Exception)
 239 {
 240         if (_fieldTptr==NULL)
 241                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 242                                              SALOME::INTERNAL_ERROR);
 243         try
 244         {
 245                 return _fieldTptr->getIterationNumber();
 246         }
 247         catch (MEDEXCEPTION &ex)
 248         {
 249                 MESSAGE("Exception en accedant au champ");
 250                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 251         }
 252 }
 253 //=============================================================================
 254 /*!
 255  * CORBA: Accessor for Corba Number
 256  */
 257 //=============================================================================
 258 CORBA::Long FIELD_i::getCorbaIndex()
 259 throw (SALOME::SALOME_Exception)
 260 {
 261         if (_fieldTptr==NULL)
 262                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 263                                              SALOME::INTERNAL_ERROR);
 264         return _corbaIndex;
 265
 266 }
 267 //=============================================================================
 268 /*!
 269  * CORBA: Accessor for iteration number
 270  */
 271 //=============================================================================
 272 CORBA::Long FIELD_i::getOrderNumber()
 273 throw (SALOME::SALOME_Exception)
 274 {
 275         if (_fieldTptr==NULL)
 276                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 277                                              SALOME::INTERNAL_ERROR);
 278         try
 279         {
 280                 return _fieldTptr->getOrderNumber();
 281         }
 282         catch (MEDEXCEPTION &ex)
 283         {
 284                 MESSAGE("Exception en accedant au champ");
 285                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 286         }
 287 }
 288 //=============================================================================
 289 /*!
 290  * CORBA: Accessor
 291  */
 292 //=============================================================================
 293 CORBA::Double FIELD_i::getTime()
 294 throw (SALOME::SALOME_Exception)
 295 {
 296         if (_fieldTptr==NULL)
 297                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 298                                              SALOME::INTERNAL_ERROR);
 299         try
 300         {
 301                 return _fieldTptr->getTime();
 302         }
 303         catch (MEDEXCEPTION &ex)
 304         {
 305                 MESSAGE("Exception en accedant au champ");
 306                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 307         }
 308 }
 309 //=============================================================================
 310 /*!
 311  * CORBA: Accessor for Fields's Components names
 312  */
 313 //=============================================================================
 314 SALOME_MED::string_array * FIELD_i::getComponentsNames()
 315 throw (SALOME::SALOME_Exception)
 316 {
 317         if (_fieldTptr==NULL)
 318                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 319                                              SALOME::INTERNAL_ERROR);
 320         SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
 321         try
 322         {
 323                 int nbcom = _fieldTptr->getNumberOfComponents();
 324                 myseq->length(nbcom);
 325                 const string * namecom=_fieldTptr->getComponentsNames();
 326                 for (int i=0;i<nbcom;i++)
 327                 {
 328                         myseq[i]=CORBA::string_dup(namecom[i].c_str());
 329                 }
 330         }
 331         catch (MEDEXCEPTION &ex)
 332         {
 333                 MESSAGE("Exception en accedant au champ");
 334                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 335         }
 336         return myseq._retn();
 337 }
 338 //=============================================================================
 339 /*!
 340  * CORBA: Accessor for Fields's Components units
 341  */
 342 //=============================================================================
 343 SALOME_MED::string_array * FIELD_i::getComponentsUnits()
 344 throw (SALOME::SALOME_Exception)
 345 {
 346         if (_fieldTptr==NULL)
 347                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 348                                              SALOME::INTERNAL_ERROR);
 349         SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
 350         try
 351         {
 352                 int nbcom = _fieldTptr->getNumberOfComponents();
 353                 myseq->length(nbcom);
 354                 const string * unitcom=_fieldTptr->getMEDComponentsUnits();
 355                 for (int i=0;i<nbcom;i++)
 356                 {
 357                         myseq[i]=CORBA::string_dup(unitcom[i].c_str());
 358                 }
 359         }
 360         catch (MEDEXCEPTION &ex)
 361         {
 362                 MESSAGE("Exception en accedant au champ");
 363                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 364         }
 365         return myseq._retn();
 366 }
 367 //=============================================================================
 368 /*!
 369  * CORBA: Accessor for Fields's Components descriptions
 370  */
 371 //=============================================================================
 372 SALOME_MED::string_array * FIELD_i::getComponentsDescriptions()
 373 throw (SALOME::SALOME_Exception)
 374 {
 375         if (_fieldTptr==NULL)
 376                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 377                                              SALOME::INTERNAL_ERROR);
 378         SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
 379         try
 380         {
 381                 int nbcom = _fieldTptr->getNumberOfComponents();
 382                 myseq->length(nbcom);
 383                 const string * namecom=_fieldTptr->getComponentsDescriptions();
 384                 for (int i=0;i<nbcom;i++)
 385                 {
 386                         myseq[i]=CORBA::string_dup(namecom[i].c_str());
 387                 }
 388         }
 389         catch (MEDEXCEPTION &ex)
 390         {
 391                 MESSAGE("Exception en accedant au champ");
 392                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 393         }
 394         return myseq._retn();
 395 }
 396 //=============================================================================
 397 /*!
 398  * CORBA: Add in Study
 399  */
 400 //=============================================================================
 401 void FIELD_i::addInStudy(SALOMEDS::Study_ptr myStudy,
 402                                                  SALOME_MED::FIELD_ptr myIor )
 403                     throw (SALOME::SALOME_Exception, SALOMEDS::StudyBuilder::LockProtection)
 404 {
 405         BEGIN_OF(" FIELD_i::addInStudy");
 406         if (_fieldTptr==NULL)
 407                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 408                                              SALOME::INTERNAL_ERROR);
 409         if ( _FieldId != "" )
 410         {
 411                 MESSAGE("Field already in Study");
 412                     THROW_SALOME_CORBA_EXCEPTION("Field already in Study", \
 413                                  SALOME::BAD_PARAM);
 414         };
 415
 416
 417         SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
 418         SALOMEDS::GenericAttribute_var anAttr;
 419         SALOMEDS::AttributeName_var    aName;
 420         SALOMEDS::AttributeIOR_var     aIOR;
 421
 422         // Create SComponent labelled 'Med'
 423         SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 424         if ( CORBA::is_nil(medfather) )
 425           THROW_SALOME_CORBA_EXCEPTION("SComponent labelled 'MED' not Found",SALOME::INTERNAL_ERROR);
 426
 427         // Create SObject labelled 'MEDFIELD' if it doesn't already exit
 428         SALOMEDS::SObject_var medfieldfather = myStudy->FindObject("MEDFIELD");
 429         if ( CORBA::is_nil(medfieldfather) )
 430         {
 431           MESSAGE("Add Object 'MEDFIELD'");
 432           medfieldfather = myBuilder->NewObject(medfather);
 433           anAttr = myBuilder->FindOrCreateAttribute(medfieldfather, "AttributeName");
 434           aName = SALOMEDS::AttributeName::_narrow(anAttr);
 435           aName->SetValue("MEDFIELD");
 436
 437         } ;
 438
 439         string fieldName = _fieldTptr->getName();
 440
 441         // Create SObject labelled 'FIELDNAME' if it doesn't already exit
 442         SALOMEDS::SObject_var medfieldnamefather = myStudy->FindObject(fieldName.c_str());
 443         if ( CORBA::is_nil(medfieldnamefather) )
 444         {
 445           MESSAGE("Add Object "<<fieldName);
 446           medfieldnamefather = myBuilder->NewObject(medfieldfather);
 447           anAttr = myBuilder->FindOrCreateAttribute(medfieldnamefather, "AttributeName");
 448           aName = SALOMEDS::AttributeName::_narrow(anAttr);
 449           aName->SetValue(fieldName.c_str());
 450
 451         } ;
 452
 453         // Create object labelled according to Field's Name
 454
 455         MESSAGE("Add a Field Object under "<<fieldName);
 456         myBuilder->NewCommand();
 457         SALOMEDS::SObject_var newObj = myBuilder->NewObject(medfieldnamefather);
 458
 459         ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 460         ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting()) ;
 461         CORBA::ORB_var &orb = init(0,0);
 462
 463         int iterationNumber = _fieldTptr->getIterationNumber();
 464         SCRUTE(iterationNumber);
 465
 466         int orderNumber = _fieldTptr->getOrderNumber();
 467         SCRUTE(orderNumber);
 468
 469         ostringstream iterationName ;
 470         iterationName<<"(" << iterationNumber << "," << orderNumber << ")";
 471         //      string supportName = _support->getName();
 472         string supportName = (_fieldTptr->getSupport())->getName();
 473         //      string meshName = (_support->getMesh())->getName();
 474         string meshName = ((_fieldTptr->getSupport())->getMesh())->getName();
 475         string meshNameStudy = meshName;
 476
 477         char * fieldEntryName;
 478         int lenName = strlen(iterationName.str().c_str()) + 4 +
 479           strlen(supportName.c_str()) + 4 + strlen(meshName.c_str()) + 1;
 480
 481         fieldEntryName = new char[lenName];
 482         fieldEntryName = strcpy(fieldEntryName,iterationName.str().c_str());
 483         fieldEntryName = strcat(fieldEntryName,"_ON_");
 484         fieldEntryName = strcat(fieldEntryName,supportName.c_str());
 485         fieldEntryName = strcat(fieldEntryName,"_OF_");
 486
 487         for (string::size_type pos=0; pos<meshNameStudy.size();++pos)
 488           {
 489             if (isspace(meshNameStudy[pos])) meshNameStudy[pos] = '_';
 490           }
 491
 492         SCRUTE(meshNameStudy);
 493
 494         fieldEntryName = strcat(fieldEntryName,meshNameStudy.c_str());
 495
 496         SCRUTE(fieldEntryName);
 497
 498         anAttr = myBuilder->FindOrCreateAttribute(newObj, "AttributeName");
 499         aName = SALOMEDS::AttributeName::_narrow(anAttr);
 500 //         aName->SetValue(iterationName.str().c_str());
 501         aName->SetValue(fieldEntryName);
 502
 503         string iorStr = orb->object_to_string(myIor);
 504         anAttr = myBuilder->FindOrCreateAttribute(newObj, "AttributeIOR");
 505         aIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 506         aIOR->SetValue(iorStr.c_str());
 507         myBuilder->CommitCommand();
 508         _FieldId = newObj->GetID();
 509
 510         MESSAGE("Computing path to Support");
 511
 512         char * supportEntryPath;
 513         lenName = 28 + 15 + strlen(meshName.c_str()) + 1 +
 514           strlen(supportName.c_str()) + 1;
 515         supportEntryPath = new char[lenName];
 516         supportEntryPath = strcpy(supportEntryPath,"/Med/MEDMESH/MEDSUPPORTS_OF_");
 517         supportEntryPath = strcat(supportEntryPath,meshNameStudy.c_str());
 518         supportEntryPath = strcat(supportEntryPath,"/");
 519         supportEntryPath = strcat(supportEntryPath,supportName.c_str());
 520
 521         SCRUTE(supportEntryPath);
 522
 523         MESSAGE("supportEntryPath in field " << supportEntryPath << " length " << lenName);
 524
 525 //      SALOMEDS::SObject_var supportObject = myStudy->FindObject(supportName.c_str());
 526         SALOMEDS::SObject_var supportObject = myStudy->FindObjectByPath(supportEntryPath);
 527
 528         SCRUTE(supportObject);
 529
 530         if ( CORBA::is_nil(supportObject) )
 531         {
 532           MESSAGE("supportObject is a nil corba object");
 533           MESSAGE("FIELD_i::addInStudy : SUPPORT not found") ;
 534         }
 535         else
 536         {
 537           MESSAGE("supportObject is OK and is now going to be referenced !");
 538           SALOMEDS::SObject_var newObjSupport = myBuilder->NewObject(newObj);
 539           myBuilder->Addreference(newObjSupport,supportObject);
 540           MESSAGE(" OUF !!!");
 541         }
 542
 543         myBuilder->CommitCommand();
 544
 545         delete [] supportEntryPath;
 546         delete [] fieldEntryName;
 547
 548         MESSAGE("FIELD_i::addInStudy");
 549
 550         //END_OF("FIELD_i::addInStudy");
 551 }
 552 //=============================================================================
 553 /*!
 554  * CORBA: write
 555  */
 556 //=============================================================================
 557 void FIELD_i::write (CORBA::Long i, const char* driverFieldName)
 558 throw (SALOME::SALOME_Exception)
 559 {
 560         if (_fieldTptr==NULL)
 561                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 562                                              SALOME::INTERNAL_ERROR);
 563         try
 564         {
 565                 _fieldTptr->write(i,driverFieldName);
 566         }
 567         catch (MEDEXCEPTION &ex)
 568         {
 569                 MESSAGE("Exception en accedant au champ");
 570                 THROW_SALOME_CORBA_EXCEPTION("Unable to acces Field C++ Object"\
 571                                                 ,SALOME::INTERNAL_ERROR);
 572         }
 573 }
 574 //=============================================================================
 575 /*!
 576  * CORBA: read
 577  */
 578 //=============================================================================
 579 void FIELD_i::read (CORBA::Long i)
 580 throw (SALOME::SALOME_Exception)
 581 {
 582         if (_fieldTptr==NULL)
 583                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 584                                              SALOME::INTERNAL_ERROR);
 585         try
 586         {
 587                 _fieldTptr->read(i);
 588         }
 589         catch (MEDEXCEPTION &ex)
 590         {
 591                 MESSAGE("Exception en accedant au champ");
 592                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 593         }
 594 }
 595 //=============================================================================
 596 /*!
 597  * CORBA: rmDriver
 598  */
 599 //=============================================================================
 600 void FIELD_i::rmDriver (CORBA::Long i)
 601 throw (SALOME::SALOME_Exception)
 602 {
 603         if (_fieldTptr==NULL)
 604                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 605                                              SALOME::INTERNAL_ERROR);
 606         try
 607         {
 608                 _fieldTptr->rmDriver(i);
 609         }
 610         catch (MEDEXCEPTION &ex)
 611         {
 612                 MESSAGE("Exception en accedant au champ");
 613                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 614         }
 615 }
 616 //=============================================================================
 617 /*!
 618  * CORBA: addDriver
 619  */
 620 //=============================================================================
 621 CORBA::Long FIELD_i::addDriver (SALOME_MED::medDriverTypes driverType,
 622                         const char* fileName, const char* fieldName) throw (SALOME::SALOME_Exception)
 623 {
 624         if (_fieldTptr==NULL)
 625                 THROW_SALOME_CORBA_EXCEPTION("No associated Field", \
 626                                              SALOME::INTERNAL_ERROR);
 627         try
 628         {
 629                 int drivernum=_fieldTptr->addDriver(
 630                                         convertIdlDriverToMedDriver(driverType),
 631                                         fileName,
 632                                         fieldName);
 633                 return drivernum;
 634         }
 635         catch (MEDEXCEPTION &ex)
 636         {
 637                 MESSAGE("Exception en accedant au champ");
 638                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 639         }
 640 }
 641