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         SCRUTE(fileName);
 191         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 192         if (!_duringLoad) addInStudy(myStudy) ;
 193
 194         SALOME_MED::MED_ptr myMedIOR ;
 195         try
 196         {
 197           // we create a new MED_i and add in study
 198           MED_i * myMedI = new MED_i();
 199           myMedIOR = myMedI->_this() ;
 200 //        if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR) ;
 201           if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR,fileName) ;
 202           // create ::MED object, read all and add in study !
 203           myMedI->init(myStudy,MED_DRIVER,fileName) ;
 204         }
 205         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 206         catch(...)
 207         {
 208                 MESSAGE("Erreur a la lecture du fichier");
 209                 THROW_SALOME_CORBA_EXCEPTION("Unable to open File "\
 210                                                 ,SALOME::BAD_PARAM);
 211         }
 212         return SALOME_MED::MED::_duplicate(myMedIOR) ;
 213 }
 214
 215 //=============================================================================
 216 /*!
 217  *  Prepare un Maillage sans le lire en memoire avec stokage dans l'etude
 218  *  des champs avec leur type
 219  */
 220 //=============================================================================
 221 void Med_Gen_i::readStructFileWithFieldType (const char* fileName,
 222                                              const char* studyName)
 223 throw (SALOME::SALOME_Exception)
 224 {
 225   BEGIN_OF("Med_Gen_i::readStructFileWithFieldType (const char* fileName,const char* studyName)");
 226
 227         SCRUTE(fileName);
 228         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 229
 230         if (!_duringLoad) addInStudy(myStudy) ;
 231
 232         try
 233         {
 234           // we create a new MED_i and add in study
 235           MED_i * myMedI = new MED_i();
 236           SALOME_MED::MED_ptr myMedIOR = myMedI->_this() ;
 237           if (!_duringLoad) myMedI->addInStudy(myStudy,myMedIOR,fileName) ;
 238           // create ::MED object, read all and add in study !
 239           myMedI->initWithFieldType(myStudy,MED_DRIVER,fileName) ;
 240         }
 241         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 242         catch(...)
 243         {
 244                 MESSAGE("Erreur a la lecture du fichier");
 245                 THROW_SALOME_CORBA_EXCEPTION("Unable to open File "\
 246                                                 ,SALOME::BAD_PARAM);
 247         }
 248
 249         END_OF("Med_Gen_i::readStructFileWithFieldType (const char* fileName,const char* studyName)");
 250
 251
 252 }
 253
 254 //=============================================================================
 255 /*!
 256  *  Sert un Maillage
 257  */
 258 //=============================================================================
 259 SALOME_MED::MESH_ptr Med_Gen_i::readMeshInFile(const char* fileName,
 260                                                const char* studyName,
 261                                                const char* meshName)
 262 throw (SALOME::SALOME_Exception)
 263 {
 264         SCRUTE(fileName);
 265         SALOMEDS::Study_var myStudy = studyName2Study(studyName) ;
 266
 267         if (!_duringLoad) addInStudy(myStudy) ;
 268
 269 // Creation du maillage
 270
 271         MESH * myMesh= new MESH() ;
 272         myMesh->setName(meshName);
 273         MED_MESH_RDONLY_DRIVER myMeshDriver(fileName,myMesh);
 274         try
 275         {
 276                 myMeshDriver.setMeshName(meshName);
 277                 myMeshDriver.open();
 278         }
 279         catch (const exception & ex)
 280         {
 281                 MESSAGE("Exception Interceptee : ");
 282                 SCRUTE(ex.what());
 283                 THROW_SALOME_CORBA_EXCEPTION("Unable to find this mesh in this file",SALOME::BAD_PARAM);
 284         };
 285         try
 286         {
 287                 myMeshDriver.read();
 288                 MESSAGE("apres read");
 289                 myMeshDriver.close();
 290         }
 291         catch (const exception & ex)
 292         {
 293                 MESSAGE("Exception Interceptee : ");
 294                 SCRUTE(ex.what());
 295                 THROW_SALOME_CORBA_EXCEPTION("Unable to read this mesh in this file",SALOME::BAD_PARAM);
 296         };
 297
 298         MESH_i * meshi = new MESH_i(myMesh);
 299         //SALOME_MED::MESH_var mesh = SALOME_MED::MESH::_narrow(meshi->_this());
 300         SALOME_MED::MESH_ptr mesh = meshi->_this();
 301         try
 302         {
 303           // add the mesh object in study
 304           if (!_duringLoad) meshi->addInStudy(myStudy,mesh);
 305         }
 306         catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 307         return SALOME_MED::MESH::_duplicate(mesh);
 308 }
 309 //=============================================================================
 310 /*!
 311  *  Sert un Champ
 312  */
 313 //=============================================================================
 314 SALOME_MED::FIELD_ptr Med_Gen_i::readFieldInFile(const char* fileName,
 315                                                const char* studyName,
 316                                                const char* fieldName,
 317                                                CORBA::Long ordre,
 318                                                CORBA::Long iter)
 319 throw (SALOME::SALOME_Exception)
 320 {
 321         SCRUTE(fileName);
 322         string myStudyName(studyName);
 323
 324         if (myStudyName.size() == 0)
 325                 THROW_SALOME_CORBA_EXCEPTION("No Study Name given", \
 326                                  SALOME::BAD_PARAM);
 327
 328         // Get StudyManager Reference, current study,
 329
 330         CORBA::Object_var obj = _NS->Resolve("/myStudyManager");
 331         SALOMEDS::StudyManager_var myStudyManager =
 332                         SALOMEDS::StudyManager::_narrow(obj);
 333         ASSERT(! CORBA::is_nil(myStudyManager));
 334         SALOMEDS::Study_var myStudy =
 335                 myStudyManager->GetStudyByName(myStudyName.c_str());
 336         if (CORBA::is_nil(myStudy))
 337         THROW_SALOME_CORBA_EXCEPTION("Wrong Study Name", \
 338                                  SALOME::BAD_PARAM);
 339
 340         SALOMEDS::StudyBuilder_var myBuilder = myStudy->NewBuilder();
 341         SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 342         if (CORBA::is_nil(medfather))
 343         {
 344                 myBuilder->NewCommand();
 345                 // mpv: component label must be created in spite of "Locked" study flag state
 346                 bool aLocked = myStudy->GetProperties()->IsLocked();
 347                 if (aLocked) myStudy->GetProperties()->SetLocked(false);
 348
 349                 medfather = myBuilder->NewComponent("MED");
 350                 SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(
 351                       myBuilder->FindOrCreateAttribute(medfather, "AttributeName"));
 352                 //NRI           aName->SetValue("Med");
 353
 354                 CORBA::Object_var objVarN = _NS->Resolve("/Kernel/ModulCatalog");
 355                 SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 356                 SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "MED" );
 357                 if ( !Comp->_is_nil() ) {
 358                   aName->SetValue( Comp->componentusername() );
 359                 }
 360
 361                 CORBA::Object_var myO = _poa->id_to_reference(*_id); // this ior...
 362                 myBuilder->DefineComponentInstance(medfather,myO);
 363
 364                 if (aLocked) myStudy->GetProperties()->SetLocked(true);
 365                 myBuilder->CommitCommand();
 366
 367         }
 368         else
 369                         MESSAGE("MED dejà dans l étude");
 370
 371         MESSAGE("Lecture du fichier ")
 372         SCRUTE(fileName);
 373
 374 // Creation du champ
 375
 376         FIELD_ * myField= new FIELD_() ;
 377         MED * mymed = new MED(MED_DRIVER,fileName) ;
 378         try
 379         {
 380                 deque<string> fieldsNames = mymed->getFieldNames() ;
 381                 int numberOfFields = fieldsNames.size();
 382                 int i;
 383                 for (i=0; i<numberOfFields; i++)
 384                 {
 385                         if (fieldsNames[i]== fieldName) break;
 386                 }
 387                 if (i == numberOfFields)
 388                 {
 389                         THROW_SALOME_CORBA_EXCEPTION("Unable to find this field ",SALOME::BAD_PARAM);
 390                 }
 391                 MESSAGE("trouve");
 392 /*
 393                 deque<DT_IT_> myIteration = mymed->getFieldIteration (fieldName);
 394                 if (myIteration.size() != 1)
 395                 {
 396                         MESSAGE("WARNING : My iteration size is ")
 397                         SCRUTE(myIteration.size());
 398                 }
 399 */
 400                 myField = mymed->getField(fieldName,iter,ordre);
 401         }
 402         catch (const exception & ex)
 403         {
 404                 MESSAGE("Exception Interceptee : ");
 405                 SCRUTE(ex.what());
 406                 THROW_SALOME_CORBA_EXCEPTION("Unable to find this field in this file",SALOME::BAD_PARAM);
 407         };
 408
 409         SUPPORT * fieldSupport;
 410         SALOME_MED::SUPPORT_ptr mySupportIOR;
 411         try
 412         {
 413                 fieldSupport=(SUPPORT *)myField->getSupport() ;
 414                 ASSERT(fieldSupport != NULL);
 415                 MESH * myMesh=(MESH *)fieldSupport->getMesh();
 416                 ASSERT(myMesh != NULL);
 417                 myMesh->read();
 418                 SCRUTE(myMesh->getName());
 419                 fieldSupport->update();
 420                 SUPPORT_i * mySupportI = new SUPPORT_i(fieldSupport);
 421                 mySupportIOR=mySupportI->_this();
 422         }
 423         catch (const exception & ex)
 424         {
 425                 MESSAGE("Exception Interceptee : ");
 426                 SCRUTE(ex.what());
 427                 THROW_SALOME_CORBA_EXCEPTION("Unable to find associated support",SALOME::BAD_PARAM);
 428         };
 429
 430         med_type_champ type = myField->getValueType() ;
 431         switch (type)
 432         {
 433          case MED_FR::MED_INT32:
 434          {
 435                 try
 436                 {
 437                         ((FIELD<int>*)myField)->read() ;
 438                         FIELDINT_i * myFieldIntI = new FIELDINT_i(mySupportIOR,(FIELD<int>*)myField);
 439                         POA_SALOME_MED::FIELD_tie<FIELD_i> * myFieldTie = new POA_SALOME_MED::FIELD_tie<FIELD_i>(myFieldIntI);
 440                         SALOME_MED::FIELD_ptr myFieldIOR = myFieldTie->_this() ;
 441                         if (!_duringLoad) myFieldIntI->addInStudy(myStudy,myFieldIOR) ;
 442                         return SALOME_MED::FIELD::_duplicate(myFieldIOR);
 443                 }
 444                 catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 445                 catch (const exception & ex)
 446                 {
 447                         MESSAGE("Exception Interceptee : ");
 448                         SCRUTE(ex.what());
 449                         THROW_SALOME_CORBA_EXCEPTION("Unable to read int field",SALOME::BAD_PARAM);
 450                 };
 451                 break;
 452          }
 453          case MED_FR::MED_REEL64:
 454          {
 455                 try
 456                 {
 457                         ((FIELD<double>*)myField)->read() ;
 458                         FIELDDOUBLE_i * myFieldDoubleI = new FIELDDOUBLE_i(mySupportIOR,(FIELD<double>*)myField);
 459                         POA_SALOME_MED::FIELD_tie<FIELD_i> * myFieldTie = new POA_SALOME_MED::FIELD_tie<FIELD_i>(myFieldDoubleI);
 460                         SALOME_MED::FIELD_ptr myFieldIOR = myFieldTie->_this() ;
 461                         if (!_duringLoad) myFieldDoubleI->addInStudy(myStudy,myFieldIOR) ;
 462                         return SALOME_MED::FIELD::_duplicate(myFieldIOR);
 463                 }
 464                 catch (const SALOMEDS::StudyBuilder::LockProtection & lp) {}
 465                 catch (const exception & ex)
 466                 {
 467                         MESSAGE("Exception Interceptee : ");
 468                         SCRUTE(ex.what());
 469                         THROW_SALOME_CORBA_EXCEPTION("Unable to read double field",SALOME::BAD_PARAM);
 470                 };
 471                 break;
 472          }
 473         }
 474
 475
 476 }
 477
 478
 479 //=============================================================================
 480 /*!
 481  *  Destructor
 482  */
 483 //=============================================================================
 484
 485 Med_Gen_i::~Med_Gen_i()
 486 {
 487   MESSAGE("Med_Gen_i::~Med_Gen_i");
 488 }
 489
 490 //=============================================================================
 491 /*!
 492  *  CORBA: Save Mesh objects (called when a study is saved)
 493  */
 494 //=============================================================================
 495 SALOMEDS::TMPFile* Med_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
 496                                    const char* theURL,
 497                                    bool isMultiFile) {
 498   const char* LOC = "Med_Gen_i::Save";
 499   BEGIN_OF(LOC);
 500
 501   SALOMEDS::TMPFile_var aStreamFile;
 502   // Get a temporary directory to store a file
 503   TCollection_AsciiString aTmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
 504   // Create a list to store names of created files
 505   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 506   TColStd_SequenceOfAsciiString aFileNames;
 507
 508   CORBA::String_var aSaveStudyName("");
 509   if (isMultiFile) aSaveStudyName = strdup(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));
 510
 511   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 512   if (!CORBA::is_nil(aMedMeshFather)) {
 513     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 514     for(; anIter->More(); anIter->Next()) {
 515       SALOMEDS::SObject_var aSO = anIter->Value();
 516       SALOMEDS::GenericAttribute_var anAttr;
 517       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 518         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 519         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 520         if (! CORBA::is_nil(myMesh)) {
 521           TCollection_AsciiString aName(strdup(aSaveStudyName));
 522           aName += "_MEDMESH_";
 523           aName += myMesh->getName();
 524           aName += ".med";
 525           MESSAGE("Save mesh with name "<<aName.ToCString());
 526           long driverId = myMesh->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myMesh->getName());
 527           myMesh->write(driverId,"");
 528           aFileNames.Append(aName);
 529         }
 530       }
 531     }
 532   }
 533
 534   SALOMEDS::SObject_var aMedFieldFather = theComponent->GetStudy()->FindObject("MEDFIELD");
 535   if (!CORBA::is_nil(aMedFieldFather)) {
 536     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedFieldFather);
 537     for(; anIter->More(); anIter->Next()) {
 538       SALOMEDS::SObject_var aSO = anIter->Value();
 539       SALOMEDS::GenericAttribute_var anAttr;
 540       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 541         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 542         SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 543         if (! CORBA::is_nil(myField)) {
 544           ostringstream a,b;
 545           a<< myField->getOrderNumber();
 546           b<< myField->getIterationNumber();
 547
 548           TCollection_AsciiString aName(strdup(aSaveStudyName));
 549           aName += "_MEDFIELD_";
 550           aName += myField->getName();
 551           aName += "_ORDRE_";
 552           aName += strdup(a.str().c_str());
 553           aName += "_ITER_";
 554           aName += strdup(b.str().c_str());
 555           aName += ".med";
 556           MESSAGE("Save mesh with name "<<aName.ToCString());
 557           long driverId = myField->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myField->getName());
 558           myField->write(driverId,"");
 559           aFileNames.Append(aName);
 560         }
 561       }
 562     }
 563   }
 564
 565   int i;
 566   aSeq->length(aFileNames.Length());
 567   for(i = aFileNames.Length(); i > 0; i--) aSeq[i-1] = CORBA::string_dup(aFileNames.Value(i).ToCString());
 568   // Conver a file to the byte stream
 569   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 570   // Remove the created file and tmp directory
 571   if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 572   // Return the created byte stream
 573   return aStreamFile._retn();
 574
 575   END_OF(LOC);
 576 }
 577
 578 SALOMEDS::TMPFile* Med_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
 579                                         const char* theURL,
 580                                         bool isMultiFile) {
 581   const char* LOC = "Med_Gen_i::SaveASCII";
 582   BEGIN_OF(LOC);
 583
 584   SALOMEDS::TMPFile_var aStreamFile;
 585   // Get a temporary directory to store a file
 586   TCollection_AsciiString aTmpDir = (isMultiFile)?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
 587   // Create a list to store names of created files
 588   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 589   TColStd_SequenceOfAsciiString aFileNames;
 590
 591   CORBA::String_var aSaveStudyName("");
 592   if (isMultiFile) aSaveStudyName = strdup(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));
 593
 594   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 595   if (!CORBA::is_nil(aMedMeshFather)) {
 596     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 597     for(; anIter->More(); anIter->Next()) {
 598       SALOMEDS::SObject_var aSO = anIter->Value();
 599       SALOMEDS::GenericAttribute_var anAttr;
 600       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 601         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 602         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 603         if (! CORBA::is_nil(myMesh)) {
 604           TCollection_AsciiString aName(strdup(aSaveStudyName));
 605           aName += "_MEDMESH_";
 606           aName += myMesh->getName();
 607           aName += ".med";
 608           MESSAGE("Save mesh with name "<<aName.ToCString());
 609           long driverId = myMesh->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myMesh->getName());
 610           myMesh->write(driverId,"");
 611           HDFascii::ConvertFromHDFToASCII(strdup((aTmpDir+aName).ToCString()), true);
 612           aFileNames.Append(aName);
 613         }
 614       }
 615     }
 616   }
 617
 618   SALOMEDS::SObject_var aMedFieldFather = theComponent->GetStudy()->FindObject("MEDFIELD");
 619   if (!CORBA::is_nil(aMedFieldFather)) {
 620     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedFieldFather);
 621     for(; anIter->More(); anIter->Next()) {
 622       SALOMEDS::SObject_var aSO = anIter->Value();
 623       SALOMEDS::GenericAttribute_var anAttr;
 624       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 625         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 626         SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 627         if (! CORBA::is_nil(myField)) {
 628           ostringstream a,b;
 629           a<< myField->getOrderNumber();
 630           b<< myField->getIterationNumber();
 631
 632           TCollection_AsciiString aName(strdup(aSaveStudyName));
 633           aName += "_MEDFIELD_";
 634           aName += myField->getName();
 635           aName += "_ORDRE_";
 636           aName += strdup(a.str().c_str());
 637           aName += "_ITER_";
 638           aName += strdup(b.str().c_str());
 639           aName += ".med";
 640           MESSAGE("Save mesh with name "<<aName.ToCString());
 641           long driverId = myField->addDriver(SALOME_MED::MED_DRIVER,(aTmpDir+aName).ToCString(),myField->getName());
 642           myField->write(driverId,"");
 643           HDFascii::ConvertFromHDFToASCII(strdup((aTmpDir+aName).ToCString()), true);
 644           aFileNames.Append(aName);
 645         }
 646       }
 647     }
 648   }
 649
 650   int i;
 651   aSeq->length(aFileNames.Length());
 652   for(i = aFileNames.Length(); i > 0; i--) aSeq[i-1] = CORBA::string_dup(aFileNames.Value(i).ToCString());
 653   // Conver a file to the byte stream
 654   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 655   // Remove the created file and tmp directory
 656   if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 657   // Return the created byte stream
 658   return aStreamFile._retn();
 659
 660   END_OF(LOC);
 661 }
 662
 663 //=============================================================================
 664 /*!
 665  *  CORBA: Load Mesh objects (called when an existing study is opened)
 666  */
 667 //=============================================================================
 668
 669 CORBA::Boolean Med_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
 670                                const SALOMEDS::TMPFile& theStream,
 671                                const char* theURL,
 672                                bool isMultiFile) {
 673   const char* LOC = "Med_Gen_i::Load";
 674   BEGIN_OF(LOC);
 675
 676   // Get a temporary directory for a file
 677   TCollection_AsciiString aTmpDir =
 678     (isMultiFile)?TCollection_AsciiString((char*)theURL):SALOMEDS_Tool::GetTmpDir();
 679   _saveFileName = CORBA::string_dup(aTmpDir.ToCString());
 680   SALOMEDS::ListOfFileNames_var aSeq =
 681     SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.ToCString(), isMultiFile);
 682   return true;
 683
 684   END_OF(LOC);
 685 }
 686
 687 CORBA::Boolean Med_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
 688                                     const SALOMEDS::TMPFile& theStream,
 689                                     const char* theURL,
 690                                     bool isMultiFile) {
 691   return Load(theComponent, theStream, theURL, isMultiFile);
 692 }
 693
 694 //=============================================================================
 695 /*!
 696  *  CORBA:
 697  */
 698 //=============================================================================
 699
 700 void Med_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
 701 {
 702   MESSAGE("Med_Gen_i::Close");
 703   SALOMEDS::SObject_var aMedMeshFather = theComponent->GetStudy()->FindObject("MEDMESH");
 704   if (!CORBA::is_nil(aMedMeshFather)) {
 705     SALOMEDS::ChildIterator_var anIter = theComponent->GetStudy()->NewChildIterator(aMedMeshFather);
 706     for(; anIter->More(); anIter->Next()) {
 707       SALOMEDS::SObject_var aSO = anIter->Value();
 708       SALOMEDS::GenericAttribute_var anAttr;
 709       if (aSO->FindAttribute(anAttr,"AttributeIOR")) {
 710         CORBA::Object_var myIOR = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 711         SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 712         // here must call method destroy of myMesh, but it not implented yet
 713       }
 714     }
 715   }
 716 }
 717
 718 //=============================================================================
 719 /*!
 720  *  CORBA:
 721  */
 722 //=============================================================================
 723
 724 char* Med_Gen_i::ComponentDataType()
 725 {
 726   MESSAGE("Med_Gen_i::ComponentDataType");
 727   return strdup("MED") ; /* What is this type ? */
 728 }
 729
 730 //=============================================================================
 731 /*!
 732  *  CORBA: give a persistent reference of a transient object (for study save)
 733  */
 734 //=============================================================================
 735
 736 char* Med_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
 737                                         const char* IORString,
 738                                         CORBA::Boolean isMultiFile,
 739                                         CORBA::Boolean isASCII) {
 740   const char * LOC = "Med_Gen_i::IORToLocalPersistentID" ;
 741   BEGIN_OF(LOC) ;
 742   SCRUTE(IORString);
 743
 744
 745   if (string(IORString).size()==0) return "_MED";
 746   // Well, we know where put object (_saveFilename) and we know object (IORString)
 747   // cast object :
 748   CORBA::Object_var myIOR = _orb->string_to_object(IORString);
 749
 750   // MED
 751   SALOME_MED::MED_var myMed = SALOME_MED::MED::_narrow(myIOR);
 752   if (! CORBA::is_nil(myMed))
 753   {
 754         // nothing to save : Support will be saved inside the mesh
 755         string str_MedName="_MED Objet Med + /OBJ_MED/";
 756         return strdup(str_MedName.c_str()) ;
 757   }
 758
 759   // MESH
 760   SALOME_MED::MESH_var myMesh = SALOME_MED::MESH::_narrow(myIOR);
 761   if (! CORBA::is_nil(myMesh))
 762   {
 763     CORBA::String_var aName((string("_MEDMESH_")+ myMesh->getName() + ".med").c_str());
 764     return strdup(aName._retn()) ;
 765   }
 766
 767   // SUPPORT
 768   SALOME_MED::SUPPORT_var mySupport = SALOME_MED::SUPPORT::_narrow(myIOR);
 769   if (! CORBA::is_nil(mySupport))
 770   {
 771         // nothing to save : Support will be saved inside the mesh
 772         string str_SupportName;
 773         try
 774         {
 775                 str_SupportName=string("/FAS/")+string(mySupport->getName());
 776                 str_SupportName+=string("/ENS_MAA/")+string(mySupport->getMesh()->getName());
 777                 SCRUTE(str_SupportName);
 778         }
 779         catch(...)
 780         {
 781                 MESSAGE("Unable to save the support");
 782                 THROW_SALOME_CORBA_EXCEPTION("Unable to save Field in Med"\
 783                                               ,SALOME::INTERNAL_ERROR);
 784         }
 785     return strdup(("_MED"+str_SupportName).c_str());
 786   }
 787
 788   SALOME_MED::FIELD_var myField = SALOME_MED::FIELD::_narrow(myIOR);
 789   if (! CORBA::is_nil(myField))
 790   {
 791     string str_FieldName;
 792     ostringstream a,b;
 793     a<< myField->getOrderNumber();
 794     b<< myField->getIterationNumber();
 795     CORBA::String_var aName((string("_MEDFIELD_")+ myField->getName() +
 796                              string("_ORDRE_")+a.str()+
 797                              string("_ITER_")+b.str() +
 798                              ".med").c_str());
 799     return strdup(aName._retn());
 800   }
 801
 802   //THROW_SALOME_CORBA_EXCEPTION("Unable to save IOR",SALOME::BAD_PARAM);
 803   return "_MED";
 804
 805   END_OF(LOC) ;
 806 }
 807
 808 //=============================================================================
 809 /*!
 810  *  CORBA: give a transient reference (when loading an object, opening study)
 811  */
 812 //=============================================================================
 813
 814 char* Med_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
 815                                         const char* aLocalPersistentID,
 816                                         CORBA::Boolean isMultiFile,
 817                                         CORBA::Boolean isASCII)
 818      throw(SALOME::SALOME_Exception)
 819 {
 820   const char * LOC = "Med_Gen_i::LocalPersistentIDToIOR" ;
 821   BEGIN_OF(LOC) ;
 822   TCollection_AsciiString aTmpDir(CORBA::string_dup(_saveFileName.c_str()));
 823
 824   TCollection_AsciiString aSaveStudyName("");
 825   if (isMultiFile) aSaveStudyName = strdup(SALOMEDS_Tool::GetNameFromPath(theSObject->GetStudy()->URL()));
 826
 827   if (strcmp(aLocalPersistentID, "Objet Med + /OBJ_MED/") == 0) return strdup(""); // MED
 828
 829   if (strncmp(aLocalPersistentID, "_MEDMESH_",9) == 0) {// MESH
 830     MESH * myMesh= new MESH() ;
 831     int aMeshNameLen = strlen(aLocalPersistentID) - 12;
 832     char* aMeshName = new char[aMeshNameLen];
 833     strncpy(aMeshName, &(aLocalPersistentID[9]), aMeshNameLen-1);
 834     aMeshName[aMeshNameLen-1] = 0;
 835     myMesh->setName(aMeshName);
 836
 837     char* aFileName;
 838     if (isASCII) {
 839       char* aResultPath = HDFascii::ConvertFromASCIIToHDF((aTmpDir + strdup(aLocalPersistentID)).ToCString());
 840       aFileName = new char[strlen(aResultPath) + 19];
 841       sprintf(aFileName, "%shdf_from_ascii.hdf", aResultPath);
 842       delete(aResultPath);
 843     } else aFileName = strdup((aTmpDir + aSaveStudyName + strdup(aLocalPersistentID)).ToCString());
 844     MED_MESH_RDONLY_DRIVER myMeshDriver(aFileName,myMesh);
 845     try
 846       {
 847         myMeshDriver.setMeshName(aMeshName);
 848         myMeshDriver.open();
 849       }
 850     catch (const exception & ex)
 851       {
 852         MESSAGE("Exception Interceptee : ");
 853         SCRUTE(ex.what());
 854         THROW_SALOME_CORBA_EXCEPTION("Unable to find this mesh in this file",SALOME::BAD_PARAM);
 855       };
 856     try
 857       {
 858         myMeshDriver.read();
 859         MESSAGE("apres read");
 860         myMeshDriver.close();
 861       }
 862     catch (const exception & ex)
 863       {
 864         MESSAGE("Exception Interceptee : ");
 865         SCRUTE(ex.what());
 866         THROW_SALOME_CORBA_EXCEPTION("Unable to read this mesh in this file",SALOME::BAD_PARAM);
 867       }
 868     MESH_i * meshi = new MESH_i(myMesh);
 869     //SALOME_MED::MESH_var mesh = SALOME_MED::MESH::_narrow(meshi->_this());
 870     SALOME_MED::MESH_ptr mesh = meshi->_this();
 871     SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 872     aSeq->length(1);
 873     aSeq[0]=CORBA::string_dup(aLocalPersistentID);
 874     if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 875     if (isASCII) {
 876       SALOMEDS::ListOfFileNames_var aFilesToRemove = new SALOMEDS::ListOfFileNames;
 877       aFilesToRemove->length(1);
 878       aFilesToRemove[0] = strdup(&(aFileName[strlen(SALOMEDS_Tool::GetDirFromPath(aFileName))]));
 879       SALOMEDS_Tool::RemoveTemporaryFiles(SALOMEDS_Tool::GetDirFromPath(aFileName), aFilesToRemove, true);
 880     }
 881     delete(aFileName);
 882     return(CORBA::string_dup(_orb->object_to_string(mesh)));
 883   } else if (strncmp(aLocalPersistentID, "_MEDFIELD_",14) == 0) { // FIELD
 884     return(strdup("")); // not implemented yet
 885   }
 886
 887   return strdup("");
 888
 889   END_OF(LOC) ;
 890 }
 891
 892 //=============================================================================
 893 /*!
 894  *  returns true, if can publish object
 895  */
 896 //=============================================================================
 897 bool Med_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR) {
 898   SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(theIOR);
 899   return !(aMesh->_is_nil());
 900 }
 901
 902 //=============================================================================
 903 /*!
 904  *  publish the given object
 905  */
 906 //=============================================================================
 907 SALOMEDS::SObject_ptr Med_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
 908                                                 SALOMEDS::SObject_ptr theSObject,
 909                                                 CORBA::Object_ptr theObject,
 910                                                 const char* theName) throw (SALOME::SALOME_Exception)
 911 {
 912   SALOMEDS::SObject_var aResultSO;
 913
 914   if(CORBA::is_nil(theObject)) return aResultSO;
 915   if(theStudy->_is_nil()) return aResultSO;
 916
 917   SALOMEDS::StudyBuilder_var aBuilder = theStudy->NewBuilder();
 918   SALOMEDS::GenericAttribute_var anAttr;
 919   SALOMEDS::AttributeName_var    aName;
 920   SALOMEDS::AttributeIOR_var     anIOR;
 921   SALOMEDS::SComponent_var aFather = theStudy->FindComponent("MED");
 922
 923   if (aFather->_is_nil()) {
 924     aFather = aBuilder->NewComponent("MED");
 925     if (aFather->_is_nil()) return aResultSO;
 926     anAttr = aBuilder->FindOrCreateAttribute(aFather, "AttributeName");
 927     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 928     //NRI    aName->SetValue("MED");
 929
 930     CORBA::Object_var objVarN = _NS->Resolve("/Kernel/ModulCatalog");
 931     SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 932     SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "MED" );
 933     if ( !Comp->_is_nil() ) {
 934       aName->SetValue( Comp->componentusername() );
 935     }
 936     aBuilder->DefineComponentInstance(aFather, MED_Gen::_this());
 937   }
 938
 939   if (CORBA::is_nil(theSObject)) {
 940     SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(theObject);
 941     aMesh->addInStudy(theStudy, aMesh);
 942     SALOMEDS::SObject_var aResultSO = theStudy->FindObjectIOR(_orb->object_to_string(theObject));
 943   } else {
 944     if (!theSObject->ReferencedObject(aResultSO))
 945       THROW_SALOME_CORBA_EXCEPTION("Publish in study MED object error",SALOME::BAD_PARAM);
 946   }
 947 //    aBuilder->Addreference(theObject, aResultSO);
 948   return aResultSO._retn();
 949 }
 950
 951 //=============================================================================
 952 /*!
 953  *  returns true, if can copy the object
 954  */
 955 //=============================================================================
 956 CORBA::Boolean Med_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
 957   // Try to retrieve known by MED component mesh by given IOR
 958   SALOMEDS::GenericAttribute_var anAttr;
 959   if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return false;
 960   try {
 961     CORBA::Object_var anObj = _orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 962     SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(anObj);
 963     // If the object is null one it can't be copied: return false
 964     if (aMesh->_is_nil()) return false;
 965   } catch(...) {
 966     return false;
 967   }
 968   return true;
 969 }
 970
 971 //=============================================================================
 972 /*!
 973  *  create copy of the object and put it to the stream
 974  */
 975 //=============================================================================
 976 SALOMEDS::TMPFile* Med_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) {
 977     // Declare a sequence of the byte to store the copied object
 978   SALOMEDS::TMPFile_var aStreamFile;
 979
 980   // Try to get GEOM_Shape object by given SObject
 981   SALOMEDS::GenericAttribute_var anAttr;
 982   if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return new SALOMEDS::TMPFile(0);
 983   CORBA::String_var anIOR = strdup(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value());
 984   CORBA::Object_var anObj = _orb->string_to_object(anIOR);
 985   SALOME_MED::MESH_var aMesh = SALOME_MED::MESH::_narrow(anObj);
 986   if (aMesh->_is_nil()) return new SALOMEDS::TMPFile(0);
 987
 988   // Get a temporary directory to store a temporary file
 989   CORBA::String_var aTmpDir = SALOMEDS_Tool::GetTmpDir();
 990   // Create a list to store names of created files
 991   SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 992   aSeq->length(1);
 993   aSeq[0] = strdup(aMesh->getName());
 994   char* aFullName = new char[strlen(aTmpDir)+strlen(aSeq[0])+1];
 995   strcpy(aFullName, aTmpDir);
 996   strcpy(aFullName+strlen(aTmpDir), aSeq[0]);
 997   long driverId = aMesh->addDriver(SALOME_MED::MED_DRIVER,strdup(aFullName) , aMesh->getName());
 998   aMesh->write(driverId,"");
 999   delete(aFullName);
1000
1001   aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir, aSeq.in(), false);
1002   SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeq.in(), true);
1003
1004   // Assign an ID = 1 the the type SALOME_MED::MESH
1005   theObjectID = 1;
1006
1007   return aStreamFile._retn();
1008 }
1009
1010 //=============================================================================
1011 /*!
1012  *  returns true, if can copy the object
1013  */
1014 //=============================================================================
1015 CORBA::Boolean Med_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
1016   // The MED component can paste only objects copied by MED component
1017   // and with the object type = 1 (mesh)
1018   if (strcmp(theComponentName, ComponentDataType()) != 0 || theObjectID != 1) return false;
1019   return true;
1020 }
1021
1022 //=============================================================================
1023 /*!
1024  *  returns true, if can copy the object
1025  */
1026 //=============================================================================
1027 SALOMEDS::SObject_ptr Med_Gen_i::PasteInto(const SALOMEDS::TMPFile& theStream,
1028                                            CORBA::Long theObjectID,
1029                                            SALOMEDS::SObject_ptr theObject) {
1030   SALOMEDS::SObject_var aResultSO = SALOMEDS::SObject::_duplicate(theObject);
1031   if (theStream.length() == 0) return aResultSO._retn();
1032
1033   SALOMEDS::Study_var aStudy = theObject->GetStudy();
1034
1035   CORBA::String_var aTmpDir = strdup(SALOMEDS_Tool::GetTmpDir());
1036   SALOMEDS::ListOfFileNames_var aSeq = SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir, false);
1037   CORBA::String_var aMeshName = strdup(aSeq[0]);
1038   char* aFullName = new char[strlen(aTmpDir)+strlen(aMeshName)+1];
1039   strcpy(aFullName, aTmpDir);
1040   strcpy(aFullName+strlen(aTmpDir), aMeshName);
1041
1042   MESH * myMesh= new MESH() ;
1043   myMesh->setName((char*)aMeshName);
1044   MED_MESH_RDONLY_DRIVER myMeshDriver(aFullName, myMesh);
1045   try {
1046     myMeshDriver.setMeshName((char*)aMeshName);
1047     myMeshDriver.open();
1048   } catch (const exception & ex) {
1049     MESSAGE("Exception Interceptee : ");
1050     SCRUTE(ex.what());
1051     delete(aFullName);
1052     return aResultSO._retn();
1053   };
1054   try {
1055     myMeshDriver.read();
1056     ("apres read");
1057     myMeshDriver.close();
1058   } catch (const exception & ex) {
1059     MESSAGE("Exception Interceptee : ");
1060     SCRUTE(ex.what());
1061     delete(aFullName);
1062     return aResultSO._retn();
1063   };
1064   // set new mesh name, becouse now there are no possibility to operate meshes with the same names
1065 //    srand((unsigned int)time(NULL));
1066   int aRND = rand(); //Get a random number to present a name of a copied mesh
1067   char aCopiedMeshName[20];
1068   sprintf(aCopiedMeshName,"MESH_COPY_%d",aRND);
1069   myMesh->setName(aCopiedMeshName);
1070   MESH_i * meshi = new MESH_i(myMesh);
1071   SALOME_MED::MESH_ptr mesh = meshi->_this();
1072   // add the mesh object in study
1073   meshi->addInStudy(aStudy,mesh);
1074   // get the IOR attribute of just added mesh
1075   CORBA::String_var anIORString = _orb->object_to_string(mesh);
1076   aResultSO = aStudy->FindObjectIOR(anIORString);
1077
1078   SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aSeq.in(), true);
1079   delete(aFullName);
1080   return aResultSO._retn();
1081 }
1082
1083
1084
1085
1086
1087
1088 //=============================================================================
1089 /*!
1090  * C factory, accessible with dlsym, after dlopen
1091  */
1092 //=============================================================================
1093
1094 extern "C"
1095 {
1096   PortableServer::ObjectId * MEDEngine_factory(
1097                                CORBA::ORB_ptr orb,
1098                                PortableServer::POA_ptr poa,
1099                                PortableServer::ObjectId * contId,
1100                                const char *instanceName,
1101                                const char *interfaceName)
1102   {
1103     MESSAGE("PortableServer::ObjectId * MedEngine_factory()");
1104     SCRUTE(interfaceName);
1105     Med_Gen_i * myMed_Gen
1106       = new Med_Gen_i(orb, poa, contId, instanceName, interfaceName);
1107     return myMed_Gen->getId() ;
1108   }
1109 }