src/MED/Med_Gen_i.cxx

   1 //  MED MED : implemetation of MED idl descriptions
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : Med_Gen_i.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : MED
  27 //  $Header$
  28
  29 using namespace std;
  30 #include "Med_Gen_i.hxx"
  31
  32 #include "MEDMEM_Mesh_i.hxx"
  33 #include "MEDMEM_Med_i.hxx"
  34 #include "MEDMEM_FieldInt_i.hxx"
  35 #include "MEDMEM_FieldDouble_i.hxx"
  36 #include "MEDMEM_Support_i.hxx"
  37
  38 #include "MEDMEM_Mesh.hxx"
  39 #include "MEDMEM_Field.hxx"
  40 #include "MEDMEM_Med.hxx"
  41 #include "MEDMEM_MedMedDriver.hxx"
  42 #include "MEDMEM_MedMeshDriver.hxx"
  43 #include "MEDMEM_MedFieldDriver.hxx"
  44 #include "MEDMEM_define.hxx"
  45 #include "MEDMEM_DriversDef.hxx"
  46
  47
  48 #include "Utils_SINGLETON.hxx"
  49 #include "OpUtil.hxx"
  50 #include "Utils_CorbaException.hxx"
  51 #include "utilities.h"
  52
  53 #include <string>
  54 #include <deque>
  55 #include <map>
  56
  57 #include <TCollection_AsciiString.hxx>
  58 #include <TColStd_SequenceOfAsciiString.hxx>
  59 #include <HDFascii.hxx>
  60 #include "SALOMEDS_Tool.hxx"
  61
  62 using namespace MEDMEM;
  63
  64 // Initialisation des variables statiques
  65  map <string, string> Med_Gen_i::_MedCorbaObj;
  66  string Med_Gen_i::_myFileName="";
  67  string Med_Gen_i::_saveFileName="";
  68
  69 //=============================================================================
  70 /*!
  71  *  default constructor: not for use
  72  */
  73 //=============================================================================
  74
  75 Med_Gen_i::Med_Gen_i()
  76 {
  77   MESSAGE("Med_Gen_i::Med_Gen_i");
  78 }
  79
  80 //=============================================================================
  81 /*!
  82  *  standard constructor
  83  */
  84 //=============================================================================
  85
  86 Med_Gen_i:: Med_Gen_i(CORBA::ORB_ptr orb,
  87                                 PortableServer::POA_ptr poa,
  88                                 PortableServer::ObjectId * contId,
  89                                 const char *instanceName,
  90                                 const char *interfaceName) :
  91   Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
  92 {
  93   MESSAGE("activate object");
  94   _thisObj = this ;
  95   _id = _poa->activate_object(_thisObj);
  96
  97   _duringLoad=false;
  98   // get an NamingService interface
  99   _NS = SINGLETON_<SALOME_NamingService>::Instance() ;
 100   ASSERT(SINGLETON_<SALOME_NamingService>::IsAlreadyExisting()) ;
 101   _NS->init_orb( _orb ) ;
 102 }
 103 //=============================================================================
 104 /*!
 105  *  private method : change a study name in SALOMEDS::Study_var
 106  */
 107 //=============================================================================
 108
 109 SALOMEDS::Study_var Med_Gen_i::studyName2Study(const char* studyName)
 110   throw(SALOME::SALOME_Exception)
 111 {
 112   string myStudyName(studyName);
 113
 114   if (myStudyName.size() == 0)
 115     THROW_SALOME_CORBA_EXCEPTION("No Study Name given", \
 116                                  SALOME::BAD_PARAM);
 117
 118   // Get StudyManager Reference, current study,
 119
 120   CORBA::Object_var obj = _NS->Resolve("/myStudyManager");
 121   SALOMEDS::StudyManager_var myStudyManager =
 122     SALOMEDS::StudyManager::_narrow(obj);
 123   if(CORBA::is_nil(myStudyManager))
 124     THROW_SALOME_CORBA_EXCEPTION("No StudyManager Found in NameService", \
 125                                  SALOME::BAD_PARAM);
 126
 127   SALOMEDS::Study_var myStudy =
 128     myStudyManager->GetStudyByName(myStudyName.c_str());
 129   if (CORBA::is_nil(myStudy))
 130     THROW_SALOME_CORBA_EXCEPTION("Wrong Study Name", \
 131                                  SALOME::BAD_PARAM);
 132
 133   return SALOMEDS::Study::_duplicate(myStudy) ;
 134 }
 135
 136 //=============================================================================
 137 /*!
 138  *  private method : add Med component in Study (Not MedGen ???)
 139  */
 140 //=============================================================================
 141
 142 void Med_Gen_i::addInStudy(SALOMEDS::Study_var myStudy)
 143   throw(SALOME::SALOME_Exception)
 144 {
 145   SALOMEDS::StudyBuilder_var  myBuilder = myStudy->NewBuilder();
 146
 147   // Create SComponent labelled 'Med' if it doesn't already exit
 148   SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 149   if ( CORBA::is_nil(medfather) )
 150     {
 151       myBuilder->NewCommand();
 152       // mpv: component label must be created in spite of "Locked" study flag state
 153       bool aLocked = myStudy->GetProperties()->IsLocked();
 154       if (aLocked) myStudy->GetProperties()->SetLocked(false);
 155
 156       MESSAGE("Add Component Med");
 157       medfather = myBuilder->NewComponent("MED");
 158       SALOMEDS::GenericAttribute_var anAttr = myBuilder->FindOrCreateAttribute(medfather, "AttributeName");
 159       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 160       //NRI      aName->SetValue("Med");
 161
 162       CORBA::Object_var objVarN = _NS->Resolve("/Kernel/ModulCatalog");
 163       SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 164       SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "MED" );
 165       if ( !Comp->_is_nil() ) {
 166         aName->SetValue( Comp->componentusername() );
 167       }
 168
 169       //            Utilisation de this  deconseillee par Paul ??
 170       //            myBuilder->DefineComponentInstance(medfather,POA_Engines::MED_Gen::_this());
 171       CORBA::Object_var myO = _poa->id_to_reference(*_id); // this ior...
 172       myBuilder->DefineComponentInstance(medfather,myO);
 173
 174       if (aLocked) myStudy->GetProperties()->SetLocked(true);
 175       myBuilder->CommitCommand();
 176     }
 177
 178
 179 }
 180
 181 //=============================================================================
 182 /*!
 183  * Lit tous les objets contenus dans un fichier med et les lit en memoire
 184  */
 185 //=============================================================================
 186 SALOME_MED::MED_ptr Med_Gen_i::readStructFile (const char* fileName,
 187                                 const char* studyName)
 188   throw(SALOME::SALOME_Exception)
 189 {
 190         beginService("Med_Gen_i::readStructFile");
 191
 192         SCRUTE(fileName);
 193         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 194 //         if (!_duringLoad) addInStudy(myStudy) ;
 195
 196         SALOME_MED::MED_ptr myMedIOR ;
 197         try
 198         {
 199           // we create a new MED_i and add in study
 200           MED_i * myMedI = new MED_i();
 201           myMedIOR = myMedI->_this() ;
 202 //        if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR) ;
 203 //        if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR,fileName) ;
 204           // create ::MED object, read all and add in study !
 205           myMedI->init(myStudy,MED_DRIVER,fileName) ;
 206         }
 207         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 208         catch(...)
 209         {
 210                 MESSAGE("Erreur a la lecture du fichier");
 211                 THROW_SALOME_CORBA_EXCEPTION("Unable to open File "\
 212                                                 ,SALOME::BAD_PARAM);
 213         }
 214
 215         endService("Med_Gen_i::readStructFile");
 216         return myMedIOR;
 217 }
 218
 219 //=============================================================================
 220 /*!
 221  *  Prepare un Maillage sans le lire en memoire avec stokage dans l'etude
 222  *  des champs avec leur type
 223  */
 224 //=============================================================================
 225 void Med_Gen_i::readStructFileWithFieldType (const char* fileName,
 226                                              const char* studyName)
 227 throw (SALOME::SALOME_Exception)
 228 {
 229         beginService("Med_Gen_i::readStructFileWithFieldType");
 230
 231         BEGIN_OF("Med_Gen_i::readStructFileWithFieldType (const char* fileName,const char* studyName)");
 232
 233         SCRUTE(fileName);
 234         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 235
 236         if (!_duringLoad) addInStudy(myStudy) ;
 237
 238         try
 239         {
 240           // we create a new MED_i and add in study
 241           MED_i * myMedI = new MED_i();
 242           SALOME_MED::MED_ptr myMedIOR = myMedI->_this() ;
 243           if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR,fileName) ;
 244           // create ::MED object, read all and add in study !
 245           myMedI->initWithFieldType(myStudy,MED_DRIVER,fileName) ;
 246         }
 247         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 248         catch(...)
 249         {
 250                 MESSAGE("Erreur a la lecture du fichier");
 251                 THROW_SALOME_CORBA_EXCEPTION("Unable to open File "\
 252                                                 ,SALOME::BAD_PARAM);
 253         }
 254
 255         endService("Med_Gen_i::readStructFileWithFieldType");
 256         END_OF("Med_Gen_i::readStructFileWithFieldType (const char* fileName,const char* studyName)");
 257
 258
 259 }
 260
 261 //=============================================================================
 262 /*!
 263  *  Sert un Maillage
 264  */
 265 //=============================================================================
 266 SALOME_MED::MESH_ptr Med_Gen_i::readMeshInFile(const char* fileName,
 267                                                const char* studyName,
 268                                                const char* meshName)
 269 throw (SALOME::SALOME_Exception)
 270 {
 271         beginService("Med_Gen_i::readMeshInFile");
 272         SCRUTE(fileName);
 273         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 274
 275 //      if (!_duringLoad) addInStudy(myStudy) ;
 276
 277 // Creation du maillage
 278
 279         MESH * myMesh= new MESH() ;
 280         myMesh->setName(meshName);
 281         MED_MESH_RDONLY_DRIVER myMeshDriver(fileName,myMesh);
 282         try
 283         {
 284                 myMeshDriver.setMeshName(meshName);
 285                 myMeshDriver.open();
 286         }
 287         catch (const exception & ex)
 288         {
 289                 MESSAGE("Exception Interceptee : ");
 290                 SCRUTE(ex.what());
 291                 THROW_SALOME_CORBA_EXCEPTION("Unable to find this mesh in this file",SALOME::BAD_PARAM);
 292         };
 293         try
 294         {
 295                 myMeshDriver.read();
 296                 MESSAGE("apres read");
 297                 myMeshDriver.close();
 298         }
 299         catch (const exception & ex)
 300         {
 301                 MESSAGE("Exception Interceptee : ");
 302                 SCRUTE(ex.what());
 303                 THROW_SALOME_CORBA_EXCEPTION("Unable to read this mesh in this file",SALOME::BAD_PARAM);
 304         };
 305
 306         MESH_i * meshi = new MESH_i(myMesh);
 307         //SALOME_MED::MESH_var mesh = SALOME_MED::MESH::_narrow(meshi->_this());
 308         SALOME_MED::MESH_ptr mesh = meshi->_this();
 309         try
 310         {
 311           // add the mesh object in study
 312 //        if (!_duringLoad) meshi->addInStudy(myStudy,mesh);
 313         }
 314         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 315
 316         endService("Med_Gen_i::readMeshInFile");
 317         return mesh;
 318 }
 319 //=============================================================================
 320 /*!
 321  *  Sert un Champ
 322  */
 323 //=============================================================================
 324 SALOME_MED::FIELD_ptr Med_Gen_i::readFieldInFile(const char* fileName,
 325                                                const char* studyName,
 326                                                const char* fieldName,
 327                                                CORBA::Long ordre,
 328                                                CORBA::Long iter)
 329 throw (SALOME::SALOME_Exception)
 330 {
 331         beginService("Med_Gen_i::readFieldInFile");
 332         SCRUTE(fileName);
 333         string myStudyName(studyName);
 334
 335         if (myStudyName.size() == 0)
 336                 THROW_SALOME_CORBA_EXCEPTION("No Study Name given", \
 337                                  SALOME::BAD_PARAM);
 338
 339         // Get StudyManager Reference, current study,
 340
 341         CORBA::Object_var obj = _NS->Resolve("/myStudyManager");
 342         SALOMEDS::StudyManager_var myStudyManager =
 343                         SALOMEDS::StudyManager::_narrow(obj);
 344         ASSERT(! CORBA::is_nil(myStudyManager));
 345         SALOMEDS::Study_var myStudy =
 346                 myStudyManager->GetStudyByName(myStudyName.c_str());
 347         if (CORBA::is_nil(myStudy))
 348         THROW_SALOME_CORBA_EXCEPTION("Wrong Study Name", \
 349                                  SALOME::BAD_PARAM);
 350
 351         SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
 352         SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 353         if (CORBA::is_nil(medfather))
 354         {
 355                 myBuilder->NewCommand();
 356                 // mpv: component label must be created in spite of "Locked" study flag state
 357                 bool aLocked = myStudy->GetProperties()->IsLocked();
 358                 if (aLocked) myStudy->GetProperties()->SetLocked(false);
 359
 360                 medfather = myBuilder->NewComponent("MED");
 361                 SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(
 362                       myBuilder->FindOrCreateAttribute(medfather, "AttributeName"));
 363                 //NRI           aName->SetValue("Med");
 364
 365                 CORBA::Object_var objVarN = _NS->Resolve("/Kernel/ModulCatalog");
 366                 SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 367                 SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "MED" );
 368                 if ( !Comp->_is_nil() ) {
 369                   aName->SetValue( Comp->componentusername() );
 370                 }
 371
 372                 CORBA::Object_var myO = _poa->id_to_reference(*_id); // this ior...
 373                 myBuilder->DefineComponentInstance(medfather,myO);
 374
 375                 if (aLocked) myStudy->GetProperties()->SetLocked(true);
 376                 myBuilder->CommitCommand();
 377
 378         }
 379         else
 380                         MESSAGE("MED dejà dans l étude");
 381
 382         MESSAGE("Lecture du fichier ")
 383         SCRUTE(fileName);
 384
 385 // Creation du champ
 386
 387         FIELD_ * myField;
 388         MED * mymed = new MED(MED_DRIVER,fileName) ;
 389         try
 390         {
 391                 deque<string> fieldsNames = mymed->getFieldNames() ;
 392                 int numberOfFields = fieldsNames.size();
 393                 int i;
 394                 for (i=0; i<numberOfFields; i++)
 395                 {
 396                         if (fieldsNames[i]== fieldName) break;
 397                 }
 398                 if (i == numberOfFields)
 399                 {
 400                         THROW_SALOME_CORBA_EXCEPTION("Unable to find this field ",SALOME::BAD_PARAM);
 401                 }
 402                 MESSAGE("trouve");
 403 /*
 404                 deque<DT_IT_> myIteration = mymed->getFieldIteration (fieldName);
 405                 if (myIteration.size() != 1)
 406                 {
 407                         MESSAGE("WARNING : My iteration size is ")
 408                         SCRUTE(myIteration.size());
 409                 }
 410 */
 411                 myField = mymed->getField(fieldName,iter,ordre);
 412         }
 413         catch (const exception & ex)
 414         {
 415                 MESSAGE("Exception Interceptee : ");
 416                 SCRUTE(ex.what());
 417                 THROW_SALOME_CORBA_EXCEPTION("Unable to find this field in this file",SALOME::BAD_PARAM);
 418         };
 419
 420         SUPPORT * fieldSupport;
 421         try
 422         {
 423                 fieldSupport=(SUPPORT *)myField->getSupport() ;
 424                 ASSERT(fieldSupport != NULL);
 425                 MESH * myMesh=(MESH *)fieldSupport->getMesh();
 426                 ASSERT(myMesh != NULL);
 427                 myMesh->read();
 428                 SCRUTE(myMesh->getName());
 429                 fieldSupport->update();
 430         }
 431         catch (const exception & ex)
 432         {
 433                 MESSAGE("Exception Interceptee : ");
 434                 SCRUTE(ex.what());
 435                 THROW_SALOME_CORBA_EXCEPTION("Unable to find associated support",SALOME::BAD_PARAM);
 436         };
 437
 438         med_type_champ type = myField->getValueType() ;
 439         switch (type)
 440         {
 441          case MED_FR::MED_INT32:
 442          {
 443                 try
 444                 {
 445                         ((FIELD<int>*)myField)->read() ;
 446                         FIELDINT_i * myFieldIntI = new FIELDINT_i((FIELD<int>*)myField);
 447                         SALOME_MED::FIELD_ptr myFieldIOR = myFieldIntI->_this();
 448 //                      if (!_duringLoad) myFieldIntI->addInStudy(myStudy,myFieldIOR) ;
 449                         endService("Med_Gen_i::readFieldInFile");
 450                         return myFieldIOR;
 451                 }
 452                 catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 453                 catch (const exception & ex)
 454                 {
 455                         MESSAGE("Exception Interceptee : ");
 456                         SCRUTE(ex.what());
 457                         THROW_SALOME_CORBA_EXCEPTION("Unable to read int field",SALOME::BAD_PARAM);
 458                 };
 459                 break;
 460          }
 461          case MED_FR::MED_REEL64:
 462          {
 463                 try
 464                 {
 465                         ((FIELD<double>*)myField)->read() ;
 466                         FIELDDOUBLE_i * myFieldDoubleI = new FIELDDOUBLE_i((FIELD<double>*)myField);
 467                         SALOME_MED::FIELD_ptr myFieldIOR = myFieldDoubleI->_this() ;
 468 //                      if (!_duringLoad) myFieldDoubleI->addInStudy(myStudy,myFieldIOR) ;
 469                         endService("Med_Gen_i::readFieldInFile");
 470                         return myFieldIOR;
 471                 }
 472                 catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 473                 catch (const exception & ex)
 474                 {
 475                         MESSAGE("Exception Interceptee : ");
 476                         SCRUTE(ex.what());
 477                         THROW_SALOME_CORBA_EXCEPTION("Unable to read double field",SALOME::BAD_PARAM);
 478                 };
 479                 break;
 480          }
 481         }
 482
 483
 484 }
 485
 486
 487 //=============================================================================
 488 /*!
 489  *  Destructor
 490  */
 491 //=============================================================================
 492
 493 Med_Gen_i::~Med_Gen_i()
 494 {
 495   MESSAGE("Med_Gen_i::~Med_Gen_i");
 496 }
 497
 498 //=============================================================================
 499 /*!
 500  *  CORBA: Save Mesh objects (called when a study is saved)
 501  */
 502 //=============================================================================
 503 SALOMEDS::TMPFile* Med_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
 504                                    const char* theURL,
 505                                    bool isMultiFile) {
 506   const char* LOC = "Med_Gen_i::Save";
 507   BEGIN_OF(LOC);
 508
 509   SALOMEDS::TMPFile_var aStreamFile;
 510   // Get a temporary directory to store a file
 511   TCollection_AsciiString aTmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):(char*)SALOMEDS_Tool::GetTmpDir().c_str();
 512   // Create a list to store names of created files
 513   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 514   TColStd_SequenceOfAsciiString aFileNames;
 515
 516   CORBA::String_var aSaveStudyName("");
 517   if (isMultiFile) aSaveStudyName = CORBA::string_dup(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()).c_str());
 518
 519   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 520   if (!CORBA::is_nil(aMedMeshFather)) {
 521     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 522     anIter->InitEx(1);
 523     for(; anIter->More(); anIter->Next()) {
 524       SALOMEDS::SObject_var aSO = anIter->Value();
 525       SALOMEDS::GenericAttribute_var anAttr;
 526       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 527         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 528         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 529         if (! CORBA::is_nil(myMesh)) {
 530           TCollection_AsciiString aName(aSaveStudyName);
 531           aName += "_MEDMESH_";
 532           aName += myMesh->getName();
 533           aName += ".med";
 534           MESSAGE("Save mesh with name "<<aName.ToCString());
 535           long driverId = myMesh->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myMesh->getName());
 536           myMesh->write(driverId,"");
 537           aFileNames.Append(aName);
 538         }
 539       }
 540     }
 541   }
 542
 543   SALOMEDS::SObject_var aMedFieldFather = theComponent->GetStudy()->FindObject("MEDFIELD");
 544   if (!CORBA::is_nil(aMedFieldFather)) {
 545     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedFieldFather);
 546     anIter->InitEx(1);
 547     for(; anIter->More(); anIter->Next()) {
 548       SALOMEDS::SObject_var aSO = anIter->Value();
 549       SALOMEDS::GenericAttribute_var anAttr;
 550       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 551         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 552         SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 553         if (! CORBA::is_nil(myField)) {
 554           ostringstream a,b;
 555           a<< myField->getOrderNumber();
 556           b<< myField->getIterationNumber();
 557
 558           TCollection_AsciiString aName(aSaveStudyName);
 559           aName += "_MEDFIELD_";
 560           aName += myField->getName();
 561           aName += "_ORDRE_";
 562           aName += (char*)(a.str().c_str());
 563           aName += "_ITER_";
 564           aName += (char*)(b.str().c_str());
 565           aName += ".med";
 566           MESSAGE("Save mesh with name "<<aName.ToCString());
 567           long driverId = myField->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myField->getName());
 568           myField->write(driverId,"");
 569           aFileNames.Append(aName);
 570         }
 571       }
 572     }
 573   }
 574
 575   int i;
 576   aSeq->length(aFileNames.Length());
 577   for(i = aFileNames.Length(); i > 0; i--) aSeq[i-1] = CORBA::string_dup(aFileNames.Value(i).ToCString());
 578   // Conver a file to the byte stream
 579   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 580   // Remove the created file and tmp directory
 581   if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 582   // Return the created byte stream
 583   return aStreamFile._retn();
 584
 585   END_OF(LOC);
 586 }
 587
 588 SALOMEDS::TMPFile* Med_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
 589                                         const char* theURL,
 590                                         bool isMultiFile) {
 591   const char* LOC = "Med_Gen_i::SaveASCII";
 592   BEGIN_OF(LOC);
 593
 594   SALOMEDS::TMPFile_var aStreamFile;
 595   // Get a temporary directory to store a file
 596   TCollection_AsciiString aTmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):(char*)SALOMEDS_Tool::GetTmpDir().c_str();
 597   // Create a list to store names of created files
 598   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 599   TColStd_SequenceOfAsciiString aFileNames;
 600
 601   CORBA::String_var aSaveStudyName("");
 602   if (isMultiFile) aSaveStudyName = CORBA::string_dup(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()).c_str());
 603
 604   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 605   if (!CORBA::is_nil(aMedMeshFather)) {
 606     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 607     anIter->InitEx(1);
 608     for(; anIter->More(); anIter->Next()) {
 609       SALOMEDS::SObject_var aSO = anIter->Value();
 610       SALOMEDS::GenericAttribute_var anAttr;
 611       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 612         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 613         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 614         if (! CORBA::is_nil(myMesh)) {
 615           TCollection_AsciiString aName(aSaveStudyName);
 616           aName += "_MEDMESH_";
 617           aName += myMesh->getName();
 618           aName += ".med";
 619           MESSAGE("Save mesh with name "<<aName.ToCString());
 620           long driverId = myMesh->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myMesh->getName());
 621           myMesh->write(driverId,"");
 622           HDFascii::ConvertFromHDFToASCII((aTmpDir+aName).ToCString(), true);
 623           aFileNames.Append(aName);
 624         }
 625       }
 626     }
 627   }
 628
 629   SALOMEDS::SObject_var aMedFieldFather = theComponent->GetStudy()->FindObject("MEDFIELD");
 630   if (!CORBA::is_nil(aMedFieldFather)) {
 631     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedFieldFather);
 632     anIter->InitEx(1);
 633     for(; anIter->More(); anIter->Next()) {
 634       SALOMEDS::SObject_var aSO = anIter->Value();
 635       SALOMEDS::GenericAttribute_var anAttr;
 636       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 637         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 638         SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 639         if (! CORBA::is_nil(myField)) {
 640           ostringstream a,b;
 641           a<< myField->getOrderNumber();
 642           b<< myField->getIterationNumber();
 643
 644           TCollection_AsciiString aName(aSaveStudyName);
 645           aName += "_MEDFIELD_";
 646           aName += myField->getName();
 647           aName += "_ORDRE_";
 648           aName += (char*)(a.str().c_str());
 649           aName += "_ITER_";
 650           aName += (char*)(b.str().c_str());
 651           aName += ".med";
 652           MESSAGE("Save mesh with name "<<aName.ToCString());
 653           long driverId = myField->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myField->getName());
 654           myField->write(driverId,"");
 655           HDFascii::ConvertFromHDFToASCII((aTmpDir+aName).ToCString(), true);
 656           aFileNames.Append(aName);
 657         }
 658       }
 659     }
 660   }
 661
 662   int i;
 663   aSeq->length(aFileNames.Length());
 664   for(i = aFileNames.Length(); i > 0; i--) aSeq[i-1] = CORBA::string_dup(aFileNames.Value(i).ToCString());
 665   // Conver a file to the byte stream
 666   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 667   // Remove the created file and tmp directory
 668   if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 669   // Return the created byte stream
 670   return aStreamFile._retn();
 671
 672   END_OF(LOC);
 673 }
 674
 675 //=============================================================================
 676 /*!
 677  *  CORBA: Load Mesh objects (called when an existing study is opened)
 678  */
 679 //=============================================================================
 680
 681 CORBA::Boolean Med_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
 682                                const SALOMEDS::TMPFile& theStream,
 683                                const char* theURL,
 684                                bool isMultiFile) {
 685   const char* LOC = "Med_Gen_i::Load";
 686   BEGIN_OF(LOC);
 687
 688   // Get a temporary directory for a file
 689   TCollection_AsciiString aTmpDir =
 690     (isMultiFile)?TCollection_AsciiString((char*)theURL):(char*)SALOMEDS_Tool::GetTmpDir().c_str();
 691   _saveFileName = CORBA::string_dup(aTmpDir.ToCString());
 692   SALOMEDS::ListOfFileNames_var aSeq =
 693     SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.ToCString(), isMultiFile);
 694   return true;
 695
 696   END_OF(LOC);
 697 }
 698
 699 CORBA::Boolean Med_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
 700                                     const SALOMEDS::TMPFile& theStream,
 701                                     const char* theURL,
 702                                     bool isMultiFile) {
 703   return Load(theComponent, theStream, theURL, isMultiFile);
 704 }
 705
 706 //=============================================================================
 707 /*!
 708  *  CORBA:
 709  */
 710 //=============================================================================
 711
 712 void Med_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
 713 {
 714   MESSAGE("Med_Gen_i::Close");
 715   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 716   if (!CORBA::is_nil(aMedMeshFather)) {
 717     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 718     for(; anIter->More(); anIter->Next()) {
 719       SALOMEDS::SObject_var aSO = anIter->Value();
 720       SALOMEDS::GenericAttribute_var anAttr;
 721       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 722         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 723         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 724         // here must call method destroy of myMesh, but it not implented yet
 725       }
 726     }
 727   }
 728 }
 729
 730 //=============================================================================
 731 /*!
 732  *  CORBA:
 733  */
 734 //=============================================================================
 735
 736 char* Med_Gen_i::ComponentDataType()
 737 {
 738   MESSAGE("Med_Gen_i::ComponentDataType");
 739   return CORBA::string_dup("MED") ; /* What is this type ? */
 740 }
 741
 742 //=============================================================================
 743 /*!
 744  *  CORBA: give a persistent reference of a transient object (for study save)
 745  */
 746 //=============================================================================
 747
 748 char* Med_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
 749                                         const char* IORString,
 750                                         CORBA::Boolean isMultiFile,
 751                                         CORBA::Boolean isASCII) {
 752   const char * LOC = "Med_Gen_i::IORToLocalPersistentID" ;
 753   BEGIN_OF(LOC) ;
 754   SCRUTE(IORString);
 755
 756
 757   if (string(IORString).size()==0) return "_MED";
 758   // Well, we know where put object (_saveFilename) and we know object (IORString)
 759   // cast object :
 760   CORBA::Object_var myIOR = _orb->string_to_object(IORString);
 761
 762   // MED
 763   SALOME_MED::MED_var myMed = SALOME_MED::MED::_narrow(myIOR);
 764   if (! CORBA::is_nil(myMed))
 765   {
 766         // nothing to save : Support will be saved inside the mesh
 767         string str_MedName="_MED Objet Med + /OBJ_MED/";
 768         return CORBA::string_dup(str_MedName.c_str()) ;
 769   }
 770
 771   // MESH
 772   SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 773   if (! CORBA::is_nil(myMesh))
 774   {
 775     CORBA::String_var aName((string("_MEDMESH_")+ myMesh->getName() + ".med").c_str());
 776     return aName._retn() ;
 777   }
 778
 779   // SUPPORT
 780   SALOME_MED::SUPPORT_var mySupport = SALOME_MED::SUPPORT::_narrow(myIOR);
 781   if (! CORBA::is_nil(mySupport))
 782   {
 783         // nothing to save : Support will be saved inside the mesh
 784         string str_SupportName;
 785         try
 786         {
 787                 str_SupportName=string("/FAS/")+string(mySupport->getName());
 788                 str_SupportName+=string("/ENS_MAA/")+string(mySupport->getMesh()->getName());
 789                 SCRUTE(str_SupportName);
 790         }
 791         catch(...)
 792         {
 793                 MESSAGE("Unable to save the support");
 794                 THROW_SALOME_CORBA_EXCEPTION("Unable to save Field in Med"\
 795                                               ,SALOME::INTERNAL_ERROR);
 796         }
 797     return CORBA::string_dup(("_MED"+str_SupportName).c_str());
 798   }
 799
 800   SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 801   if (! CORBA::is_nil(myField))
 802   {
 803     string str_FieldName;
 804     ostringstream a,b;
 805     a<< myField->getOrderNumber();
 806     b<< myField->getIterationNumber();
 807     CORBA::String_var aName((string("_MEDFIELD_")+ myField->getName() +
 808                              string("_ORDRE_")+a.str()+
 809                              string("_ITER_")+b.str() +
 810                              ".med").c_str());
 811     return aName._retn();
 812   }
 813
 814   //THROW_SALOME_CORBA_EXCEPTION("Unable to save IOR",SALOME::BAD_PARAM);
 815   return "_MED";
 816
 817   END_OF(LOC) ;
 818 }
 819
 820 //=============================================================================
 821 /*!
 822  *  CORBA: give a transient reference (when loading an object, opening study)
 823  */
 824 //=============================================================================
 825
 826 char* Med_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
 827                                         const char* aLocalPersistentID,
 828                                         CORBA::Boolean isMultiFile,
 829                                         CORBA::Boolean isASCII)
 830      throw(SALOME::SALOME_Exception)
 831 {
 832   const char * LOC = "Med_Gen_i::LocalPersistentIDToIOR" ;
 833   BEGIN_OF(LOC) ;
 834   TCollection_AsciiString aTmpDir((char*)(_saveFileName.c_str()));
 835
 836   TCollection_AsciiString aSaveStudyName("");
 837   if (isMultiFile) aSaveStudyName = (char*)SALOMEDS_Tool::GetNameFromPath(theSObject->GetStudy()->URL()).c_str();
 838
 839   if (strcmp(aLocalPersistentID, "Objet Med + /OBJ_MED/") == 0) return CORBA::string_dup(""); // MED
 840
 841   if (strncmp(aLocalPersistentID, "_MEDMESH_",9) == 0) {// MESH
 842     MESH * myMesh= new MESH() ;
 843     int aMeshNameLen = strlen(aLocalPersistentID) - 12;
 844     char* aMeshName = new char[aMeshNameLen];
 845     strncpy(aMeshName, &(aLocalPersistentID[9]), aMeshNameLen-1);
 846     aMeshName[aMeshNameLen-1] = 0;
 847     myMesh->setName(aMeshName);
 848
 849     char* aFileName;
 850     if (isASCII) {
 851       char* aResultPath = HDFascii::ConvertFromASCIIToHDF((aTmpDir + aSaveStudyName + (char*)aLocalPersistentID).ToCString());
 852       aFileName = new char[strlen(aResultPath) + 19];
 853       sprintf(aFileName, "%shdf_from_ascii.hdf", aResultPath);
 854       delete(aResultPath);
 855     } else aFileName = CORBA::string_dup((aTmpDir + aSaveStudyName + (char*)aLocalPersistentID).ToCString());
 856     MED_MESH_RDONLY_DRIVER myMeshDriver(aFileName,myMesh);
 857     try
 858       {
 859         myMeshDriver.setMeshName(aMeshName);
 860         myMeshDriver.open();
 861       }
 862     catch (const exception & ex)
 863       {
 864         MESSAGE("Exception Interceptee : ");
 865         SCRUTE(ex.what());
 866         THROW_SALOME_CORBA_EXCEPTION("Unable to find this mesh in this file",SALOME::BAD_PARAM);
 867       };
 868     try
 869       {
 870         myMeshDriver.read();
 871         MESSAGE("apres read");
 872         myMeshDriver.close();
 873       }
 874     catch (const exception & ex)
 875       {
 876         MESSAGE("Exception Interceptee : ");
 877         SCRUTE(ex.what());
 878         THROW_SALOME_CORBA_EXCEPTION("Unable to read this mesh in this file",SALOME::BAD_PARAM);
 879       }
 880     MESH_i * meshi = new MESH_i(myMesh);
 881     //SALOME_MED::MESH_var mesh = SALOME_MED::MESH::_narrow(meshi->_this());
 882     SALOME_MED::MESH_ptr mesh = meshi->_this();
 883     SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 884     aSeq->length(1);
 885     aSeq[0]=CORBA::string_dup(aLocalPersistentID);
 886     if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 887     if (isASCII) {
 888       SALOMEDS::ListOfFileNames_var aFilesToRemove = new SALOMEDS::ListOfFileNames;
 889       aFilesToRemove->length(1);
 890       aFilesToRemove[0] = CORBA::string_dup(&(aFileName[strlen(SALOMEDS_Tool::GetDirFromPath(aFileName).c_str())]));
 891       SALOMEDS_Tool::RemoveTemporaryFiles(SALOMEDS_Tool::GetDirFromPath(aFileName).c_str(), aFilesToRemove, true);
 892     }
 893     delete(aFileName);
 894     return(CORBA::string_dup(_orb->object_to_string(mesh)));
 895   } else if (strncmp(aLocalPersistentID, "_MEDFIELD_",14) == 0) { // FIELD
 896     return(CORBA::string_dup("")); // not implemented yet
 897   }
 898
 899   return CORBA::string_dup("");
 900
 901   END_OF(LOC) ;
 902 }
 903
 904 //=============================================================================
 905 /*!
 906  *  returns true, if can publish object
 907  */
 908 //=============================================================================
 909 bool Med_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR) {
 910   SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(theIOR);
 911   return !(aMesh->_is_nil());
 912 }
 913
 914 //=============================================================================
 915 /*!
 916  *  publish the given object
 917  */
 918 //=============================================================================
 919 SALOMEDS::SObject_ptr Med_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
 920                                                 SALOMEDS::SObject_ptr theSObject,
 921                                                 CORBA::Object_ptr theObject,
 922                                                 const char* theName) throw (SALOME::SALOME_Exception)
 923 {
 924   SALOMEDS::SObject_var aResultSO;
 925
 926   if(CORBA::is_nil(theObject)) return aResultSO;
 927   if(theStudy->_is_nil()) return aResultSO;
 928
 929   SALOMEDS::StudyBuilder_var aBuilder = theStudy->NewBuilder();
 930   SALOMEDS::GenericAttribute_var anAttr;
 931   SALOMEDS::AttributeName_var    aName;
 932   SALOMEDS::AttributeIOR_var     anIOR;
 933   SALOMEDS::SComponent_var aFather = theStudy->FindComponent("MED");
 934
 935   if (aFather->_is_nil()) {
 936     aFather = aBuilder->NewComponent("MED");
 937     if (aFather->_is_nil()) return aResultSO;
 938     anAttr = aBuilder->FindOrCreateAttribute(aFather, "AttributeName");
 939     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 940     //NRI    aName->SetValue("MED");
 941
 942     CORBA::Object_var objVarN = _NS->Resolve("/Kernel/ModulCatalog");
 943     SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 944     SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "MED" );
 945     if ( !Comp->_is_nil() ) {
 946       aName->SetValue( Comp->componentusername() );
 947     }
 948     aBuilder->DefineComponentInstance(aFather, MED_Gen::_this());
 949   }
 950
 951   if (CORBA::is_nil(theSObject)) {
 952     SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(theObject);
 953     aMesh->addInStudy(theStudy, aMesh);
 954     SALOMEDS::SObject_var aResultSO = theStudy->FindObjectIOR(_orb->object_to_string(theObject));
 955   } else {
 956     if (!theSObject->ReferencedObject(aResultSO))
 957       THROW_SALOME_CORBA_EXCEPTION("Publish in study MED object error",SALOME::BAD_PARAM);
 958   }
 959 //    aBuilder->Addreference(theObject, aResultSO);
 960   return aResultSO._retn();
 961 }
 962
 963 //=============================================================================
 964 /*!
 965  *  returns true, if can copy the object
 966  */
 967 //=============================================================================
 968 CORBA::Boolean Med_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
 969   // Try to retrieve known by MED component mesh by given IOR
 970   SALOMEDS::GenericAttribute_var anAttr;
 971   if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return false;
 972   try {
 973     CORBA::Object_var anObj = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 974     SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(anObj);
 975     // If the object is null one it can't be copied: return false
 976     if (aMesh->_is_nil()) return false;
 977   } catch(...) {
 978     return false;
 979   }
 980   return true;
 981 }
 982
 983 //=============================================================================
 984 /*!
 985  *  create copy of the object and put it to the stream
 986  */
 987 //=============================================================================
 988 SALOMEDS::TMPFile* Med_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) {
 989     // Declare a sequence of the byte to store the copied object
 990   SALOMEDS::TMPFile_var aStreamFile;
 991
 992   // Try to get GEOM_Shape object by given SObject
 993   SALOMEDS::GenericAttribute_var anAttr;
 994   if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return new SALOMEDS::TMPFile(0);
 995   CORBA::String_var anIOR = CORBA::string_dup(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 996   CORBA::Object_var anObj = _orb->string_to_object(anIOR);
 997   SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(anObj);
 998   if (aMesh->_is_nil()) return new SALOMEDS::TMPFile(0);
 999
1000   // Get a temporary directory to store a temporary file
1001   CORBA::String_var aTmpDir = SALOMEDS_Tool::GetTmpDir().c_str();
1002   // Create a list to store names of created files
1003   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
1004   aSeq->length(1);
1005   aSeq[0] = CORBA::string_dup(aMesh->getName());
1006   char* aFullName = new char[strlen(aTmpDir)+strlen(aSeq[0])+1];
1007   strcpy(aFullName, aTmpDir);
1008   strcpy(aFullName+strlen(aTmpDir), aSeq[0]);
1009   long driverId = aMesh->addDriver(SALOME_MED::MED_DRIVER,aFullName , aMesh->getName());
1010   aMesh->write(driverId,"");
1011   delete(aFullName);
1012
1013   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir, aSeq.in(), false);
1014   SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeq.in(), true);
1015
1016   // Assign an ID = 1 the the type SALOME_MED::MESH
1017   theObjectID = 1;
1018
1019   return aStreamFile._retn();
1020 }
1021
1022 //=============================================================================
1023 /*!
1024  *  returns true, if can copy the object
1025  */
1026 //=============================================================================
1027 CORBA::Boolean Med_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
1028   // The MED component can paste only objects copied by MED component
1029   // and with the object type = 1 (mesh)
1030   if (strcmp(theComponentName, ComponentDataType()) != 0 || theObjectID != 1) return false;
1031   return true;
1032 }
1033
1034 //=============================================================================
1035 /*!
1036  *  returns true, if can copy the object
1037  */
1038 //=============================================================================
1039 SALOMEDS::SObject_ptr Med_Gen_i::PasteInto(const SALOMEDS::TMPFile& theStream,
1040                                            CORBA::Long theObjectID,
1041                                            SALOMEDS::SObject_ptr theObject) {
1042   SALOMEDS::SObject_var aResultSO = SALOMEDS::SObject::_duplicate(theObject);
1043   if (theStream.length() == 0) return aResultSO._retn();
1044
1045   SALOMEDS::Study_var aStudy = theObject->GetStudy();
1046
1047   CORBA::String_var aTmpDir = CORBA::string_dup(SALOMEDS_Tool::GetTmpDir().c_str());
1048   SALOMEDS::ListOfFileNames_var aSeq = SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir, false);
1049   CORBA::String_var aMeshName = CORBA::string_dup(aSeq[0]);
1050   char* aFullName = new char[strlen(aTmpDir)+strlen(aMeshName)+1];
1051   strcpy(aFullName, aTmpDir);
1052   strcpy(aFullName+strlen(aTmpDir), aMeshName);
1053
1054   MESH * myMesh= new MESH() ;
1055   myMesh->setName((char*)aMeshName);
1056   MED_MESH_RDONLY_DRIVER myMeshDriver(aFullName, myMesh);
1057   try {
1058     myMeshDriver.setMeshName((char*)aMeshName);
1059     myMeshDriver.open();
1060   } catch (const exception & ex) {
1061     MESSAGE("Exception Interceptee : ");
1062     SCRUTE(ex.what());
1063     delete(aFullName);
1064     return aResultSO._retn();
1065   };
1066   try {
1067     myMeshDriver.read();
1068     ("apres read");
1069     myMeshDriver.close();
1070   } catch (const exception & ex) {
1071     MESSAGE("Exception Interceptee : ");
1072     SCRUTE(ex.what());
1073     delete(aFullName);
1074     return aResultSO._retn();
1075   };
1076   // set new mesh name, becouse now there are no possibility to operate meshes with the same names
1077 //    srand((unsigned int)time(NULL));
1078   int aRND = rand(); //Get a random number to present a name of a copied mesh
1079   char aCopiedMeshName[20];
1080   sprintf(aCopiedMeshName,"MESH_COPY_%d",aRND);
1081   myMesh->setName(aCopiedMeshName);
1082   MESH_i * meshi = new MESH_i(myMesh);
1083   SALOME_MED::MESH_ptr mesh = meshi->_this();
1084   // add the mesh object in study
1085   meshi->addInStudy(aStudy,mesh);
1086   // get the IOR attribute of just added mesh
1087   CORBA::String_var anIORString = _orb->object_to_string(mesh);
1088   aResultSO = aStudy->FindObjectIOR(anIORString);
1089
1090   SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeq.in(), true);
1091   delete(aFullName);
1092   return aResultSO._retn();
1093 }
1094
1095
1096
1097
1098
1099
1100 //=============================================================================
1101 /*!
1102  * C factory, accessible with dlsym, after dlopen
1103  */
1104 //=============================================================================
1105
1106 extern "C"
1107 {
1108   PortableServer::ObjectId * MEDEngine_factory(
1109                                CORBA::ORB_ptr orb,
1110                                PortableServer::POA_ptr poa,
1111                                PortableServer::ObjectId * contId,
1112                                const char *instanceName,
1113                                const char *interfaceName)
1114   {
1115     MESSAGE("PortableServer::ObjectId * MedEngine_factory()");
1116     SCRUTE(interfaceName);
1117     Med_Gen_i * myMed_Gen
1118       = new Med_Gen_i(orb, poa, contId, instanceName, interfaceName);
1119     return myMed_Gen->getId() ;
1120   }
1121 }