src/SALOMEDSImpl/SALOMEDSImpl_Study.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
  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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  File   : SALOMEDSImpl_Study.cxx
  24 //  Author : Sergey RUIN
  25 //  Module : SALOME
  26 //
  27 #include "SALOMEDSImpl_Study.hxx"
  28 #include <string.h>
  29
  30 #include <KERNEL_version.h>
  31 #include <Basics_Utils.hxx>
  32 #include <Basics_DirUtils.hxx>
  33
  34 #include "HDFexplorer.hxx"
  35
  36 #include "DF_Application.hxx"
  37 #include "DF_ChildIterator.hxx"
  38
  39 #include "SALOMEDSImpl_ChildNodeIterator.hxx"
  40 #include "SALOMEDSImpl_Attributes.hxx"
  41 #include "SALOMEDSImpl_UseCaseIterator.hxx"
  42 #include "SALOMEDSImpl_AttributeReference.hxx"
  43 #include "SALOMEDSImpl_StudyHandle.hxx"
  44 #include "SALOMEDSImpl_Tool.hxx"
  45 #include "SALOMEDSImpl_IParameters.hxx"
  46 #include "SALOMEDSImpl_ScalarVariable.hxx"
  47 #include "SALOMEDSImpl_SComponent.hxx"
  48
  49 #include "HDFOI.hxx"
  50 #include <fstream>
  51 #include <sstream>
  52 #include <algorithm>
  53
  54 // comment out the following define to enable \t symbols in in the python dump files
  55 #define WITHOUT_TABS
  56
  57 #define DIRECTORYID       16661
  58 #define FILELOCALID       26662
  59 #define FILEID            "FILE: "
  60 #define VARIABLE_SEPARATOR  ':'
  61 #define OPERATION_SEPARATOR '|'
  62 #define USE_CASE_LABEL_ID "0:2"
  63
  64 static void SaveAttributes(const SALOMEDSImpl_SObject& SO, HDFgroup *hdf_group_sobject);
  65 static void ReadAttributes(SALOMEDSImpl_Study*, const SALOMEDSImpl_SObject&, HDFdataset* );
  66 static void BuildTree (SALOMEDSImpl_Study*, HDFgroup*);
  67 static void Translate_IOR_to_persistentID (const SALOMEDSImpl_SObject&,
  68                                            SALOMEDSImpl_Driver*, bool isMultiFile, bool isASCII);
  69 static void ReadNoteBookVariables(SALOMEDSImpl_Study* theStudy, HDFgroup* theGroup);
  70
  71 namespace {
  72   class StudyUnlocker
  73   {
  74   public:
  75     StudyUnlocker( SALOMEDSImpl_Study* study ): myStudy( study ), myLocked( false )
  76     {
  77       myPrevLocked = myStudy->GetProperties()->IsLocked();
  78       resume();
  79     }
  80     ~StudyUnlocker()
  81     {
  82       suspend();
  83     }
  84     void suspend()
  85     {
  86       if (myLocked) {
  87             myStudy->GetProperties()->SetLocked(true);
  88             myPrevLocked = myLocked;
  89             myLocked = false;
  90       }
  91     }
  92     void resume()
  93     {
  94       if (myPrevLocked) {
  95             myStudy->GetProperties()->SetLocked(false);
  96             myLocked = myPrevLocked;
  97             myPrevLocked = false;
  98       }
  99     }
 100   private:
 101     SALOMEDSImpl_Study* myStudy;
 102     bool myLocked;
 103     bool myPrevLocked;
 104   };
 105 }
 106
 107 //============================================================================
 108 /*! Function : SALOMEDSImpl_Study
 109  *  Purpose  : SALOMEDSImpl_Study constructor
 110  */
 111 //============================================================================
 112 SALOMEDSImpl_Study::SALOMEDSImpl_Study()
 113 {
 114   _appli = new DF_Application();
 115   _clipboard = _appli->NewDocument("SALOME_STUDY");
 116
 117   Init();
 118 }
 119
 120 //============================================================================
 121 /*! Function : ~SALOMEDSImpl_Study
 122  *  Purpose  : SALOMEDSImpl_Study destructor
 123  */
 124 //============================================================================
 125 SALOMEDSImpl_Study::~SALOMEDSImpl_Study()
 126 {
 127   Clear();
 128   _appli->Close(_clipboard);
 129   // Destroy application
 130   delete _appli;
 131 }
 132
 133 //============================================================================
 134 /*! Function : Init
 135  *  Purpose  : Initialize study components
 136  */
 137 //============================================================================
 138 void SALOMEDSImpl_Study::Init()
 139 {
 140   static int _id = 0;
 141   std::stringstream sstrm;
 142   sstrm << ++_id;
 143   _name = "Study" + std::string(sstrm.str());
 144   _doc = _appli->NewDocument("SALOME_STUDY");
 145   _Saved = false;
 146   _URL = "";
 147   _autoFill = false;
 148   _errorCode = "";
 149   _useCaseBuilder = new SALOMEDSImpl_UseCaseBuilder(_doc);
 150   _builder = new SALOMEDSImpl_StudyBuilder(this);
 151   _cb = new SALOMEDSImpl_Callback(_useCaseBuilder);
 152   _notifier=0;
 153   _genObjRegister=0;
 154   //Put on the root label a StudyHandle attribute to store the address of this object
 155   //It will be used to retrieve the study object by DF_Label that belongs to the study
 156   SALOMEDSImpl_StudyHandle::Set(_doc->Main().Root(), this);
 157
 158   // set Study properties
 159   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
 160
 161   int month=0,day=0,year=0,hh=0,mn=0,ss=0;
 162   SALOMEDSImpl_Tool::GetSystemDate(year, month, day, hh, mn, ss);
 163   aProp->SetModification(SALOMEDSImpl_Tool::GetUserName(),
 164                          mn, hh, day, month, year);
 165   aProp->SetCreationMode(1);  //"from scratch"
 166 }
 167
 168 //============================================================================
 169 /*! Function : Clear
 170  *  Purpose  : Clear study components
 171  */
 172 //============================================================================
 173 void SALOMEDSImpl_Study::Clear()
 174 {
 175   delete _builder;
 176   delete _cb;
 177   delete _useCaseBuilder;
 178   URL("");
 179   _appli->Close(_doc);
 180   _doc = NULL;
 181   _mapOfSO.clear();
 182   _mapOfSCO.clear();
 183 }
 184
 185 //============================================================================
 186 /*! Function : Open
 187  *  Purpose  : Open a Study from it's persistent reference
 188  */
 189 //============================================================================
 190 bool SALOMEDSImpl_Study::Open(const std::string& aUrl)
 191 {
 192   // Set "C" locale temporarily to avoid possible localization problems
 193   Kernel_Utils::Localizer loc;
 194
 195   _errorCode = "";
 196
 197   // open the HDFFile
 198   HDFfile *hdf_file =0;
 199   HDFgroup *hdf_group_study_structure =0;
 200   HDFgroup *hdf_notebook_vars = 0;
 201
 202   char* aC_HDFUrl;
 203   std::string aHDFUrl;
 204   bool isASCII = false;
 205   if (HDFascii::isASCII(aUrl.c_str())) {
 206     isASCII = true;
 207     char* aResultPath = HDFascii::ConvertFromASCIIToHDF(aUrl.c_str());
 208     if ( !aResultPath )
 209       return NULL;
 210     aC_HDFUrl = new char[strlen(aResultPath) + 19];
 211     sprintf(aC_HDFUrl, "%shdf_from_ascii.hdf", aResultPath);
 212     delete [] (aResultPath);
 213     aHDFUrl = aC_HDFUrl;
 214     delete [] aC_HDFUrl;
 215   }
 216   else {
 217     aHDFUrl = aUrl;
 218   }
 219
 220   hdf_file = new HDFfile((char*)aHDFUrl.c_str());
 221   try {
 222     hdf_file->OpenOnDisk(HDF_RDONLY);// mpv: was RDWR, but opened file can be write-protected too
 223   }
 224   catch (HDFexception)
 225   {
 226     char *eStr;
 227     eStr = new char[strlen(aUrl.c_str())+17];
 228     sprintf(eStr,"Can't open file %s",aUrl.c_str());
 229     delete [] eStr;
 230     _errorCode = std::string(eStr);
 231     return NULL;
 232   }
 233
 234   // Assign the value of the URL in the study object
 235   URL(aUrl);
 236
 237   SALOMEDSImpl_AttributePersistentRef::Set(_doc->Main(), aUrl);
 238
 239   if (!hdf_file->ExistInternalObject("STUDY_STRUCTURE")) {
 240      _errorCode = "Study is empty";
 241     return false;
 242   }
 243
 244   //Create  the Structure of the Document
 245   hdf_group_study_structure = new HDFgroup("STUDY_STRUCTURE",hdf_file);
 246
 247   try {
 248     BuildTree (this, hdf_group_study_structure);
 249   }
 250   catch (HDFexception)
 251   {
 252     char *eStr = new char [strlen(aUrl.c_str())+17];
 253     sprintf(eStr,"Can't open file %s", aUrl.c_str());
 254     _errorCode = std::string(eStr);
 255     return false;
 256   }
 257
 258   //Read and create notebook variables
 259   if(hdf_file->ExistInternalObject("NOTEBOOK_VARIABLES")) {
 260     hdf_notebook_vars  = new HDFgroup("NOTEBOOK_VARIABLES",hdf_file);
 261     ReadNoteBookVariables(this, hdf_notebook_vars);
 262     hdf_notebook_vars =0; //will be deleted by hdf_sco_group destructor
 263   }
 264
 265   hdf_file->CloseOnDisk();
 266   hdf_group_study_structure = new HDFgroup("STUDY_STRUCTURE",hdf_file);
 267
 268   if (isASCII) {
 269     std::vector<std::string> aFilesToRemove;
 270     aFilesToRemove.push_back("hdf_from_ascii.hdf");
 271     SALOMEDSImpl_Tool::RemoveTemporaryFiles(SALOMEDSImpl_Tool::GetDirFromPath(aHDFUrl), aFilesToRemove, true);
 272   }
 273
 274   delete hdf_file; // all related hdf objects will be deleted
 275
 276   // unlock study if it is locked, to set components versions
 277   StudyUnlocker unlock(this);
 278
 279   //For old studies we have to add "unknown" version tag for all stored components
 280   SALOMEDSImpl_SComponentIterator itcomponent = NewComponentIterator();
 281   for (; itcomponent.More(); itcomponent.Next())
 282   {
 283     SALOMEDSImpl_SComponent sco = itcomponent.Value();
 284     std::string aCompType = sco.GetComment();
 285     if ( aCompType == SALOMEDSImpl_IParameters::getDefaultVisualComponent() ) continue;
 286     if ( GetProperties()->GetComponentVersions( aCompType ).empty() )
 287       GetProperties()->SetComponentVersion( aCompType, "" ); // empty version means "unknown"
 288   }
 289
 290   return true;
 291 }
 292
 293 //============================================================================
 294 /*! Function : Save
 295  *  Purpose  : Save a Study to it's persistent reference
 296  */
 297 //============================================================================
 298 bool SALOMEDSImpl_Study::Save(SALOMEDSImpl_DriverFactory* aFactory,
 299                               bool theMultiFile,
 300                               bool theASCII)
 301 {
 302   _errorCode = "";
 303
 304   std::string url = URL();
 305   if (url.empty()) {
 306     _errorCode = "No path specified to save the study. Nothing done";
 307     return false;
 308   }
 309   else {
 310     return Impl_SaveAs(url, aFactory, theMultiFile, theASCII);
 311   }
 312
 313   return false;
 314 }
 315
 316 //=============================================================================
 317 /*! Function : SaveAs
 318  *  Purpose  : Save a study to the persistent reference aUrl
 319  */
 320 //============================================================================
 321 bool SALOMEDSImpl_Study::SaveAs(const std::string& aUrl,
 322                                 SALOMEDSImpl_DriverFactory* aFactory,
 323                                 bool theMultiFile,
 324                                 bool theASCII)
 325 {
 326   _errorCode = "";
 327   return Impl_SaveAs(aUrl, aFactory, theMultiFile, theASCII);
 328 }
 329
 330 //=============================================================================
 331 /*! Function : _SaveProperties
 332  *  Purpose  : save the study properties in HDF file
 333  */
 334 //============================================================================
 335 bool SALOMEDSImpl_Study::Impl_SaveProperties(HDFgroup *hdf_group)
 336 {
 337   _errorCode = "";
 338
 339   HDFdataset *hdf_dataset = 0;
 340   hdf_size size[1];
 341   hdf_int32 name_len;
 342
 343   // add modifications list (user and date of save)
 344   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
 345
 346   // unlock study if it is locked, to set modification date
 347   StudyUnlocker unlock(this);
 348
 349   int month=0,day=0,year=0,hh=0,mn=0,ss=0;
 350   SALOMEDSImpl_Tool::GetSystemDate(year, month, day, hh, mn, ss);
 351   aProp->SetModification(SALOMEDSImpl_Tool::GetUserName(),
 352                                      mn, hh, day, month, year);
 353
 354   // lock study back if it was locked initially, to write correct value of Locked flag
 355   unlock.suspend();
 356
 357   std::vector<std::string> aNames;
 358   std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
 359
 360   aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
 361
 362   std::string units = aProp->GetUnits();
 363   std::string comment = aProp->GetComment();
 364
 365   std::map< std::string, std::vector<std::string> > allVersions = aProp->GetComponentsVersions();
 366   std::map<std::string, std::string> versions;
 367
 368   int aLength = 0, aLength1 = 0, anIndex, i, unitsSize = 0, commentSize = 0;
 369
 370   for(i=1; i<=aNames.size(); i++)
 371     aLength += aNames[i-1].size() + 1;
 372
 373   std::map< std::string, std::vector<std::string> >::const_iterator it;
 374   for (it = allVersions.begin(); it != allVersions.end(); ++it ) {
 375     std::string vlist = "";
 376     std::vector<std::string> vl = it->second;
 377     std::vector<std::string>::const_iterator vlit;
 378     for ( vlit = vl.begin(); vlit != vl.end(); ++vlit ) {
 379       if ( vlist != "" ) vlist += ";";
 380       vlist += *vlit;
 381     }
 382     versions[ it->first ] = vlist;
 383     aLength1 += it->first.size() + vlist.size() + 2;
 384   }
 385
 386   unitsSize = units.size();
 387   commentSize = comment.size();
 388
 389   //string format:
 390   //locked flag, modified flag,
 391   //minutes, hours, day, months, year, user name, char(1),
 392   //minutes, hours, day, months, year, user name, char(1),
 393   //.....................................................,
 394   //.....................................................,
 395   //.....................................................,
 396   //minutes, hours, day, months, year, user name, char(1), char(30) <- !!!! used to define end of section with modifications !!!!
 397   //units, char(1), comment, char(30) <- !!!! used to define start of section with components' versions !!!!
 398   //component=versions, char(1),
 399   //component=versions, char(1),
 400   //...........................,
 401   //component=versions, char(1), char(0)
 402
 403   //string length: 1 byte = locked flag, 1 byte = modified flag, (12 + name length + 1) for each name and date, 1 byte (char(30) section delimeter)
 404   // unit length + 1, comment length, "zero" byte
 405
 406   char* aProperty = new char[3 + aLength + 12 * aNames.size() + 1 + unitsSize + 1 + commentSize + 1 + aLength1 ];
 407
 408   sprintf(aProperty,"%c%c", (char)aProp->GetCreationMode(),  (aProp->IsLocked())?'l':'u');
 409
 410   aLength = aNames.size();
 411   int a = 2;
 412   for(anIndex = 0; anIndex<aLength; anIndex++) {
 413     sprintf(&(aProperty[a]),"%2d%2d%2d%2d%4d%s",
 414             (int)(aMinutes[anIndex]),
 415             (int)(aHours[anIndex]),
 416             (int)(aDays[anIndex]),
 417             (int)(aMonths[anIndex]),
 418             (int)(aYears[anIndex]),
 419             aNames[anIndex].c_str());
 420     a = strlen(aProperty);
 421     aProperty[a++] = 1;
 422   }
 423
 424   //Write delimeter of the section to define end of the modifications section
 425   aProperty[a++] = 30;
 426
 427   //Write units if need
 428   if(units.size() > 0) {
 429     sprintf(&(aProperty[a]),"%s",units.c_str());
 430     a = strlen(aProperty);
 431   }
 432
 433   aProperty[a++] = 1;
 434
 435   //Write comments if need
 436   if(comment.size() > 0) {
 437     sprintf(&(aProperty[a]),"%s",comment.c_str());
 438     a = strlen(aProperty);
 439   }
 440
 441   aProperty[a++] = 30; //delimeter of the component versions
 442
 443   std::map<std::string, std::string>::const_iterator versionsIt;
 444   for ( versionsIt = versions.begin(); versionsIt != versions.end(); ++versionsIt ) {
 445     sprintf(&(aProperty[a]),"%s=%s",
 446             (char*)(versionsIt->first.c_str()),
 447             (char*)(versionsIt->second.c_str()));
 448     a = a + versionsIt->first.size() + versionsIt->second.size() + 1;
 449     aProperty[a++] = 1;
 450   }
 451
 452   aProperty[a] = 0;
 453
 454   name_len = (hdf_int32) a;
 455   size[0] = name_len + 1 ;
 456   hdf_dataset = new HDFdataset("AttributeStudyProperties",hdf_group,HDF_STRING,size,1);
 457   hdf_dataset->CreateOnDisk();
 458   hdf_dataset->WriteOnDisk(aProperty);
 459   hdf_dataset->CloseOnDisk();
 460   hdf_dataset=0; //will be deleted by hdf_sco_group destructor
 461   delete [] aProperty;
 462
 463   aProp->SetModified(0);
 464   return true;
 465 }
 466
 467 //=============================================================================
 468 /*! Function : _SaveAs
 469  *  Purpose  : save the study in HDF file
 470  */
 471 //============================================================================
 472 bool SALOMEDSImpl_Study::Impl_SaveAs(const std::string& aStudyUrl,
 473                                      SALOMEDSImpl_DriverFactory* aFactory,
 474                                      bool theMultiFile,
 475                                      bool theASCII)
 476 {
 477   // Set "C" locale temporarily to avoid possible localization problems
 478   Kernel_Utils::Localizer loc;
 479
 480   // HDF File will be composed of differents part :
 481   // * For each ComponentDataType, all data created by the component
 482   //   Informations in data group hdf_group_datacomponent
 483   // * Study Structure -> Exactly what is contained in Document
 484   //   Informations in data group hdf_group_study_structure
 485
 486   _errorCode = "";
 487
 488   HDFfile *hdf_file=0;
 489   HDFgroup *hdf_group_study_structure =0;
 490   HDFgroup *hdf_sco_group =0;
 491   HDFgroup *hdf_sco_group2 =0;
 492   HDFgroup *hdf_notebook_vars =0;
 493   HDFgroup *hdf_notebook_var  = 0;
 494
 495   HDFgroup *hdf_group_datacomponent =0;
 496   HDFdataset *hdf_dataset =0;
 497   hdf_size size[1];
 498   hdf_int32 name_len = 0;
 499   std::string component_name;
 500
 501   // Store previous URL
 502   std::string anOldName = URL();
 503
 504   // Map to store components' versions
 505   std::map<std::string, std::string> componentVersions;
 506
 507   //Create a temporary url to which the study is saved
 508   std::string aUrl = SALOMEDSImpl_Tool::GetTmpDir() + SALOMEDSImpl_Tool::GetNameFromPath(aStudyUrl);
 509
 510   // unlock study if it is locked, as some attributes need to be modified
 511   StudyUnlocker unlock(this);
 512
 513   SALOMEDSImpl_StudyBuilder* SB= NewBuilder();
 514   std::map<std::string, SALOMEDSImpl_Driver*> aMapTypeDriver;
 515
 516   try {
 517     // mpv 15.12.2003: for saving components we have to load all data from all modules
 518     SALOMEDSImpl_SComponentIterator itcomponent = NewComponentIterator();
 519     for (; itcomponent.More(); itcomponent.Next()) {
 520       SALOMEDSImpl_SComponent sco = itcomponent.Value();
 521       // if there is an associated Engine call its method for saving
 522       std::string IOREngine;
 523       try {
 524         SALOMEDSImpl_Driver* aDriver = NULL;
 525         std::string aCompType = sco.GetComment();
 526         if (!sco.ComponentIOR(IOREngine)) {
 527           if (!aCompType.empty()) {
 528             aDriver = aFactory->GetDriverByType(aCompType);
 529             if (aDriver != NULL) {
 530               if (!SB->LoadWith(sco, aDriver)) {
 531                 _errorCode = SB->GetErrorCode();
 532                 return false;
 533               }
 534             }
 535           }
 536         }
 537             else {
 538               aDriver = aFactory->GetDriverByIOR(IOREngine);
 539             }
 540             aMapTypeDriver[aCompType] = aDriver;
 541       }
 542       catch(...) {
 543         _errorCode = "Can not restore information to resave it";
 544         return false;
 545       }
 546     }
 547
 548     // VSR: set URL to new file name
 549     // VSR: remember to set previous name if save operation fails
 550     URL(aStudyUrl);
 551
 552     // To change for Save
 553     // Do not have to do a new file but just a Open??? Rewrite all informations after erasing evrything??
 554     hdf_file = new HDFfile((char*)aUrl.c_str());
 555     hdf_file->CreateOnDisk();
 556
 557     //-----------------------------------------------------------------------
 558     // 1 - Create a groupe for each SComponent and Update the PersistanceRef
 559     //-----------------------------------------------------------------------
 560     hdf_group_datacomponent = new HDFgroup("DATACOMPONENT",hdf_file);
 561     hdf_group_datacomponent->CreateOnDisk();
 562
 563     for (itcomponent.Init(); itcomponent.More(); itcomponent.Next()) {
 564       SALOMEDSImpl_SComponent sco = itcomponent.Value();
 565
 566       std::string scoid = sco.GetID();
 567       hdf_sco_group = new HDFgroup((char*)scoid.c_str(), hdf_group_datacomponent);
 568       hdf_sco_group->CreateOnDisk();
 569
 570       std::string componentDataType = sco.ComponentDataType();
 571       std::string IOREngine;
 572       if (sco.ComponentIOR(IOREngine)) {
 573         // Engine should be already in the map as it was to added before
 574         SALOMEDSImpl_Driver* Engine = aMapTypeDriver[componentDataType];
 575         if (Engine != NULL) {
 576           SALOMEDSImpl_TMPFile* aStream = NULL;
 577           long length = 0;
 578
 579           componentVersions[ componentDataType ] = Engine->Version();
 580
 581           if (theASCII) aStream = Engine->SaveASCII(sco,
 582                                                     SALOMEDSImpl_Tool::GetDirFromPath(aUrl),
 583                                                     length,
 584                                                     theMultiFile);
 585           else aStream = Engine->Save(sco,
 586                                       SALOMEDSImpl_Tool::GetDirFromPath(aUrl),
 587                                       length,
 588                                       theMultiFile);
 589           HDFdataset *hdf_dataset;
 590           hdf_size aHDFSize[1];
 591           if (length > 0) {  //The component saved some auxiliary files, then put them into HDF file
 592             aHDFSize[0] = length;
 593
 594             HDFdataset *hdf_dataset = new HDFdataset("FILE_STREAM", hdf_sco_group, HDF_STRING, aHDFSize, 1);
 595             hdf_dataset->CreateOnDisk();
 596             hdf_dataset->WriteOnDisk(aStream->Data());  //Save the stream in the HDF file
 597             hdf_dataset->CloseOnDisk();
 598           }
 599
 600           if (aStream) delete aStream;
 601
 602           // store multifile state
 603           aHDFSize[0] = 2;
 604           hdf_dataset = new HDFdataset("MULTIFILE_STATE", hdf_sco_group, HDF_STRING, aHDFSize, 1);
 605           hdf_dataset->CreateOnDisk();
 606           hdf_dataset->WriteOnDisk((void*)(theMultiFile?"M":"S")); // save: multi or single
 607           hdf_dataset->CloseOnDisk();
 608           hdf_dataset=0; //will be deleted by hdf_sco_AuxFiles destructor
 609           // store ASCII state
 610           aHDFSize[0] = 2;
 611           hdf_dataset = new HDFdataset("ASCII_STATE", hdf_sco_group, HDF_STRING, aHDFSize, 1);
 612           hdf_dataset->CreateOnDisk();
 613           hdf_dataset->WriteOnDisk((void*)(theASCII?"A":"B")); // save: ASCII or BINARY
 614           hdf_dataset->CloseOnDisk();
 615           hdf_dataset=0; //will be deleted by hdf_sco_AuxFiles destructor
 616           // Creation of the persistance reference  attribute
 617           Translate_IOR_to_persistentID (sco, Engine, theMultiFile, theASCII);
 618         }
 619       }
 620       hdf_sco_group->CloseOnDisk();
 621       hdf_sco_group=0; // will be deleted by hdf_group_datacomponent destructor
 622     }
 623     hdf_group_datacomponent->CloseOnDisk();
 624     hdf_group_datacomponent =0;  // will be deleted by hdf_file destructor
 625
 626     //-----------------------------------------------------------------------
 627     //3 - Write the Study Structure
 628     //-----------------------------------------------------------------------
 629     hdf_group_study_structure = new HDFgroup("STUDY_STRUCTURE",hdf_file);
 630     hdf_group_study_structure->CreateOnDisk();
 631     // save component attributes
 632     for (itcomponent.Init(); itcomponent.More(); itcomponent.Next()) {
 633       SALOMEDSImpl_SComponent SC = itcomponent.Value();
 634       std::string scid = SC.GetID();
 635       hdf_sco_group2 = new HDFgroup((char*)scid.c_str(), hdf_group_study_structure);
 636       hdf_sco_group2->CreateOnDisk();
 637       SaveAttributes(SC, hdf_sco_group2);
 638       // ComponentDataType treatment
 639       component_name = SC.ComponentDataType();
 640       name_len = (hdf_int32)component_name.length();
 641       size[0] = name_len +1 ;
 642       hdf_dataset = new HDFdataset("COMPONENTDATATYPE",hdf_sco_group2,HDF_STRING,size,1);
 643       hdf_dataset->CreateOnDisk();
 644       hdf_dataset->WriteOnDisk((char*)component_name.c_str());
 645       hdf_dataset->CloseOnDisk();
 646       hdf_dataset=0; //will be deleted by hdf_sco_group destructor
 647       Impl_SaveObject(SC, hdf_sco_group2);
 648       hdf_sco_group2->CloseOnDisk();
 649       hdf_sco_group2=0; // will be deleted by hdf_group_study_structure destructor
 650     }
 651     //-----------------------------------------------------------------------
 652     //4 - Write the Study UseCases Structure
 653     //-----------------------------------------------------------------------
 654     SALOMEDSImpl_SObject aSO = FindObjectID(USE_CASE_LABEL_ID);
 655     if (aSO) {
 656       HDFgroup *hdf_soo_group = new HDFgroup(USE_CASE_LABEL_ID,hdf_group_study_structure);
 657       hdf_soo_group->CreateOnDisk();
 658       SaveAttributes(aSO, hdf_soo_group);
 659       Impl_SaveObject(aSO, hdf_soo_group);
 660       hdf_soo_group->CloseOnDisk();
 661       hdf_soo_group=0; // will be deleted by hdf_group_study_structure destructor
 662     }
 663     //-----------------------------------------------------------------------
 664     //5 - Write the NoteBook Variables
 665     //-----------------------------------------------------------------------
 666
 667     //5.1 Create group to store all note book variables
 668     hdf_notebook_vars = new HDFgroup("NOTEBOOK_VARIABLES",hdf_file);
 669     hdf_notebook_vars->CreateOnDisk();
 670
 671     std::string varValue;
 672     std::string varType;
 673     std::string varIndex;
 674
 675     for (int i=0 ;i < myNoteBookVars.size(); i++ ) {
 676       // For each variable create HDF group
 677       hdf_notebook_var = new HDFgroup((char*)myNoteBookVars[i]->Name().c_str(),hdf_notebook_vars);
 678       hdf_notebook_var->CreateOnDisk();
 679
 680       // Save Variable type
 681       varType = myNoteBookVars[i]->SaveType();
 682       name_len = (hdf_int32) varType.length();
 683       size[0] = name_len +1 ;
 684       hdf_dataset = new HDFdataset("VARIABLE_TYPE",hdf_notebook_var,HDF_STRING,size,1);
 685       hdf_dataset->CreateOnDisk();
 686       hdf_dataset->WriteOnDisk((char*)varType.c_str());
 687       hdf_dataset->CloseOnDisk();
 688       hdf_dataset=0; //will be deleted by hdf_sco_group destructor
 689
 690       char buffer[256];
 691       sprintf(buffer,"%d",i);
 692       varIndex= std::string(buffer);
 693       name_len = (hdf_int32) varIndex.length();
 694       size[0] = name_len +1 ;
 695       hdf_dataset = new HDFdataset("VARIABLE_INDEX",hdf_notebook_var,HDF_STRING,size,1);
 696       hdf_dataset->CreateOnDisk();
 697       hdf_dataset->WriteOnDisk((char*)varIndex.c_str());
 698       hdf_dataset->CloseOnDisk();
 699       hdf_dataset=0; //will be deleted by hdf_sco_group destructor
 700
 701       // Save Variable value
 702       varValue = myNoteBookVars[i]->Save();
 703       name_len = (hdf_int32) varValue.length();
 704       size[0] = name_len +1 ;
 705       hdf_dataset = new HDFdataset("VARIABLE_VALUE",hdf_notebook_var,HDF_STRING,size,1);
 706       hdf_dataset->CreateOnDisk();
 707       hdf_dataset->WriteOnDisk((char*)varValue.c_str());
 708       hdf_dataset->CloseOnDisk();
 709       hdf_dataset=0; //will be deleted by hdf_sco_group destructor
 710       hdf_notebook_var->CloseOnDisk();
 711       hdf_notebook_var = 0; //will be deleted by hdf_sco_group destructor
 712     }
 713     hdf_notebook_vars->CloseOnDisk();
 714     hdf_notebook_vars = 0; //will be deleted by hdf_sco_group destructor
 715
 716     // record component versions
 717     std::map<std::string, std::string>::const_iterator itVersions;
 718     for ( itVersions = componentVersions.begin(); itVersions != componentVersions.end(); ++itVersions )
 719       GetProperties()->SetComponentVersion( itVersions->first, itVersions->second );
 720
 721     // lock study back if it was locked initially, to write correct value of Locked flag
 722     unlock.suspend();
 723
 724     //-----------------------------------------------------------------------
 725     //6 - Write the Study Properties
 726     //-----------------------------------------------------------------------
 727     std::string study_name = Name();
 728     name_len = (hdf_int32) study_name.size();
 729     size[0] = name_len +1 ;
 730     hdf_dataset = new HDFdataset("STUDY_NAME",hdf_group_study_structure,HDF_STRING,size,1);
 731     hdf_dataset->CreateOnDisk();
 732     hdf_dataset->WriteOnDisk((char*)study_name.c_str());
 733     hdf_dataset->CloseOnDisk();
 734     hdf_dataset=0; // will be deleted by hdf_group_study_structure destructor
 735
 736     Impl_SaveProperties(hdf_group_study_structure);
 737     hdf_group_study_structure->CloseOnDisk();
 738     hdf_file->CloseOnDisk();
 739
 740     hdf_group_study_structure =0; // will be deleted by hdf_file destructor
 741     delete hdf_file; // recursively deletes all hdf objects...
 742   }
 743   catch (HDFexception) {
 744     _errorCode = "HDFexception ! ";
 745     URL( anOldName ); // VSR: restore previous url if operation is failed
 746     return false;
 747   }
 748   catch (std::exception& exc) {
 749     _errorCode = const_cast<char*>(exc.what());
 750     URL( anOldName ); // VSR: restore previous url if operation is failed
 751     return false;
 752   }
 753   catch (...) {
 754     _errorCode = "Unknown exception ! ";
 755     URL( anOldName ); // VSR: restore previous url if operation is failed
 756     return false;
 757   }
 758   if (theASCII) { // save file in ASCII format
 759     HDFascii::ConvertFromHDFToASCII(aUrl.c_str(), true);
 760   }
 761
 762   // Now it's necessary to copy files from the temporary directory to the user defined directory.
 763   // The easiest way to get a list of file in the temporary directory
 764
 765   std::string aCmd, aTmpFileDir = SALOMEDSImpl_Tool::GetTmpDir();
 766   std::string aTmpFile = aTmpFileDir +"files";
 767   std::string aStudyTmpDir = SALOMEDSImpl_Tool::GetDirFromPath(aUrl);
 768
 769 #ifdef WIN32
 770   aCmd = "dir /B \"" + aStudyTmpDir +"\" > " + aTmpFile;
 771 #else
 772   aCmd ="ls -1 \"" + aStudyTmpDir +"\" > " + aTmpFile;
 773 #endif
 774   system(aCmd.c_str());
 775
 776   // Iterate and move files in the temporary directory
 777   FILE* fp = fopen(aTmpFile.c_str(), "rb");
 778   if (!fp) {
 779     URL( anOldName ); // VSR: restore previous url if operation is failed
 780     return false;
 781   }
 782   char* buffer = new char[2047];
 783   int errors = 0;
 784   while (!feof(fp) && !errors) {
 785     if ((fgets(buffer, 2046, fp)) == NULL) break;
 786     size_t aLen = strlen(buffer);
 787     if (buffer[aLen-1] == '\n') buffer[aLen-1] = char(0);
 788 #ifdef WIN32
 789     aCmd = "move /Y \"" + aStudyTmpDir + std::string(buffer) + "\" \"" + SALOMEDSImpl_Tool::GetDirFromPath(aStudyUrl) +"\"";
 790 #else
 791     aCmd = "mv -f \"" + aStudyTmpDir + std::string(buffer) + "\" \"" + SALOMEDSImpl_Tool::GetDirFromPath(aStudyUrl)+"\"";
 792 #endif
 793     errors = system(aCmd.c_str());
 794   }
 795
 796   delete []buffer;
 797   fclose(fp);
 798
 799   // Perform cleanup
 800 #ifdef WIN32
 801   DeleteFileA(aTmpFile.c_str());
 802 #else
 803   unlink(aTmpFile.c_str());
 804 #endif
 805
 806 #ifdef WIN32
 807   RemoveDirectoryA(aTmpFileDir.c_str());
 808   RemoveDirectoryA(aStudyTmpDir.c_str());
 809 #else
 810   rmdir(aTmpFileDir.c_str());
 811   rmdir(aStudyTmpDir.c_str());
 812 #endif
 813
 814   if ( !errors ) {
 815     // VSR: finally, if all is done without errors, mark study as Saved
 816     IsSaved(true);
 817   }
 818
 819   return !errors;
 820 }
 821
 822 //============================================================================
 823 /*! Function : Impl_SaveObject
 824  *  Purpose  :
 825  */
 826 //============================================================================
 827 bool SALOMEDSImpl_Study::Impl_SaveObject(const SALOMEDSImpl_SObject& SC,
 828                                          HDFgroup *hdf_group_datatype)
 829 {
 830   _errorCode = "";
 831
 832   // Write in group hdf_group_datatype all informations of SObject SC
 833   // Iterative function to parse all SObjects under a SComponent
 834
 835   HDFgroup *hdf_group_sobject = 0;
 836
 837   DF_ChildIterator itchild(SC.GetLabel());
 838   for (; itchild.More(); itchild.Next()) {
 839     // mpv: don't save empty labels
 840     std::vector<DF_Attribute*> attr = itchild.Value().GetAttributes();
 841     if (attr.size() == 0) {  //No attributes on the label
 842       DF_ChildIterator subchild(itchild.Value());
 843       if (!subchild.More()) {
 844         continue;
 845       }
 846       subchild.Init(itchild.Value(), true);
 847       bool anEmpty = true;
 848       for (; subchild.More() && anEmpty; subchild.Next()) {
 849         std::vector<DF_Attribute*> attr2 = subchild.Value().GetAttributes();
 850         if (attr2.size()) {
 851           anEmpty = false;  //There are attributes on the child label
 852           break;
 853         }
 854       }
 855       if (anEmpty) continue;
 856     }
 857
 858     SALOMEDSImpl_SObject SO = SALOMEDSImpl_Study::SObject(itchild.Value());
 859
 860     std::string scoid = SO.GetID();
 861     hdf_group_sobject = new HDFgroup(scoid.c_str(), hdf_group_datatype);
 862     hdf_group_sobject->CreateOnDisk();
 863     SaveAttributes(SO, hdf_group_sobject);
 864     Impl_SaveObject(SO, hdf_group_sobject);
 865     hdf_group_sobject->CloseOnDisk();
 866     hdf_group_sobject =0; // will be deleted by father hdf object destructor
 867   }
 868   return true;
 869 }
 870
 871 //============================================================================
 872 /*! Function : CanCopy
 873  *  Purpose  :
 874  */
 875 //============================================================================
 876 bool SALOMEDSImpl_Study::CanCopy(const SALOMEDSImpl_SObject& theObject,
 877                                  SALOMEDSImpl_Driver* theEngine)
 878 {
 879   _errorCode = "";
 880   SALOMEDSImpl_SComponent aComponent = theObject.GetFatherComponent();
 881   if (!aComponent) return false;
 882   if (aComponent.GetLabel() == theObject.GetLabel()) return false;
 883   std::string IOREngine;
 884   if (!aComponent.ComponentIOR(IOREngine)) return false;
 885   if (theEngine == NULL) return false;
 886   return theEngine->CanCopy(theObject);
 887 }
 888
 889 //============================================================================
 890 /*! Function : CopyLabel
 891  *  Purpose  :
 892  */
 893 //============================================================================
 894 bool SALOMEDSImpl_Study::CopyLabel(SALOMEDSImpl_Driver* theEngine,
 895                                    const int theSourceStartDepth,
 896                                    const DF_Label& theSource,
 897                                    const DF_Label& theDestinationMain)
 898 {
 899   _errorCode = "";
 900
 901   int a;
 902   DF_Label aTargetLabel = theDestinationMain;
 903   DF_Label aAuxTargetLabel = theDestinationMain.Father().FindChild(2);
 904   for(a = theSource.Depth() - theSourceStartDepth; a > 0 ; a--) {
 905     DF_Label aSourceLabel = theSource;
 906     for(int aNbFather = 1; aNbFather < a; aNbFather++) aSourceLabel = aSourceLabel.Father();
 907     aTargetLabel = aTargetLabel.FindChild(aSourceLabel.Tag());
 908     aAuxTargetLabel = aAuxTargetLabel.FindChild(aSourceLabel.Tag());
 909   }
 910   // iterate attributes
 911   std::vector<DF_Attribute*> attrList = theSource.GetAttributes();
 912   for(int i = 0, len = attrList.size(); i<len; i++) {
 913     DF_Attribute* anAttr = attrList[i];
 914     std::string type = SALOMEDSImpl_GenericAttribute::Impl_GetType(anAttr);
 915     if (type.substr(0, 17) == std::string("AttributeTreeNode")) continue; // never copy tree node attribute
 916     if (type == std::string("AttributeTarget")) continue; // and target attribute
 917
 918     if (type == std::string("AttributeReference")) { // reference copied as Comment in aux tree
 919       DF_Label aReferenced = dynamic_cast<SALOMEDSImpl_AttributeReference*>(anAttr)->Get();
 920       std::string anEntry = aReferenced.Entry();
 921       // store the value of name attribute of referenced label
 922       SALOMEDSImpl_AttributeName* aNameAttribute;
 923       if ((aNameAttribute=(SALOMEDSImpl_AttributeName*)aReferenced.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) {
 924         anEntry += " ";
 925         anEntry += aNameAttribute->Value();
 926       }
 927       SALOMEDSImpl_AttributeComment::Set(aAuxTargetLabel, anEntry);
 928       continue;
 929     }
 930
 931     if (type == std::string("AttributeIOR")) { // IOR => ID and TMPFile of Engine
 932       std::string anEntry = theSource.Entry();
 933       SALOMEDSImpl_SObject aSO = FindObjectID(anEntry);
 934       int anObjID;
 935       long aLen;
 936       SALOMEDSImpl_TMPFile* aStream = theEngine->CopyFrom(aSO, anObjID, aLen);
 937       std::string aResStr("");
 938       for(a = 0; a < aLen; a++) {
 939         aResStr += (char)(aStream->Get(a));
 940       }
 941
 942       if(aStream) delete aStream;
 943
 944       SALOMEDSImpl_AttributeInteger::Set(aAuxTargetLabel, anObjID);
 945       SALOMEDSImpl_AttributeName::Set(aAuxTargetLabel, aResStr);
 946       continue;
 947     }
 948     DF_Attribute* aNewAttribute = anAttr->NewEmpty();
 949     aTargetLabel.AddAttribute(aNewAttribute);
 950     anAttr->Paste(aNewAttribute);
 951   }
 952
 953   return true;
 954 }
 955
 956 //============================================================================
 957 /*! Function : Copy
 958  *  Purpose  :
 959  */
 960 //============================================================================
 961 bool SALOMEDSImpl_Study::Copy(const SALOMEDSImpl_SObject& theObject,
 962                                     SALOMEDSImpl_Driver* theEngine)
 963 {
 964   _errorCode = "";
 965
 966   // adoptation for alliances datamodel copy: without IOR attributes !!!
 967   bool aStructureOnly; // copy only SObjects and attributes without component help
 968   aStructureOnly = !theObject.GetLabel().IsAttribute(SALOMEDSImpl_AttributeIOR::GetID());
 969
 970   if (!_doc) {
 971     _errorCode = "Document is null";
 972     return false;
 973   }
 974
 975   //Clear the clipboard
 976   _clipboard->Main().Root().ForgetAllAttributes(true);
 977   _appli->Close(_clipboard);
 978   _clipboard = _appli->NewDocument("SALOME_STUDY");
 979
 980   // set component data type to the name attribute of root label
 981   if (!aStructureOnly) {
 982     SALOMEDSImpl_AttributeComment::Set(_clipboard->Main().Root(),
 983                                        theEngine->ComponentDataType());
 984   }
 985   // iterate all theObject's label children
 986   DF_Label aStartLabel = theObject.GetLabel();
 987   int aSourceStartDepth = aStartLabel.Depth();
 988
 989   // copy main source label
 990   CopyLabel(theEngine, aSourceStartDepth, aStartLabel, _clipboard->Main());
 991
 992   // copy all subchildren of the main source label (all levels)
 993   DF_ChildIterator anIterator(aStartLabel, true);
 994   for(; anIterator.More(); anIterator.Next()) {
 995     CopyLabel(theEngine, aSourceStartDepth, anIterator.Value(), _clipboard->Main());
 996   }
 997
 998   return true;
 999 }
1000
1001 //============================================================================
1002 /*! Function : CanPaste
1003  *  Purpose  :
1004  */
1005 //============================================================================
1006 bool SALOMEDSImpl_Study::CanPaste(const SALOMEDSImpl_SObject& theObject,
1007                                          SALOMEDSImpl_Driver* theEngine)
1008 {
1009   _errorCode = "";
1010
1011   if (!_clipboard) {
1012     _errorCode = "Clipboard is null";
1013     return false;
1014   }
1015
1016   SALOMEDSImpl_AttributeComment* aCompName = NULL;
1017   if (!(aCompName=(SALOMEDSImpl_AttributeComment*)_clipboard->Main().Root().FindAttribute(SALOMEDSImpl_AttributeComment::GetID()))) {
1018     _errorCode = "Clipboard has no component type";
1019     return false;
1020   }
1021   SALOMEDSImpl_AttributeInteger* anObjID;
1022   if (!(anObjID=(SALOMEDSImpl_AttributeInteger*)_clipboard->Main().Father().FindChild(2).FindAttribute(SALOMEDSImpl_AttributeInteger::GetID()))) {
1023     _errorCode = "Clipboard has no object id";
1024     return false;
1025   }
1026   SALOMEDSImpl_SComponent aComponent = theObject.GetFatherComponent();
1027   if (!aComponent) {
1028     _errorCode = "Object doesn't belong to component";
1029     return false;
1030   }
1031
1032   std::string IOREngine;
1033   if (!aComponent.ComponentIOR(IOREngine)) {
1034     _errorCode = "component has no IOR";
1035     return false;
1036   }
1037   return theEngine->CanPaste(aCompName->Value(), anObjID->Value());
1038 }
1039
1040 //============================================================================
1041 /*! Function : PasteLabel
1042  *  Purpose  :
1043  */
1044 //============================================================================
1045 DF_Label SALOMEDSImpl_Study::PasteLabel(SALOMEDSImpl_Driver* theEngine,
1046                                         const DF_Label& theSource,
1047                                         const DF_Label& theDestinationStart,
1048                                         const bool isFirstElement)
1049 {
1050   _errorCode = "";
1051
1052   // get corresponding source, target and auxiliary labels
1053   DF_Label aTargetLabel = theDestinationStart;
1054
1055   DF_Label aAuxSourceLabel = theSource.Root().FindChild(2);
1056   int a;
1057   if (!isFirstElement) {
1058     for(a = theSource.Depth() - 1; a > 0 ; a--) {
1059       DF_Label aSourceLabel = theSource;
1060       for(int aNbFather = 1; aNbFather < a; aNbFather++) aSourceLabel = aSourceLabel.Father();
1061       aTargetLabel = aTargetLabel.FindChild(aSourceLabel.Tag());
1062       aAuxSourceLabel = aAuxSourceLabel.FindChild(aSourceLabel.Tag());
1063     }
1064     SALOMEDSImpl_SObject so = GetSObject(aTargetLabel);
1065     addSO_Notification(so);
1066   }
1067
1068   // check auxiliary label for TMPFile => IOR
1069   SALOMEDSImpl_AttributeName* aNameAttribute = NULL;
1070   if ((aNameAttribute=(SALOMEDSImpl_AttributeName*)aAuxSourceLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) {
1071     SALOMEDSImpl_AttributeInteger* anObjID = (SALOMEDSImpl_AttributeInteger*)aAuxSourceLabel.FindAttribute(SALOMEDSImpl_AttributeInteger::GetID());
1072     SALOMEDSImpl_AttributeComment* aComponentName = (SALOMEDSImpl_AttributeComment*)theSource.Root().FindAttribute(SALOMEDSImpl_AttributeComment::GetID());
1073     std::string aCompName = aComponentName->Value();
1074
1075     if (theEngine->CanPaste(aCompName, anObjID->Value())) {
1076       std::string aTMPStr = aNameAttribute->Value();
1077       int aLen = aTMPStr.size();
1078       unsigned char* aStream = NULL;
1079       if(aLen > 0) {
1080         aStream = new unsigned char[aLen+10];
1081         for(a = 0; a < aLen; a++) {
1082           aStream[a] = aTMPStr[a];
1083         }
1084       }
1085
1086       std::string anEntry = aTargetLabel.Entry();
1087       SALOMEDSImpl_SObject aPastedSO = FindObjectID(anEntry);
1088
1089       if (isFirstElement) {
1090         std::string aDestEntry = theEngine->PasteInto(aStream,
1091                                                       aLen,
1092                                                       anObjID->Value(),
1093                                                       aPastedSO.GetFatherComponent());
1094         aTargetLabel = DF_Label::Label(theDestinationStart, aDestEntry);
1095       } else
1096         theEngine->PasteInto(aStream, aLen, anObjID->Value(), aPastedSO);
1097
1098       if(aStream != NULL) delete []aStream;
1099     }
1100   }
1101
1102   // iterate attributes
1103   std::vector<DF_Attribute*> attrList = theSource.GetAttributes();
1104   for(int i = 0, len = attrList.size(); i<len; i++) {
1105     DF_Attribute* anAttr = attrList[i];
1106     if (aTargetLabel.FindAttribute(anAttr->ID())) {
1107       aTargetLabel.ForgetAttribute(anAttr->ID());
1108     }
1109     DF_Attribute* aNewAttribute = anAttr->NewEmpty();
1110     aTargetLabel.AddAttribute(aNewAttribute);
1111     anAttr->Paste(aNewAttribute);
1112   }
1113
1114   // check auxiliary label for Comment => reference or name attribute of the referenced object
1115   SALOMEDSImpl_AttributeComment* aCommentAttribute = NULL;
1116   if ((aCommentAttribute=(SALOMEDSImpl_AttributeComment*)aAuxSourceLabel.FindAttribute(SALOMEDSImpl_AttributeComment::GetID()))) {
1117     char * anEntry = new char[aCommentAttribute->Value().size() + 1];
1118     strcpy(anEntry, std::string(aCommentAttribute->Value()).c_str());
1119     char* aNameStart = strchr(anEntry, ' ');
1120     if (aNameStart) {
1121       *aNameStart = '\0';
1122       aNameStart++;
1123     }
1124     // copy to the same study, reanimate reference
1125     DF_Label aRefLabel = DF_Label::Label(aTargetLabel, anEntry);
1126     SALOMEDSImpl_AttributeReference::Set(aTargetLabel, aRefLabel);
1127     // target attributes structure support
1128     SALOMEDSImpl_AttributeTarget::Set(aRefLabel)->Add(SALOMEDSImpl_Study::SObject(aTargetLabel));
1129
1130     delete [] anEntry;
1131   }
1132
1133   return aTargetLabel;
1134 }
1135
1136 //============================================================================
1137 /*! Function : Paste
1138  *  Purpose  :
1139  */
1140 //============================================================================
1141 SALOMEDSImpl_SObject SALOMEDSImpl_Study::Paste(const SALOMEDSImpl_SObject& theObject,
1142                                                SALOMEDSImpl_Driver* theEngine)
1143 {
1144   _errorCode = "";
1145
1146   SALOMEDSImpl_SObject so;
1147
1148   // if study is locked, then paste can't be done
1149   if (GetProperties()->IsLocked()) {
1150     _errorCode = "LockProtection";
1151     throw LockProtection("LockProtection");
1152   }
1153
1154   // if there is no component name, then paste only SObjects and attributes: without component help
1155   SALOMEDSImpl_AttributeComment* aComponentName = NULL;
1156   bool aStructureOnly = !(aComponentName=(SALOMEDSImpl_AttributeComment*)_clipboard->Main().Root().FindAttribute(SALOMEDSImpl_AttributeComment::GetID()));
1157
1158   // CAF document of current study usage
1159   if (!_doc) {
1160     _errorCode = "Document is null";
1161     return so;
1162   }
1163
1164   SALOMEDSImpl_SComponent aComponent = theObject.GetFatherComponent();
1165
1166   // fill root inserted SObject
1167   DF_Label aStartLabel;
1168   if (aStructureOnly) {
1169     DF_Label anObjectLabel = DF_Label::Label(_doc->Main(), theObject.GetID());
1170     aStartLabel = PasteLabel(theEngine, _clipboard->Main(), anObjectLabel, false);
1171   } else {
1172     DF_Label aComponentLabel = DF_Label::Label(_doc->Main(), aComponent.GetID());
1173     aStartLabel = PasteLabel(theEngine, _clipboard->Main(), aComponentLabel, true);
1174   }
1175
1176   // paste all sublebels
1177   DF_ChildIterator anIterator(_clipboard->Main(), true);
1178   for(; anIterator.More(); anIterator.Next()) {
1179     PasteLabel(theEngine, anIterator.Value(), aStartLabel, false);
1180   }
1181
1182   return SALOMEDSImpl_Study::SObject(aStartLabel);
1183 }
1184
1185 //============================================================================
1186 /*! Function : GetPersistentReference
1187  *  Purpose  : Get persistent reference of study (idem URL())
1188  */
1189 //============================================================================
1190 std::string SALOMEDSImpl_Study::GetPersistentReference()
1191 {
1192   _errorCode = "";
1193   return URL();
1194 }
1195
1196 //============================================================================
1197 /*! Function : IsEmpty
1198  *  Purpose  : Detect if study is empty
1199  */
1200 //============================================================================
1201 bool SALOMEDSImpl_Study::IsEmpty()
1202 {
1203   _errorCode = "";
1204   if (!_doc) return true;
1205   return _doc->IsEmpty();
1206 }
1207
1208 //============================================================================
1209 /*! Function : FindComponent
1210  *  Purpose  : Find a Component with ComponentDataType = aComponentName
1211  */
1212 //============================================================================
1213 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::FindComponent (const std::string& aComponentName)
1214 {
1215   _errorCode = "";
1216   bool _find = false;
1217   std::string name;
1218   SALOMEDSImpl_SComponentIterator itcomp = NewComponentIterator();
1219   SALOMEDSImpl_SComponent compo;
1220
1221   for (; itcomp.More(); itcomp.Next()) {
1222     SALOMEDSImpl_SComponent SC = itcomp.Value();
1223     name = SC.ComponentDataType();
1224     if(aComponentName == name) {
1225       _find = true;
1226       return SC;
1227     }
1228   }
1229
1230   if(!_find)
1231     {
1232       _errorCode = "No component was found";
1233       return compo;
1234     }
1235   return compo;
1236 }
1237
1238 //============================================================================
1239 /*! Function : FindComponentID
1240  *  Purpose  : Find a Component from it's ID
1241  */
1242 //============================================================================
1243 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::FindComponentID(const std::string& aComponentID)
1244 {
1245   _errorCode = "";
1246
1247   // Iterate on each components defined in the study
1248   // Get the component ID and compare with aComponentID
1249   bool _find = false;
1250   std::string ID;
1251   SALOMEDSImpl_SComponent compo;
1252
1253   SALOMEDSImpl_SComponentIterator itcomp = NewComponentIterator();
1254   for (; itcomp.More(); itcomp.Next()) {
1255     SALOMEDSImpl_SComponent SC = itcomp.Value();
1256     ID = SC.GetID();
1257     if(aComponentID == ID)
1258       {
1259         // ComponentID found
1260         _find = true;
1261         compo = SC;
1262       }
1263   }
1264   if(!_find)
1265     {
1266       _errorCode = "No component was found";
1267       compo = compo;
1268     }
1269
1270   return compo;
1271 }
1272
1273 //============================================================================
1274 /*! Function : FindObject
1275  *  Purpose  : Find an Object with SALOMEDSImpl_Name = anObjectName
1276  */
1277 //============================================================================
1278 SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObject(const std::string& anObjectName)
1279 {
1280   _errorCode = "";
1281
1282   // Iterate to all components defined in the study
1283   // After testing the component name, iterate in all objects defined under
1284   // components (function _FindObject)
1285   bool _find = false;
1286   SALOMEDSImpl_SObject RefSO;
1287
1288   SALOMEDSImpl_SComponentIterator it = NewComponentIterator();
1289   for (; it.More();it.Next()){
1290     if(!_find)
1291       {
1292         SALOMEDSImpl_SComponent SC = it.Value();
1293         if (SC.GetName() == anObjectName)
1294         {
1295             _find = true;
1296             RefSO = SC;
1297
1298         }
1299         if (!_find) RefSO =  _FindObject(SC, anObjectName, _find);
1300       }
1301   }
1302   if(!RefSO) _errorCode = "No object was found";
1303   return RefSO;
1304 }
1305
1306 //============================================================================
1307 /*! Function : FindObjectID
1308  *  Purpose  : Find an Object with ID = anObjectID
1309  */
1310 //============================================================================
1311 SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectID(const std::string& anObjectID)
1312 {
1313   _errorCode = "";
1314   SALOMEDSImpl_SObject so;
1315
1316   // Convert aSO->GetID in DF_Label.
1317   DF_Label Lab = DF_Label::Label(_doc->Main(), anObjectID, false);
1318
1319   if (Lab.IsNull()) {
1320     _errorCode = "No label was found by ID";
1321     return so;
1322   }
1323   return GetSObject(Lab);
1324
1325 }
1326
1327 //============================================================================
1328 /*! Function : CreateObjectID
1329  *  Purpose  : Creates an Object with ID = anObjectID
1330  */
1331 //============================================================================
1332 SALOMEDSImpl_SObject SALOMEDSImpl_Study::CreateObjectID(const std::string& anObjectID)
1333 {
1334   _errorCode = "";
1335   SALOMEDSImpl_SObject so;
1336
1337   // Convert aSO->GetID in DF_Label.
1338   DF_Label Lab = DF_Label::Label(_doc->Main(), anObjectID, true);
1339
1340   if (Lab.IsNull()) {
1341     _errorCode = "Can not create a label";
1342     return so;
1343   }
1344   return GetSObject(Lab);
1345
1346 }
1347
1348 //============================================================================
1349 /*! Function : FindObjectByName
1350  *  Purpose  : Find Objects with SALOMEDSImpl_Name = anObjectName in a Component
1351  *           : with ComponentDataType = aComponentName
1352  */
1353 //============================================================================
1354 std::vector<SALOMEDSImpl_SObject> SALOMEDSImpl_Study::FindObjectByName(const std::string& anObjectName,
1355                                                                        const std::string& aComponentName)
1356 {
1357   _errorCode = "";
1358
1359   std::vector<SALOMEDSImpl_SObject> listSO;
1360
1361   SALOMEDSImpl_SComponent compo = FindComponent(aComponentName) ;
1362   if ( !compo ) {
1363     _errorCode = "Can not find the component";
1364     return listSO;
1365   }
1366
1367   // Iterate on each object and subobject of the component
1368   // If objectName is found add it to the list of SObjects
1369   std::string childName ;
1370
1371   std::string compoId = compo.GetID();
1372   SALOMEDSImpl_ChildIterator it = NewChildIterator(compo);
1373   for ( ; it.More(); it.Next() ) {
1374
1375     SALOMEDSImpl_SObject CSO = it.Value();
1376     if ( CSO.GetName() == anObjectName ) {
1377         /* add to list */
1378         listSO.push_back(CSO) ;
1379     }
1380
1381     /* looks also for eventual children */
1382     bool found = false ;
1383     CSO = _FindObject( CSO, anObjectName, found ) ;
1384     if( found) {
1385       listSO.push_back(CSO) ;
1386     }
1387   }
1388
1389   return listSO;
1390 }
1391
1392
1393
1394 //============================================================================
1395 /*! Function : FindObjectIOR
1396  *  Purpose  : Find an Object with IOR = anObjectIOR
1397  */
1398 //============================================================================
1399 SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectIOR(const std::string& anObjectIOR)
1400 {
1401   _errorCode = "";
1402
1403   SALOMEDSImpl_SObject aResult ;
1404
1405   // searching in the datamap for optimization
1406   std::map<std::string, DF_Label>::iterator it=myIORLabels.find(anObjectIOR);
1407   if (it != myIORLabels.end()) {
1408     aResult = GetSObject(it->second);
1409     // 11 oct 2002: forbidden attributes must be checked here
1410     if (!aResult.GetLabel().IsAttribute(SALOMEDSImpl_AttributeIOR::GetID())) {
1411       myIORLabels.erase(anObjectIOR);
1412       aResult = SALOMEDSImpl_SObject();
1413     }
1414   }
1415
1416   if(!aResult) _errorCode = "No object was found";
1417   return aResult;
1418 }
1419
1420 //============================================================================
1421 /*! Function : FindObjectByPath
1422  *  Purpose  : Find an Object by its path = thePath
1423  */
1424 //============================================================================
1425 SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectByPath(const std::string& thePath)
1426 {
1427   _errorCode = "";
1428
1429   std::string aPath(thePath), aToken;
1430   SALOMEDSImpl_SObject aSO;
1431   int aLength = aPath.size();
1432   bool isRelative = false;
1433
1434   if(aLength == 0) {  //Empty path - return the current context
1435     return aSO;
1436   }
1437
1438   if(aPath[0] != '/')  //Relative path
1439     isRelative = true;
1440
1441   DF_ChildIterator anIterator;
1442   DF_Label aLabel;
1443   SALOMEDSImpl_AttributeName* anAttr;
1444
1445   if(isRelative) {
1446     return aSO;
1447   }
1448   else {
1449     if(aPath.size() == 1 && aPath[0] == '/') {    //Root
1450       return GetSObject(_doc->Main());
1451     }
1452     anIterator.Init(_doc->Main(), false);
1453   }
1454
1455   std::vector<std::string> vs = SALOMEDSImpl_Tool::splitString(aPath, '/');
1456   for(int i = 0, len = vs.size(); i<len; i++) {
1457
1458     aToken = vs[i];
1459     if(aToken.size() == 0) break;
1460
1461     for ( ; anIterator.More(); anIterator.Next() ) {
1462       aLabel = anIterator.Value();
1463       if((anAttr=(SALOMEDSImpl_AttributeName*)aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) {
1464         if(anAttr->Value() == aToken) {
1465           if(i == (len-1)) {  //The searched label is found (no part of the path is left)
1466               return GetSObject(aLabel);
1467           }
1468
1469           anIterator.Init(aLabel, false);
1470           break;
1471         }
1472       }
1473     }
1474
1475   }
1476
1477   if(!aSO) _errorCode = "No object was found";
1478   return aSO;
1479 }
1480
1481 //============================================================================
1482 /*! Function : GetObjectPath
1483  *  Purpose  :
1484  */
1485 //============================================================================
1486 std::string SALOMEDSImpl_Study::GetObjectPath(const SALOMEDSImpl_SObject& theObject)
1487 {
1488   _errorCode = "";
1489
1490   std::string aPath("");
1491   if(!theObject) {
1492     _errorCode = "Null object";
1493     return aPath;
1494   }
1495
1496   std::string aName = theObject.GetName();
1497   if(!aName.empty() && aName != "" ) {
1498     std::string aValue("/");
1499     aValue+=aName;
1500     aValue += aPath;
1501     aPath = aValue;
1502     SALOMEDSImpl_SObject aFather = theObject.GetFather();
1503     if(aFather) {
1504        aName = aFather.GetName();
1505        if(!aName.empty() && aName != "") {
1506            aValue = GetObjectPath(aFather);
1507           aPath = aValue + aPath;
1508        }
1509     }
1510   }
1511
1512   return aPath;
1513 }
1514
1515
1516 //============================================================================
1517 /*! Function : GetObjectPathByIOR
1518  *  Purpose  :
1519  */
1520 //============================================================================
1521 std::string SALOMEDSImpl_Study::GetObjectPathByIOR(const std::string& theIOR)
1522 {
1523   _errorCode = "";
1524
1525   std::string aPath;
1526   SALOMEDSImpl_SObject so = FindObjectIOR(theIOR);
1527   if(!so) {
1528     _errorCode = "No SObject was found by IOR";
1529     return aPath;
1530   }
1531
1532   return GetObjectPath(so);
1533 }
1534
1535 //============================================================================
1536 /*! Function : NewChildIterator
1537  *  Purpose  : Create a ChildIterator from an SObject
1538  */
1539 //============================================================================
1540 SALOMEDSImpl_ChildIterator SALOMEDSImpl_Study::NewChildIterator(const SALOMEDSImpl_SObject& aSO)
1541 {
1542   _errorCode = "";
1543   return SALOMEDSImpl_ChildIterator(aSO);
1544 }
1545
1546
1547 //============================================================================
1548 /*! Function : NewComponentIterator
1549  *  Purpose  : Create a SComponentIterator
1550  */
1551 //============================================================================
1552 SALOMEDSImpl_SComponentIterator SALOMEDSImpl_Study::NewComponentIterator()
1553 {
1554   _errorCode = "";
1555   return SALOMEDSImpl_SComponentIterator(_doc);
1556 }
1557
1558
1559 //============================================================================
1560 /*! Function : NewBuilder
1561  *  Purpose  : Create a StudyBuilder
1562  */
1563 //============================================================================
1564 SALOMEDSImpl_StudyBuilder* SALOMEDSImpl_Study::NewBuilder()
1565 {
1566   _errorCode = "";
1567   if(_autoFill) {
1568     _builder->SetOnAddSObject(_cb);
1569     _builder->SetOnRemoveSObject(_cb);
1570   }
1571   return _builder;
1572
1573 }
1574
1575 //============================================================================
1576 /*! Function : Name
1577  *  Purpose  : get study name
1578  */
1579 //============================================================================
1580 std::string SALOMEDSImpl_Study::Name()
1581 {
1582   _errorCode = "";
1583   return Kernel_Utils::GetBaseName( _name, false );
1584 }
1585
1586 //============================================================================
1587 /*! Function : IsSaved
1588  *  Purpose  : get if study has been saved
1589  */
1590 //============================================================================
1591 bool SALOMEDSImpl_Study::IsSaved()
1592 {
1593   _errorCode = "";
1594   return _Saved;
1595 }
1596
1597 //============================================================================
1598 /*! Function : IsSaved
1599  *  Purpose  : set if study has been saved
1600  */
1601 //============================================================================
1602 void SALOMEDSImpl_Study::IsSaved(bool save)
1603 {
1604   _errorCode = "";
1605   _Saved = save;
1606   if(save) _doc->SetModified(false);
1607 }
1608
1609 //============================================================================
1610 /*! Function : IsModified
1611  *  Purpose  : Detect if a Study has been modified since it has been saved
1612  */
1613 //============================================================================
1614 bool SALOMEDSImpl_Study::IsModified()
1615 {
1616   _errorCode = "";
1617
1618   // True if is modified
1619   if (_doc && _doc->IsModified()) return true;
1620
1621   return false;
1622 }
1623
1624 //============================================================================
1625 /*! Function : URL
1626  *  Purpose  : get URL of the study (persistent reference of the study)
1627  */
1628 //============================================================================
1629 std::string SALOMEDSImpl_Study::URL()
1630 {
1631   _errorCode = "";
1632   return _URL;
1633 }
1634
1635 //============================================================================
1636 /*! Function : URL
1637  *  Purpose  : set URL of the study (persistent reference of the study)
1638  */
1639 //============================================================================
1640 void SALOMEDSImpl_Study::URL(const std::string& url)
1641 {
1642   _errorCode = "";
1643   _URL = url;
1644   _name = url;
1645
1646   /*jfa: Now name of SALOMEDS study will correspond to name of SalomeApp study
1647   std::string tmp(_URL);
1648
1649   char *aName = (char*)tmp.ToCString();
1650   char *adr = strtok(aName, "/");
1651   while (adr)
1652     {
1653       aName = adr;
1654       adr = strtok(NULL, "/");
1655     }
1656   Name(aName);*/
1657 }
1658
1659
1660 //============================================================================
1661 /*! Function : _FindObject
1662  *  Purpose  : Find an Object with SALOMEDSImpl_Name = anObjectName
1663  */
1664 //============================================================================
1665 SALOMEDSImpl_SObject SALOMEDSImpl_Study::_FindObject(const SALOMEDSImpl_SObject& SO,
1666                                                      const std::string& theObjectName,
1667                                                      bool& _find)
1668 {
1669   SALOMEDSImpl_SObject RefSO;
1670   if(!SO) return RefSO;
1671
1672   // Iterate on each objects and subobjects of the component
1673   // If objectName find, stop the loop and get the object reference
1674   SALOMEDSImpl_AttributeName* anAttr;
1675
1676   std::string soid = SO.GetID();
1677   DF_ChildIterator it(SO.GetLabel());
1678   for (; it.More(); it.Next()){
1679     if(!_find)
1680       {
1681         if ((anAttr=(SALOMEDSImpl_AttributeName*)it.Value().FindAttribute(SALOMEDSImpl_AttributeName::GetID())))
1682         {
1683           std::string Val(anAttr->Value());
1684           if (Val == theObjectName)
1685             {
1686               RefSO = GetSObject(it.Value());
1687               _find = true;
1688             }
1689         }
1690         if (!_find) RefSO = _FindObject(GetSObject(it.Value()), theObjectName, _find);
1691       }
1692   }
1693   return RefSO;
1694 }
1695
1696 //============================================================================
1697 /*! Function : _FindObjectIOR
1698  *  Purpose  : Find an Object with SALOMEDSImpl_IOR = anObjectIOR
1699  */
1700 //============================================================================
1701 SALOMEDSImpl_SObject
1702 SALOMEDSImpl_Study::_FindObjectIOR(const SALOMEDSImpl_SObject& SO,
1703                                    const std::string& theObjectIOR,
1704                                    bool& _find)
1705 {
1706   SALOMEDSImpl_SObject RefSO, aSO;
1707   if(!SO) return RefSO;
1708
1709   // Iterate on each objects and subobjects of the component
1710   // If objectName find, stop the loop and get the object reference
1711   SALOMEDSImpl_AttributeIOR* anAttr;
1712
1713   DF_ChildIterator it(SO.GetLabel());
1714   for (; it.More();it.Next()){
1715     if(!_find)
1716       {
1717         if ((anAttr=(SALOMEDSImpl_AttributeIOR*)it.Value().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID())))
1718         {
1719           std::string Val(anAttr->Value());
1720           if (Val == theObjectIOR)
1721             {
1722               RefSO = GetSObject(it.Value());
1723               _find = true;
1724             }
1725         }
1726         aSO = GetSObject(it.Value());
1727         if (!_find) RefSO =  _FindObjectIOR(aSO, theObjectIOR, _find);
1728       }
1729   }
1730   return RefSO;
1731 }
1732
1733 //============================================================================
1734 /*! Function : _GetNoteBookAccessor
1735  *  Purpose  : Find an Object with SALOMEDSImpl_IOR = anObjectIOR
1736  */
1737 //============================================================================
1738 std::string SALOMEDSImpl_Study::_GetNoteBookAccessor(){
1739   return std::string("notebook");
1740 }
1741
1742 //============================================================================
1743 /*! Function : _GetStudyVariablesScript
1744  *  Purpose  :
1745  */
1746 //============================================================================
1747 std::string SALOMEDSImpl_Study::_GetStudyVariablesScript()
1748 {
1749   std::string dump("");
1750
1751   if(myNoteBookVars.empty())
1752     return dump;
1753
1754   Kernel_Utils::Localizer loc;
1755
1756   dump += "####################################################\n";
1757   dump += "##       Begin of NoteBook variables section      ##\n";
1758   dump += "####################################################\n";
1759
1760   std::string set_method = _GetNoteBookAccessor()+".set(";
1761   std::string varName;
1762   std::string varValue;
1763   for(int i = 0 ; i < myNoteBookVars.size();i++ ) {
1764     varName = myNoteBookVars[i]->Name();
1765     varValue = myNoteBookVars[i]->SaveToScript();
1766     dump+=set_method+"\""+varName+"\", "+varValue+")\n";
1767   }
1768
1769   dump += "####################################################\n";
1770   dump += "##        End of NoteBook variables section       ##\n";
1771   dump += "####################################################\n";
1772
1773   return dump;
1774 }
1775
1776 //============================================================================
1777 /*! Function : _GetNoteBookAccess
1778  *  Purpose  :
1779  */
1780 //============================================================================
1781 std::string SALOMEDSImpl_Study::_GetNoteBookAccess()
1782 {
1783   return std::string("import salome_notebook\n");
1784 }
1785
1786 bool SALOMEDSImpl_Study::IsLocked()
1787 {
1788   _errorCode = "";
1789   return GetProperties()->IsLocked();
1790 }
1791
1792 void SALOMEDSImpl_Study::UpdateIORLabelMap(const std::string& anIOR,const std::string& anEntry)
1793 {
1794   _errorCode = "";
1795   DF_Label aLabel = DF_Label::Label(_doc->Main(), anEntry, true);
1796   std::map<std::string, DF_Label>::iterator it=myIORLabels.find(anIOR);
1797   if (it != myIORLabels.end()) myIORLabels.erase(it);
1798   myIORLabels[anIOR] = aLabel;
1799 }
1800
1801 void SALOMEDSImpl_Study::DeleteIORLabelMapItem(const std::string& anIOR)
1802 {
1803   std::map<std::string, DF_Label>::iterator it=myIORLabels.find(anIOR);
1804   if (it != myIORLabels.end())
1805     {
1806       //remove the ior entry and decref the genericobj (if it's one)
1807       myIORLabels.erase(it);
1808     }
1809 }
1810
1811 SALOMEDSImpl_Study* SALOMEDSImpl_Study::GetStudyImpl(const DF_Label& theLabel)
1812 {
1813   SALOMEDSImpl_StudyHandle* Att;
1814   if ((Att=(SALOMEDSImpl_StudyHandle*)theLabel.Root().FindAttribute(SALOMEDSImpl_StudyHandle::GetID()))) {
1815     return Att->Get();
1816   }
1817   return NULL;
1818 }
1819
1820 SALOMEDSImpl_SObject SALOMEDSImpl_Study::SObject(const DF_Label& theLabel)
1821 {
1822   return GetStudyImpl(theLabel)->GetSObject(theLabel);
1823 }
1824
1825 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::SComponent(const DF_Label& theLabel)
1826 {
1827   return GetStudyImpl(theLabel)->GetSComponent(theLabel);
1828 }
1829
1830
1831 void SALOMEDSImpl_Study::IORUpdated(const SALOMEDSImpl_AttributeIOR* theAttribute)
1832 {
1833   std::string aString = theAttribute->Label().Entry();
1834   GetStudyImpl(theAttribute->Label())->UpdateIORLabelMap(theAttribute->Value(), aString);
1835 }
1836
1837 std::vector<SALOMEDSImpl_SObject> SALOMEDSImpl_Study::FindDependances(const SALOMEDSImpl_SObject& anObject)
1838 {
1839   _errorCode = "";
1840   std::vector<SALOMEDSImpl_SObject> aSeq;
1841
1842   SALOMEDSImpl_AttributeTarget* aTarget;
1843   if ((aTarget=(SALOMEDSImpl_AttributeTarget*)anObject.GetLabel().FindAttribute(SALOMEDSImpl_AttributeTarget::GetID()))) {
1844     return aTarget->Get();
1845   }
1846
1847   return aSeq;
1848 }
1849
1850
1851 SALOMEDSImpl_AttributeStudyProperties* SALOMEDSImpl_Study::GetProperties()
1852 {
1853   _errorCode = "";
1854   return SALOMEDSImpl_AttributeStudyProperties::Set(_doc->Main());
1855 }
1856
1857 std::string SALOMEDSImpl_Study::GetLastModificationDate()
1858 {
1859   _errorCode = "";
1860   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
1861
1862   std::vector<std::string> aNames;
1863   std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
1864   aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
1865
1866   int aLastIndex = aNames.size()-1;
1867   char aResult[20];
1868   sprintf(aResult, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d",
1869           (int)(aDays[aLastIndex]),(int)(aMonths[aLastIndex]), (int)(aYears[aLastIndex]),
1870           (int)(aHours[aLastIndex]), (int)(aMinutes[aLastIndex]));
1871   std::string aResStr (aResult);
1872   return aResStr;
1873 }
1874
1875 std::vector<std::string> SALOMEDSImpl_Study::GetModificationsDate()
1876 {
1877   _errorCode = "";
1878   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
1879
1880   std::vector<std::string> aNames;
1881   std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
1882   aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
1883
1884   int anIndex, aLength = aNames.size();
1885   std::vector<std::string> aDates;
1886
1887   for (anIndex = 1; anIndex < aLength; anIndex++) {
1888     char aDate[20];
1889     sprintf(aDate, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d",
1890             (int)(aDays[anIndex]), (int)(aMonths[anIndex]), (int)(aYears[anIndex]),
1891             (int)(aHours[anIndex]), (int)(aMinutes[anIndex]));
1892     aDates.push_back(aDate);
1893   }
1894   return aDates;
1895 }
1896
1897
1898
1899 //============================================================================
1900 /*! Function : GetUseCaseBuilder
1901  *  Purpose  : Returns a UseCase builder
1902  */
1903 //============================================================================
1904 SALOMEDSImpl_UseCaseBuilder* SALOMEDSImpl_Study::GetUseCaseBuilder()
1905 {
1906   _errorCode = "";
1907   return _useCaseBuilder;
1908 }
1909
1910 //============================================================================
1911 /*! Function : GetSComponent
1912  *  Purpose  :
1913  */
1914 //============================================================================
1915 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const std::string& theEntry)
1916 {
1917   SALOMEDSImpl_SComponent aSCO;
1918   if(_mapOfSCO.find(theEntry) != _mapOfSCO.end())
1919     aSCO = _mapOfSCO[theEntry];
1920   else {
1921     DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry);
1922     aSCO = SALOMEDSImpl_SComponent(aLabel);
1923     _mapOfSCO[theEntry] = aSCO;
1924   }
1925
1926   return aSCO;
1927 }
1928
1929 //============================================================================
1930 /*! Function : GetSComponent
1931  *  Purpose  :
1932  */
1933 //============================================================================
1934 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const DF_Label& theLabel)
1935 {
1936   return SALOMEDSImpl_SComponent(theLabel);
1937 }
1938
1939 //============================================================================
1940 /*! Function : GetSObject
1941  *  Purpose  :
1942  */
1943 //============================================================================
1944 SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const std::string& theEntry)
1945 {
1946   SALOMEDSImpl_SObject aSO;
1947   std::map<std::string, SALOMEDSImpl_SObject>::iterator it=_mapOfSO.find(theEntry);
1948   if(it != _mapOfSO.end())
1949     aSO = it->second;
1950   else {
1951     DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry);
1952     aSO = SALOMEDSImpl_SObject(aLabel);
1953     _mapOfSO[theEntry] = aSO;
1954   }
1955
1956   return aSO;
1957 }
1958
1959 //============================================================================
1960 /*! Function : GetSObject
1961  *  Purpose  :
1962  */
1963 //============================================================================
1964 SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const DF_Label& theLabel)
1965 {
1966   return SALOMEDSImpl_SObject(theLabel);
1967 }
1968
1969 //============================================================================
1970 /*! Function : GetAttribute
1971  *  Purpose  :
1972  */
1973 //============================================================================
1974 DF_Attribute* SALOMEDSImpl_Study::GetAttribute(const std::string& theEntry,
1975                                                const std::string& theType)
1976 {
1977   SALOMEDSImpl_SObject aSO = GetSObject(theEntry);
1978   DF_Attribute* anAttr;
1979   aSO.FindAttribute(anAttr, theType);
1980   return anAttr;
1981 }
1982
1983 //! number of spaces for indentation in Python dump files (to replace \t symbols)
1984 static const int indent_size = 2;
1985
1986 static std::string replace_tabs( const std::string& in )
1987 {
1988   std::string out = in;
1989 #ifdef WITHOUT_TABS
1990   size_t pos = out.find( '\t' );
1991   while ( pos != std::string::npos ) {
1992     out.replace( pos, 1, indent_size, ' ' );
1993     pos = out.find( '\t' );
1994   }
1995 #endif
1996   return out;
1997 }
1998
1999 static std::string GetComponentHeader(const char* theComponentName)
2000 {
2001   std::stringstream txt;
2002   txt << "###" << std::endl;
2003   txt << "### " << theComponentName << " component" << std::endl;
2004   txt << "###" << std::endl;
2005   return txt.str();
2006 }
2007
2008 //============================================================================
2009 /*! Function : DumpStudy
2010  *  Purpose  :
2011  */
2012 //============================================================================
2013 bool SALOMEDSImpl_Study::DumpStudy(const std::string& thePath,
2014                                    const std::string& theBaseName,
2015                                    bool isPublished,
2016                                    bool isMultiFile,
2017                                    SALOMEDSImpl_DriverFactory* theFactory)
2018 {
2019   _errorCode = "";
2020
2021   if(theFactory == NULL) {
2022     _errorCode = "Null factory for creation of Engines";
2023     return false;
2024   }
2025
2026   std::vector<std::string> aSeq;
2027   std::string aCompType, aFactoryType;
2028
2029   //Build a list of all components in the Study
2030   SALOMEDSImpl_SComponentIterator itcomponent = NewComponentIterator();
2031
2032   for (; itcomponent.More(); itcomponent.Next()) {
2033     SALOMEDSImpl_SComponent sco = itcomponent.Value();
2034     aCompType = sco.ComponentDataType();
2035    if (aCompType == "GEOM")
2036       aSeq.insert(aSeq.begin(), aCompType);
2037     else
2038       aSeq.push_back(aCompType);
2039   }
2040   // re-arrange modules in the sequence, if specific order is given via SALOME_MODULES_ORDER environment variable.
2041   if ( getenv("SALOME_MODULES_ORDER") != 0 ) {
2042     std::string order = getenv("SALOME_MODULES_ORDER");
2043     std::vector<std::string> mlist;
2044     while ( !order.empty() ) {
2045       size_t idx = order.find( "," );
2046       std::string m = order.substr(0, idx);
2047       order = order.substr( ( idx == std::string::npos ) ? order.size() : idx+1 );
2048       if ( m.empty() || std::find( mlist.begin(), mlist.end(), m ) != mlist.end() ) continue;
2049       mlist.push_back( m );
2050     }
2051
2052     for ( std::vector<std::string>::reverse_iterator mit = mlist.rbegin(); mit != mlist.rend(); ++mit ) {
2053       std::vector<std::string>::iterator it = std::find( aSeq.begin(), aSeq.end(), *mit );
2054       if ( it != aSeq.end() ) {
2055         aSeq.erase( it );
2056         aSeq.insert( aSeq.begin(), *mit );
2057       }
2058     }
2059   }
2060
2061 #ifdef WIN32
2062   std::string aFileName =
2063     thePath + std::string("\\") + theBaseName + std::string(".py");
2064 #else
2065   std::string aFileName =
2066     thePath + std::string("/")  + theBaseName + std::string(".py");
2067 #endif
2068
2069   //Create a file that will contain a main Study script
2070   std::fstream fp;
2071   fp.open(aFileName.c_str(), std::ios::out);
2072
2073 #ifdef WIN32
2074   bool isOpened = fp.is_open();
2075 #else
2076   bool isOpened = fp.rdbuf()->is_open();
2077 #endif
2078
2079   if(!isOpened) {
2080     _errorCode = std::string("Can't create a file ")+aFileName;
2081     return false;
2082   }
2083
2084   std::stringstream sfp;
2085
2086   std::string aBatchModeScript = "salome";
2087
2088   //Output to the main Study script required Python modules import,
2089   //set sys.path and add a creation of the study.
2090
2091   // dump header
2092   sfp << GetDumpStudyComment() << std::endl;
2093
2094   // global imports
2095   sfp << "import sys" << std::endl;
2096   sfp << "import " << aBatchModeScript << std::endl << std::endl;
2097
2098   // initialization function
2099   sfp << aBatchModeScript << ".salome_init()" << std::endl;
2100
2101   // notebook initialization
2102   sfp << _GetNoteBookAccess() << std::endl;
2103
2104   // extend sys.path with the directory where the script is being dumped to
2105   sfp << "sys.path.insert( 0, r\'" << thePath << "\')" << std::endl << std::endl;
2106
2107   // dump NoteBook variables
2108   sfp << _GetStudyVariablesScript();
2109
2110   // dump visual parameters if necessary
2111   bool isDumpVisuals = SALOMEDSImpl_IParameters::isDumpPython(this);
2112   int lastSavePoint = -1;
2113   if(isDumpVisuals) {
2114     lastSavePoint = SALOMEDSImpl_IParameters::getLastSavePoint(this);
2115     if(lastSavePoint > 0) {
2116       sfp << SALOMEDSImpl_IParameters::getStudyScript(this, lastSavePoint) << std::endl << std::endl;
2117     }
2118   }
2119
2120   std::vector<std::string> aSeqOfFileNames;
2121
2122   // dump all components and create the components specific scripts
2123   bool isOk = true;
2124   int aLength = aSeq.size();
2125   for(int i = 1; i <= aLength; i++) {
2126
2127     aCompType = aSeq[i-1];
2128     SALOMEDSImpl_SComponent sco = FindComponent(aCompType);
2129     SALOMEDSImpl_Driver* aDriver = NULL;
2130     // if there is an associated Engine call its method for saving
2131     std::string IOREngine;
2132     try {
2133       if (!sco.ComponentIOR(IOREngine)) {
2134         if (!aCompType.empty()) {
2135
2136           aDriver = theFactory->GetDriverByType(aCompType);
2137
2138           if (aDriver != NULL) {
2139             SALOMEDSImpl_StudyBuilder* SB = NewBuilder();
2140             if(!SB->LoadWith(sco, aDriver)) {
2141               _errorCode = SB->GetErrorCode();
2142               return false;
2143             }
2144           }
2145           else continue;
2146         }
2147       }
2148       else {
2149         aDriver = theFactory->GetDriverByIOR(IOREngine);
2150       }
2151     } catch(...) {
2152       _errorCode = "Can not restore information to dump it";
2153       return false;
2154     }
2155
2156     if(aDriver == NULL) continue;
2157
2158     bool isValidScript;
2159     long aStreamLength  = 0;
2160     SALOMEDSImpl_TMPFile* aStream = aDriver->DumpPython(isPublished, isMultiFile, isValidScript, aStreamLength);
2161     if ( !isValidScript )
2162       isOk = false;
2163
2164     std::stringstream sfp2;
2165
2166     //Output the Python script generated by the component in the newly created file.
2167     if ( isMultiFile )
2168       sfp2 << GetDumpStudyComment( aCompType.c_str() ) << std::endl;
2169     else
2170       sfp2 << GetComponentHeader( aCompType.c_str() ) << std::endl;
2171     sfp2 << aStream->Data();
2172
2173     if ( isMultiFile ) {
2174       //Create a file that will contain the component specific script
2175       std::fstream fp2;
2176 #ifdef WIN32
2177       aFileName=thePath+std::string("\\");
2178 #else
2179       aFileName=thePath+std::string("/");
2180 #endif
2181       std::string aScriptName;
2182       aScriptName += theBaseName;
2183       aScriptName += "_";
2184       aScriptName += aCompType;
2185
2186       aFileName += aScriptName+ std::string(".py");
2187       aSeqOfFileNames.push_back(aFileName);
2188
2189       fp2.open(aFileName.c_str(), std::ios::out);
2190
2191 #ifdef WIN32
2192       isOpened = fp2.is_open();
2193 #else
2194       isOpened = fp2.rdbuf()->is_open();
2195 #endif
2196
2197       if(!isOpened) {
2198         _errorCode = std::string("Can't create a file ")+aFileName;
2199         SALOMEDSImpl_Tool::RemoveTemporaryFiles(thePath, aSeqOfFileNames, false);
2200         return false;
2201       }
2202
2203       // replace '\t' symbols
2204       fp2 << replace_tabs( sfp2.str() );
2205
2206       fp2.close();
2207
2208       //Add to the main script a call to RebuildData of the generated by the component the Python script
2209       sfp << "import " << aScriptName << std::endl;
2210       sfp << aScriptName << ".RebuildData()" << std::endl;
2211     }
2212     else
2213       sfp << sfp2.str();
2214
2215     if(aStream) delete aStream;
2216   }
2217
2218   sfp << std::endl;
2219   sfp << "if salome.sg.hasDesktop():" << std::endl;
2220   sfp << "\tsalome.sg.updateObjBrowser()" << std::endl;
2221
2222   if(isDumpVisuals) { //Output the call to Session's method restoreVisualState
2223     sfp << "\tiparameters.getSession().restoreVisualState(1)" << std::endl;
2224   }
2225
2226   // replace '\t' symbols
2227   fp << replace_tabs( sfp.str() );
2228
2229   fp.close();
2230
2231   return isOk;
2232 }
2233
2234 //=======================================================================
2235 //function : GetDumpStudyComment
2236 //purpose  : return a header comment for a DumpStudy script
2237 //=======================================================================
2238
2239 std::string SALOMEDSImpl_Study::GetDumpStudyComment(const char* theComponentName)
2240 {
2241   std::stringstream txt;
2242   txt << "# -*- coding: utf-8 -*-" << std::endl << std::endl;
2243   txt << "###" << std::endl;
2244   txt << "### This file is generated automatically by SALOME v"
2245       << KERNEL_VERSION_STR
2246       << " with dump python functionality";
2247   if ( theComponentName )
2248     txt << " (" << theComponentName << " component)";
2249   txt << std::endl;
2250   txt << "###" << std::endl;
2251   return txt.str();
2252 }
2253
2254 void dumpSO(const SALOMEDSImpl_SObject& theSO,
2255             std::fstream& fp,
2256             const std::string& Tab,
2257             SALOMEDSImpl_Study* theStudy);
2258
2259 //============================================================================
2260 /*! Function : dump
2261  *  Purpose  :
2262  */
2263 //============================================================================
2264 void SALOMEDSImpl_Study::dump(const std::string& theFileName)
2265 {
2266   //Create a file that will contain a main Study script
2267   std::fstream fp;
2268   fp.open(theFileName.c_str(), std::ios::out);
2269
2270 #ifdef WIN32
2271   bool isOpened = fp.is_open();
2272 #else
2273   bool isOpened = fp.rdbuf()->is_open();
2274 #endif
2275
2276   if(!isOpened) {
2277     _errorCode = std::string("Can't create a file ")+theFileName;
2278     std::cout << "### SALOMEDSImpl_Study::dump Error: " << _errorCode << std::endl;
2279     return;
2280   }
2281
2282   SALOMEDSImpl_SObject aSO = FindObjectID("0:1");
2283   fp << "0:1" << std::endl;
2284   SALOMEDSImpl_ChildIterator Itr = NewChildIterator(aSO);
2285   std::string aTab("   ");
2286   for(; Itr.More(); Itr.Next()) {
2287     dumpSO(Itr.Value(), fp, aTab, this);
2288   }
2289
2290   fp.close();
2291 }
2292
2293
2294 void dumpSO(const SALOMEDSImpl_SObject& theSO,
2295             std::fstream& fp,
2296             const std::string& Tab,
2297             SALOMEDSImpl_Study* theStudy)
2298 {
2299   std::string aTab(Tab), anID(theSO.GetID());
2300   fp << aTab << anID << std::endl;
2301   std::vector<DF_Attribute*> attribs = theSO.GetLabel().GetAttributes();
2302   for(int i = 0; i<attribs.size(); i++) {
2303     SALOMEDSImpl_GenericAttribute* anAttr = dynamic_cast<SALOMEDSImpl_GenericAttribute*>(attribs[i]);
2304
2305     if(!anAttr) {
2306       continue;
2307     }
2308
2309     std::string aType = anAttr->GetClassType();
2310     fp << Tab << "  -- " << aType;
2311
2312     if(aType == std::string("AttributeReal")) {
2313       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeReal*>(anAttr)->Value();
2314     }
2315     else if(aType == std::string("AttributeInteger")) {
2316       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeInteger*>(anAttr)->Value();
2317     }
2318     else if(aType ==  std::string("AttributeName")) {
2319       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeName*>(anAttr)->Value();
2320     }
2321     else if(aType == std::string("AttributeComment")) {
2322       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeComment*>(anAttr)->Value();
2323     }
2324     else if(aType == std::string("AttributeReference")) {
2325       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeReference*>(anAttr)->Save();
2326     }
2327     fp << std::endl;
2328   }
2329
2330   SALOMEDSImpl_ChildIterator Itr = theStudy->NewChildIterator(theSO);
2331   std::string aNewTab("   ");
2332   aNewTab+=aTab;
2333   for(; Itr.More(); Itr.Next()) {
2334     dumpSO(Itr.Value(), fp, aNewTab, theStudy);
2335   }
2336
2337   return;
2338 }
2339
2340 void SALOMEDSImpl_Study::Modify()
2341 {
2342   _errorCode = "";
2343   _doc->SetModified(true);
2344 }
2345
2346 //============================================================================
2347 /*! Function :
2348  *  Purpose  :
2349  */
2350 //============================================================================
2351 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetCommonParameters(const char* theID, int theSavePoint)
2352 {
2353   if (theSavePoint < -1) return NULL;
2354   SALOMEDSImpl_StudyBuilder* builder = NewBuilder();
2355   SALOMEDSImpl_SObject so = FindComponent((char*)theID);
2356   if (!so) so = builder->NewComponent((char*)theID);
2357   SALOMEDSImpl_AttributeParameter* attParam = NULL;
2358
2359   if (theSavePoint == -1) {
2360     int ctag = 1;
2361     DF_Label savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 );
2362     DF_Label prevPointLabel;
2363     while ( !savePointLabel.IsNull() ) {
2364       ctag++;
2365       prevPointLabel = savePointLabel;
2366       savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 );
2367     }
2368     if ( !prevPointLabel.IsNull() )
2369       so = GetSObject( prevPointLabel );
2370   }
2371   if (theSavePoint > 0) { // Try to find SObject that contains attribute parameter ...
2372     DF_Label savePointLabel = so.GetLabel().FindChild( theSavePoint, /*create=*/0 );
2373     if ( !savePointLabel.IsNull() )
2374       so = GetSObject( savePointLabel );
2375     else // ... if it does not exist - create a new one
2376       so = builder->NewObjectToTag( so, theSavePoint );
2377   }
2378
2379   DF_Attribute* A;
2380   if (so) {
2381     builder->FindAttribute(so, A, "AttributeParameter");
2382     if ( !A ) { // first call of GetCommonParameters on "Interface Applicative" component
2383       A = builder->FindOrCreateAttribute(so, "AttributeParameter");
2384     }
2385     attParam = dynamic_cast<SALOMEDSImpl_AttributeParameter*>( A );
2386   }
2387   return attParam;
2388 }
2389
2390 //============================================================================
2391 /*! Function :
2392  *  Purpose  :
2393  */
2394 //============================================================================
2395 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetModuleParameters(const char* theID,
2396                                                                          const char* theModuleName,
2397                                                                          int theSavePoint)
2398 {
2399   if(theSavePoint < -1) return NULL;
2400   SALOMEDSImpl_AttributeParameter* main_ap = GetCommonParameters(theID, theSavePoint);
2401   SALOMEDSImpl_SObject main_so = main_ap->GetSObject();
2402   SALOMEDSImpl_AttributeParameter* par = NULL;
2403
2404   SALOMEDSImpl_ChildIterator it = NewChildIterator(main_so);
2405   std::string moduleName(theModuleName);
2406   for(; it.More(); it.Next()) {
2407     SALOMEDSImpl_SObject so(it.Value());
2408     if((par=(SALOMEDSImpl_AttributeParameter*)so.GetLabel().FindAttribute(SALOMEDSImpl_AttributeParameter::GetID()))) {
2409       if(!par->IsSet("AP_MODULE_NAME", (Parameter_Types)3)) continue; //3 -> PT_STRING
2410       if(par->GetString("AP_MODULE_NAME") == moduleName) return par;
2411     }
2412   }
2413
2414   SALOMEDSImpl_StudyBuilder* builder = NewBuilder();
2415   SALOMEDSImpl_SObject so = builder->NewObject(main_so);
2416   par  = dynamic_cast<SALOMEDSImpl_AttributeParameter*>(builder->FindOrCreateAttribute(so, "AttributeParameter"));
2417   par->SetString("AP_MODULE_NAME", moduleName);
2418   return par;
2419 }
2420
2421 //============================================================================
2422 /*! Function : SetStudyLock
2423  *  Purpose  :
2424  */
2425 //============================================================================
2426 void SALOMEDSImpl_Study::SetStudyLock(const char* theLockerID)
2427 {
2428   _lockers.push_back(theLockerID);
2429 }
2430
2431 //============================================================================
2432 /*! Function : IsStudyLocked
2433  *  Purpose  :
2434  */
2435 //============================================================================
2436 bool SALOMEDSImpl_Study::IsStudyLocked()
2437 {
2438   return (_lockers.size() > 0);
2439 }
2440
2441 //============================================================================
2442 /*! Function : UnLockStudy
2443  *  Purpose  :
2444  */
2445 //============================================================================
2446 void SALOMEDSImpl_Study::UnLockStudy(const char* theLockerID)
2447 {
2448   std::vector<std::string>::iterator vsI = _lockers.begin();
2449   int length = _lockers.size();
2450   bool isFound = false;
2451   std::string id(theLockerID);
2452   for(int i = 0; i<length; i++, vsI++) {
2453     if(id == _lockers[i]) {
2454       isFound = true;;
2455       break;
2456     }
2457   }
2458   if(isFound) _lockers.erase(vsI);
2459 }
2460
2461 //============================================================================
2462 /*! Function : GetLockerID
2463  *  Purpose  :
2464  */
2465 //============================================================================
2466 std::vector<std::string> SALOMEDSImpl_Study::GetLockerID()
2467 {
2468   return _lockers;
2469 }
2470
2471 //============================================================================
2472 /*! Function : SetVariable
2473  *  Purpose  :
2474  */
2475 //============================================================================
2476 void SALOMEDSImpl_Study::SetVariable(const std::string& theVarName,
2477                                      const double theValue,
2478                                      const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2479 {
2480   bool modified = false;
2481   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2482
2483   if( aGVar == NULL ) {
2484
2485     SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName);
2486
2487     aSVar->setValue(theValue);
2488     myNoteBookVars.push_back(aSVar);
2489     modified = true;
2490   }
2491   else {
2492     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar)) {
2493       modified = aSVar->setValue(theValue) || modified;
2494       modified = aSVar->setType(theType) || modified;
2495     }
2496   }
2497   if(modified)
2498     Modify();
2499 }
2500
2501 //============================================================================
2502 /*! Function : SetStringVariable
2503  *  Purpose  :
2504  */
2505 //============================================================================
2506 void SALOMEDSImpl_Study::SetStringVariable(const std::string& theVarName,
2507                                            const std::string& theValue,
2508                                            const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2509 {
2510   bool modified = false;
2511   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2512
2513   if( aGVar == NULL ) {
2514
2515     SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName);
2516
2517     aSVar->setStringValue(theValue);
2518     myNoteBookVars.push_back(aSVar);
2519     modified = true;
2520   }
2521   else {
2522     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar)) {
2523       modified = aSVar->setStringValue(theValue) || modified;
2524       modified = aSVar->setType(theType) || modified;
2525     }
2526   }
2527   if(modified)
2528     Modify();
2529 }
2530
2531 //============================================================================
2532 /*! Function : SetStringVariableAsDouble
2533  *  Purpose  :
2534  */
2535 //============================================================================
2536 void SALOMEDSImpl_Study::SetStringVariableAsDouble(const std::string& theVarName,
2537                                                    const double theValue,
2538                                                    const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2539 {
2540   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2541   if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2542     aSVar->setValue(theValue);
2543 }
2544
2545 //============================================================================
2546 /*! Function : GetReal
2547  *  Purpose  :
2548  */
2549 //============================================================================
2550 double SALOMEDSImpl_Study::GetVariableValue(const std::string& theVarName)
2551 {
2552   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2553
2554   if(aGVar != NULL )
2555     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2556       return aSVar->getValue();
2557
2558   return 0;
2559 }
2560
2561 //============================================================================
2562 /*! Function : GetString
2563  *  Purpose  :
2564  */
2565 //============================================================================
2566 std::string SALOMEDSImpl_Study::GetStringVariableValue(const std::string& theVarName)
2567 {
2568   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2569
2570   if(aGVar != NULL )
2571     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2572       return aSVar->getStringValue();
2573
2574   return 0;
2575 }
2576
2577 //============================================================================
2578 /*! Function : IsTypeOf
2579  *  Purpose  :
2580  */
2581 //============================================================================
2582 bool SALOMEDSImpl_Study::IsTypeOf(const std::string& theVarName,
2583                                   SALOMEDSImpl_GenericVariable::
2584                                   VariableTypes theType) const
2585 {
2586   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2587
2588   if(aGVar != NULL )
2589     return aGVar->Type() == theType;
2590
2591   return false;
2592 }
2593
2594 //============================================================================
2595 /*! Function : IsVariable
2596  *  Purpose  :
2597  */
2598 //============================================================================
2599 bool SALOMEDSImpl_Study::IsVariable(const std::string& theVarName) const
2600 {
2601   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2602   return (aGVar != NULL);
2603 }
2604
2605 //============================================================================
2606 /*! Function : GetVariableNames
2607  *  Purpose  :
2608  */
2609 //============================================================================
2610 std::vector<std::string> SALOMEDSImpl_Study::GetVariableNames() const
2611 {
2612   std::vector<std::string> aResult;
2613
2614   for(int i = 0; i < myNoteBookVars.size(); i++)
2615     aResult.push_back(myNoteBookVars[i]->Name());
2616
2617   return aResult;
2618 }
2619
2620 //============================================================================
2621 /*! Function : AddVariable
2622  *  Purpose  :
2623  */
2624 //============================================================================
2625 void SALOMEDSImpl_Study::AddVariable(SALOMEDSImpl_GenericVariable* theVariable)
2626 {
2627   myNoteBookVars.push_back(theVariable);
2628 }
2629
2630 //============================================================================
2631 /*! Function : AddVariable
2632  *  Purpose  :
2633  */
2634 //============================================================================
2635 SALOMEDSImpl_GenericVariable* SALOMEDSImpl_Study::GetVariable(const std::string& theName) const
2636 {
2637   SALOMEDSImpl_GenericVariable* aResult = NULL;
2638   for(int i = 0; i < myNoteBookVars.size();i++) {
2639     if(theName.compare(myNoteBookVars[i]->Name()) == 0) {
2640       aResult = myNoteBookVars[i];
2641       break;
2642     }
2643   }
2644   return aResult;
2645 }
2646
2647 //============================================================================
2648 /*! Function : RemoveVariable
2649  *  Purpose  :
2650  */
2651 //============================================================================
2652 bool SALOMEDSImpl_Study::RemoveVariable(const std::string& theVarName)
2653 {
2654   SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName );
2655   if( !aVariable )
2656     return false;
2657
2658   std::string aValue = aVariable->SaveToScript();
2659   ReplaceVariableAttribute( theVarName, aValue );
2660
2661   std::vector<SALOMEDSImpl_GenericVariable*>::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end();
2662   for( ; it != itEnd; it++ )
2663   {
2664     SALOMEDSImpl_GenericVariable* aVariableRef = *it;
2665     if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 )
2666     {
2667       myNoteBookVars.erase( it );
2668       Modify();
2669       break;
2670     }
2671   }
2672
2673   return true;
2674 }
2675
2676 //============================================================================
2677 /*! Function : RenameVariable
2678  *  Purpose  :
2679  */
2680 //============================================================================
2681 bool SALOMEDSImpl_Study::RenameVariable(const std::string& theVarName, const std::string& theNewVarName)
2682 {
2683   SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName );
2684   if( !aVariable )
2685     return false;
2686
2687   ReplaceVariableAttribute( theVarName, theNewVarName );
2688
2689   std::vector<SALOMEDSImpl_GenericVariable*>::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end();
2690   for( ; it != itEnd; it++ )
2691   {
2692     SALOMEDSImpl_GenericVariable* aVariableRef = *it;
2693     if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 )
2694     {
2695       aVariableRef->setName( theNewVarName );
2696       Modify();
2697       break;
2698     }
2699   }
2700
2701   return true;
2702 }
2703
2704 //============================================================================
2705 /*! Function : IsVariableUsed
2706  *  Purpose  :
2707  */
2708 //============================================================================
2709 bool SALOMEDSImpl_Study::IsVariableUsed(const std::string& theVarName)
2710 {
2711   return FindVariableAttribute( theVarName );
2712 }
2713
2714 //============================================================================
2715 /*! Function : FindVariableAttribute
2716  *  Purpose  :
2717  */
2718 //============================================================================
2719 bool SALOMEDSImpl_Study::FindVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder,
2720                                                SALOMEDSImpl_SObject theSObject,
2721                                                const std::string& theName)
2722 {
2723   SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject );
2724   for( ; anIter.More(); anIter.Next() )
2725     if( FindVariableAttribute( theStudyBuilder, anIter.Value(), theName ) )
2726       return true;
2727
2728   DF_Attribute* anAttr;
2729   if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) )
2730   {
2731     if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr )
2732     {
2733       std::string aString = aStringAttr->Value();
2734
2735       std::vector< std::vector<std::string> > aSections = ParseVariables( aString );
2736       for( int i = 0, n = aSections.size(); i < n; i++ )
2737       {
2738         std::vector<std::string> aVector = aSections[i];
2739         for( int j = 0, m = aVector.size(); j < m; j++ )
2740         {
2741           std::string aStr = aVector[j];
2742           if( aStr.compare( theName ) == 0 )
2743             return true;
2744         }
2745       }
2746     }
2747   }
2748   return false;
2749 }
2750
2751 //============================================================================
2752 /*! Function : FindVariableAttribute
2753  *  Purpose  :
2754  */
2755 //============================================================================
2756 bool SALOMEDSImpl_Study::FindVariableAttribute(const std::string& theName)
2757 {
2758   SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder();
2759   SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator();
2760   for( ; aCompIter.More(); aCompIter.Next() )
2761   {
2762     SALOMEDSImpl_SObject aComp = aCompIter.Value();
2763     if( FindVariableAttribute( aStudyBuilder, aComp, theName ) )
2764       return true;
2765   }
2766   return false;
2767 }
2768
2769 //============================================================================
2770 /*! Function : ReplaceVariableAttribute
2771  *  Purpose  :
2772  */
2773 //============================================================================
2774 void SALOMEDSImpl_Study::ReplaceVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder,
2775                                                   SALOMEDSImpl_SObject theSObject,
2776                                                   const std::string& theSource,
2777                                                   const std::string& theDest)
2778 {
2779   SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject );
2780   for( ; anIter.More(); anIter.Next() )
2781     ReplaceVariableAttribute( theStudyBuilder, anIter.Value(), theSource, theDest );
2782
2783   DF_Attribute* anAttr;
2784   if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) )
2785   {
2786     if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr )
2787     {
2788       bool isChanged = false;
2789       std::string aNewString, aCurrentString = aStringAttr->Value();
2790
2791       std::vector< std::vector<std::string> > aSections = ParseVariables( aCurrentString );
2792       for( int i = 0, n = aSections.size(); i < n; i++ )
2793       {
2794         std::vector<std::string> aVector = aSections[i];
2795         for( int j = 0, m = aVector.size(); j < m; j++ )
2796         {
2797           std::string aStr = aVector[j];
2798           if( aStr.compare( theSource ) == 0 )
2799           {
2800             isChanged = true;
2801             aStr = theDest;
2802           }
2803
2804           aNewString.append( aStr );
2805           if( j != m - 1 )
2806             aNewString.append( ":" );
2807         }
2808         if( i != n - 1 )
2809           aNewString.append( "|" );
2810       }
2811
2812       if( isChanged )
2813         aStringAttr->SetValue( aNewString );
2814     }
2815   }
2816 }
2817
2818 //============================================================================
2819 /*! Function : ReplaceVariableAttribute
2820  *  Purpose  :
2821  */
2822 //============================================================================
2823 void SALOMEDSImpl_Study::ReplaceVariableAttribute(const std::string& theSource, const std::string& theDest)
2824 {
2825   SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder();
2826   SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator();
2827   for( ; aCompIter.More(); aCompIter.Next() )
2828   {
2829     SALOMEDSImpl_SObject aComp = aCompIter.Value();
2830     ReplaceVariableAttribute( aStudyBuilder, aComp, theSource, theDest );
2831   }
2832 }
2833
2834 //============================================================================
2835 /*! Function : ParseVariables
2836  *  Purpose  :
2837  */
2838 //============================================================================
2839 std::vector< std::vector< std::string > > SALOMEDSImpl_Study::ParseVariables(const std::string& theVariables) const
2840 {
2841   return SALOMEDSImpl_Tool::splitStringWithEmpty( theVariables, OPERATION_SEPARATOR, VARIABLE_SEPARATOR );
2842 }
2843
2844 //============================================================================
2845 /*! Function : EnableUseCaseAutoFilling
2846  *  Purpose  :
2847  */
2848 //============================================================================
2849 void SALOMEDSImpl_Study::EnableUseCaseAutoFilling(bool isEnabled)
2850 {
2851   _errorCode = ""; _autoFill = isEnabled;
2852   if(isEnabled) {
2853     _builder->SetOnAddSObject(_cb);
2854     _builder->SetOnRemoveSObject(_cb);
2855   }
2856   else {
2857     _builder->SetOnAddSObject(NULL);
2858     _builder->SetOnRemoveSObject(NULL);
2859   }
2860 }
2861
2862 //============================================================================
2863 /*! Function : GetIORs
2864  *  Purpose  :
2865  */
2866 //============================================================================
2867 std::vector<std::string> SALOMEDSImpl_Study::GetIORs()
2868 {
2869   std::vector<std::string> anIORs;
2870   std::map<std::string, DF_Label>::const_iterator MI;
2871   for(MI = myIORLabels.begin(); MI!=myIORLabels.end(); MI++)
2872     anIORs.push_back(MI->first);
2873
2874   return anIORs;
2875 }
2876
2877 //============================================================================
2878 /*! Function : addSO_Notification
2879  *  Purpose  : This function tells all the observers that a SO has been added
2880  */
2881 //============================================================================
2882 bool SALOMEDSImpl_Study::addSO_Notification (const SALOMEDSImpl_SObject& theSObject)
2883 {
2884   if(_notifier)
2885     return _notifier->addSO_Notification(theSObject);
2886   else
2887     return false;
2888 }
2889
2890 //============================================================================
2891 /*! Function : removeSO_Notification
2892  *  Purpose  : This function tells all the observers that a SO has been removed
2893  */
2894 //============================================================================
2895 bool SALOMEDSImpl_Study::removeSO_Notification (const SALOMEDSImpl_SObject& theSObject)
2896 {
2897   if(_notifier)
2898     return _notifier->removeSO_Notification(theSObject);
2899   else
2900     return false;
2901 }
2902
2903 //============================================================================
2904 /*! Function : modifySO_Notification
2905  *  Purpose  : This function tells all the observers that a SO has been modified and
2906                pass the mofification reason
2907  */
2908 //============================================================================
2909 bool SALOMEDSImpl_Study::modifySO_Notification (const SALOMEDSImpl_SObject& theSObject, int reason)
2910 {
2911   if(_notifier)
2912     return _notifier->modifySO_Notification(theSObject, reason);
2913   else
2914     return false;
2915 }
2916
2917 //============================================================================
2918 /*! Function : setNotifier
2919  *  Purpose  : register a notifier
2920  */
2921 //============================================================================
2922 void SALOMEDSImpl_Study::setNotifier(SALOMEDSImpl_AbstractCallback* notifier)
2923 {
2924   _notifier=notifier;
2925 }
2926
2927 static SALOMEDSImpl_AbstractCallback* & getGenObjRegister( DF_Document* doc )
2928 {
2929   static std::vector< SALOMEDSImpl_AbstractCallback* > _genObjRegVec;
2930   if ( doc->GetDocumentID() >= (int)_genObjRegVec.size() )
2931     _genObjRegVec.resize( doc->GetDocumentID() + 1, 0 );
2932   return _genObjRegVec[ doc->GetDocumentID() ];
2933 }
2934
2935 //================================================================================
2936 /*!
2937  * \brief Stores theRegister
2938  */
2939 //================================================================================
2940
2941 void SALOMEDSImpl_Study::setGenObjRegister(SALOMEDSImpl_AbstractCallback* theRegister)
2942 {
2943   getGenObjRegister( _doc ) = theRegister;
2944 }
2945
2946 //================================================================================
2947 /*!
2948  * \brief Indirectly invokes GenericObj_i::Register()
2949  */
2950 //================================================================================
2951
2952 void SALOMEDSImpl_Study::RegisterGenObj  (const std::string& theIOR, DF_Label label)
2953 {
2954   if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() ))
2955     goRegister->RegisterGenObj( theIOR );
2956 }
2957
2958 //================================================================================
2959 /*!
2960  * \brief Indirectly invokes GenericObj_i::UnRegister()
2961  */
2962 //================================================================================
2963
2964 void SALOMEDSImpl_Study::UnRegisterGenObj(const std::string& theIOR, DF_Label label)
2965 {
2966   if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() ))
2967     goRegister->UnRegisterGenObj( theIOR );
2968 }
2969
2970 //#######################################################################################################
2971 //#                                     STATIC PRIVATE FUNCTIONS
2972 //#######################################################################################################
2973
2974 //============================================================================
2975 /*! Function : SaveAttributes
2976  *  Purpose  : Save attributes for object
2977  */
2978 //============================================================================
2979 static void SaveAttributes(const SALOMEDSImpl_SObject& aSO, HDFgroup *hdf_group_sobject)
2980 {
2981   hdf_size size[1];
2982   std::vector<DF_Attribute*> attrList = aSO.GetLabel().GetAttributes();
2983   DF_Attribute* anAttr = NULL;
2984   for(int i = 0, len = attrList.size(); i<len; i++) {
2985     anAttr = attrList[i];
2986     //The following attributes are not supposed to be written to the file
2987     std::string type = SALOMEDSImpl_GenericAttribute::Impl_GetType(anAttr);
2988     if(type == std::string("AttributeIOR")) continue; //IOR attribute is not saved
2989     std::string aSaveStr =anAttr->Save();
2990     //cout << "Saving: " << aSO.GetID() << " type: "<< type<<"|" << endl;
2991     size[0] = (hdf_int32) strlen(aSaveStr.c_str()) + 1;
2992     HDFdataset *hdf_dataset = new HDFdataset((char*)type.c_str(), hdf_group_sobject, HDF_STRING,size, 1);
2993     hdf_dataset->CreateOnDisk();
2994     hdf_dataset->WriteOnDisk((char*)aSaveStr.c_str());
2995     hdf_dataset->CloseOnDisk();
2996     hdf_dataset=0; //will be deleted by hdf_sco_group destructor
2997   }
2998 }
2999
3000 //===========================================================================
3001 //Function : ReadAttributes
3002 //===========================================================================
3003 static void ReadAttributes(SALOMEDSImpl_Study* theStudy,
3004                            const SALOMEDSImpl_SObject& aSO,
3005                            HDFdataset* hdf_dataset)
3006 {
3007   hdf_dataset->OpenOnDisk();
3008
3009   DF_Attribute* anAttr = NULL;
3010   char* current_string = new char[hdf_dataset->GetSize()+1];
3011   hdf_dataset->ReadFromDisk(current_string);
3012   //cout << "Reading attr type = " << hdf_dataset->GetName() << "  SO = " << aSO.GetID() << endl;
3013   if (!strcmp(hdf_dataset->GetName(),"COMPONENTDATATYPE")) {
3014     anAttr = theStudy->NewBuilder()->FindOrCreateAttribute(aSO, "AttributeComment");
3015   }
3016   else if (!strcmp(hdf_dataset->GetName(),"AttributeReference") ||
3017            !strcmp(hdf_dataset->GetName(),"Reference")) { // Old format maintainance
3018     theStudy->NewBuilder()->Addreference(aSO, theStudy->CreateObjectID(current_string));
3019     delete [] (current_string);
3020     hdf_dataset->CloseOnDisk();
3021     return;
3022   }
3023   else {
3024     anAttr = theStudy->NewBuilder()->FindOrCreateAttribute(aSO, hdf_dataset->GetName());
3025   }
3026
3027   if (anAttr) {
3028     anAttr->Load(current_string);
3029   }
3030
3031   delete [] (current_string);
3032   hdf_dataset->CloseOnDisk();
3033 }
3034
3035 //============================================================================
3036 //Function : BuildlTree
3037 //============================================================================
3038 static void BuildTree (SALOMEDSImpl_Study* theStudy, HDFgroup* hdf_current_group)
3039 {
3040   hdf_current_group->OpenOnDisk();
3041   SALOMEDSImpl_SObject aSO;
3042   char* Entry = hdf_current_group->GetName();
3043   if (strcmp(Entry,"STUDY_STRUCTURE") == 0) {
3044     aSO = theStudy->CreateObjectID("0:1");
3045   }
3046   else {
3047     aSO = theStudy->CreateObjectID(Entry);
3048   }
3049
3050   char name[HDF_NAME_MAX_LEN+1];
3051   int nbsons = hdf_current_group->nInternalObjects();
3052   for (int i=0; i<nbsons; i++) {
3053     hdf_current_group->InternalObjectIndentify(i,name);
3054     if (strncmp(name, "INTERNAL_COMPLEX",16) == 0) continue;
3055     hdf_object_type type = hdf_current_group->InternalObjectType(name);
3056
3057     if (type == HDF_DATASET) {
3058       HDFdataset* new_dataset = new HDFdataset(name,hdf_current_group);
3059       ReadAttributes(theStudy,aSO,new_dataset);
3060       new_dataset = 0; // will be deleted by father destructor
3061     }
3062     else if (type == HDF_GROUP)   {
3063       HDFgroup* new_group = new HDFgroup(name,hdf_current_group);
3064       BuildTree (theStudy, new_group);
3065       new_group = 0; // will be deleted by father destructor
3066     }
3067   }
3068   hdf_current_group->CloseOnDisk();
3069 }
3070
3071
3072 //============================================================================
3073 //Function : Translate_IOR_to_persistentID
3074 //============================================================================
3075 static void Translate_IOR_to_persistentID (const SALOMEDSImpl_SObject& so,
3076                                            SALOMEDSImpl_Driver*        engine,
3077                                            bool                        isMultiFile,
3078                                            bool                        isASCII)
3079 {
3080   DF_ChildIterator itchild(so.GetLabel());
3081   std::string ior_string,  persistent_string, curid;
3082
3083   for (; itchild.More(); itchild.Next()) {
3084     SALOMEDSImpl_SObject current = SALOMEDSImpl_Study::SObject(itchild.Value());
3085     SALOMEDSImpl_AttributeIOR* IOR = NULL;
3086     if ((IOR=(SALOMEDSImpl_AttributeIOR*)current.GetLabel().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID()))) {
3087       ior_string = IOR->Value();
3088
3089       persistent_string = engine->IORToLocalPersistentID (current, ior_string, isMultiFile, isASCII);
3090       SALOMEDSImpl_AttributePersistentRef::Set(current.GetLabel(), persistent_string);
3091     }
3092     Translate_IOR_to_persistentID (current, engine, isMultiFile, isASCII);
3093   }
3094 }
3095
3096 void ReadNoteBookVariables(SALOMEDSImpl_Study* theStudy, HDFgroup* theGroup)
3097 {
3098   if(!theGroup)
3099     return;
3100
3101   HDFgroup* new_group =0;
3102   HDFdataset* new_dataset =0;
3103
3104   char aVarName[HDF_NAME_MAX_LEN+1];
3105   char *currentVarType = 0;
3106   char *currentVarValue = 0;
3107   char *currentVarIndex = 0;
3108   int order = 0;
3109   //Open HDF group with notebook variables
3110   theGroup->OpenOnDisk();
3111
3112   //Get Nb of variables
3113   int aNbVars = theGroup->nInternalObjects();
3114
3115   std::map<int,SALOMEDSImpl_GenericVariable*> aVarsMap;
3116
3117   for( int iVar=0;iVar < aNbVars;iVar++ ) {
3118     theGroup->InternalObjectIndentify(iVar,aVarName);
3119     hdf_object_type type = theGroup->InternalObjectType(aVarName);
3120     if(type == HDF_GROUP) {
3121
3122       //Read Variable
3123       new_group = new HDFgroup(aVarName,theGroup);
3124       new_group->OpenOnDisk();
3125
3126       //Read Type
3127       new_dataset = new HDFdataset("VARIABLE_TYPE",new_group);
3128       new_dataset->OpenOnDisk();
3129       currentVarType = new char[new_dataset->GetSize()+1];
3130       new_dataset->ReadFromDisk(currentVarType);
3131       new_dataset->CloseOnDisk();
3132       new_dataset = 0; //will be deleted by hdf_sco_group destructor
3133
3134       //Read Order
3135       if(new_group->ExistInternalObject("VARIABLE_INDEX")) {
3136         new_dataset = new HDFdataset("VARIABLE_INDEX",new_group);
3137         new_dataset->OpenOnDisk();
3138         currentVarIndex = new char[new_dataset->GetSize()+1];
3139         new_dataset->ReadFromDisk(currentVarIndex);
3140         new_dataset->CloseOnDisk();
3141         new_dataset = 0; //will be deleted by hdf_sco_group destructor
3142         order = atoi(currentVarIndex);
3143         delete [] currentVarIndex;
3144       }
3145       else
3146         order = iVar;
3147
3148       //Read Value
3149       new_dataset = new HDFdataset("VARIABLE_VALUE",new_group);
3150       new_dataset->OpenOnDisk();
3151       currentVarValue = new char[new_dataset->GetSize()+1];
3152       new_dataset->ReadFromDisk(currentVarValue);
3153       new_dataset->CloseOnDisk();
3154       new_dataset = 0; //will be deleted by hdf_sco_group destructor
3155
3156       new_group->CloseOnDisk();
3157       new_group = 0;  //will be deleted by hdf_sco_group destructor
3158
3159       SALOMEDSImpl_GenericVariable::VariableTypes aVarType =
3160         SALOMEDSImpl_GenericVariable::String2VariableType(std::string(currentVarType));
3161       delete [] currentVarType;
3162
3163       //Create variable and add it in the study
3164       SALOMEDSImpl_GenericVariable* aVariable =
3165         new SALOMEDSImpl_ScalarVariable(aVarType,std::string(aVarName));
3166       aVariable->Load(std::string(currentVarValue));
3167       aVarsMap.insert(std::make_pair(order,aVariable));
3168       delete [] currentVarValue;
3169     }
3170   }
3171
3172   std::map<int,SALOMEDSImpl_GenericVariable*>::const_iterator it= aVarsMap.begin();
3173   for(;it!=aVarsMap.end();it++)
3174     theStudy->AddVariable((*it).second);
3175
3176   theGroup->CloseOnDisk();
3177 }
3178