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 : Name
1588  *  Purpose  : set study name
1589  */
1590 //============================================================================
1591 void SALOMEDSImpl_Study::Name(const std::string& name)
1592 {
1593   _errorCode = "";
1594   _name = name;
1595 }
1596
1597 //============================================================================
1598 /*! Function : IsSaved
1599  *  Purpose  : get if study has been saved
1600  */
1601 //============================================================================
1602 bool SALOMEDSImpl_Study::IsSaved()
1603 {
1604   _errorCode = "";
1605   return _Saved;
1606 }
1607
1608 //============================================================================
1609 /*! Function : IsSaved
1610  *  Purpose  : set if study has been saved
1611  */
1612 //============================================================================
1613 void SALOMEDSImpl_Study::IsSaved(bool save)
1614 {
1615   _errorCode = "";
1616   _Saved = save;
1617   if(save) _doc->SetModified(false);
1618 }
1619
1620 //============================================================================
1621 /*! Function : IsModified
1622  *  Purpose  : Detect if a Study has been modified since it has been saved
1623  */
1624 //============================================================================
1625 bool SALOMEDSImpl_Study::IsModified()
1626 {
1627   _errorCode = "";
1628
1629   // True if is modified
1630   if (_doc && _doc->IsModified()) return true;
1631
1632   return false;
1633 }
1634
1635 //============================================================================
1636 /*! Function : URL
1637  *  Purpose  : get URL of the study (persistent reference of the study)
1638  */
1639 //============================================================================
1640 std::string SALOMEDSImpl_Study::URL()
1641 {
1642   _errorCode = "";
1643   return _URL;
1644 }
1645
1646 //============================================================================
1647 /*! Function : URL
1648  *  Purpose  : set URL of the study (persistent reference of the study)
1649  */
1650 //============================================================================
1651 void SALOMEDSImpl_Study::URL(const std::string& url)
1652 {
1653   _errorCode = "";
1654   _URL = url;
1655   _name = url;
1656
1657   /*jfa: Now name of SALOMEDS study will correspond to name of SalomeApp study
1658   std::string tmp(_URL);
1659
1660   char *aName = (char*)tmp.ToCString();
1661   char *adr = strtok(aName, "/");
1662   while (adr)
1663     {
1664       aName = adr;
1665       adr = strtok(NULL, "/");
1666     }
1667   Name(aName);*/
1668 }
1669
1670
1671 //============================================================================
1672 /*! Function : _FindObject
1673  *  Purpose  : Find an Object with SALOMEDSImpl_Name = anObjectName
1674  */
1675 //============================================================================
1676 SALOMEDSImpl_SObject SALOMEDSImpl_Study::_FindObject(const SALOMEDSImpl_SObject& SO,
1677                                                      const std::string& theObjectName,
1678                                                      bool& _find)
1679 {
1680   SALOMEDSImpl_SObject RefSO;
1681   if(!SO) return RefSO;
1682
1683   // Iterate on each objects and subobjects of the component
1684   // If objectName find, stop the loop and get the object reference
1685   SALOMEDSImpl_AttributeName* anAttr;
1686
1687   std::string soid = SO.GetID();
1688   DF_ChildIterator it(SO.GetLabel());
1689   for (; it.More(); it.Next()){
1690     if(!_find)
1691       {
1692         if ((anAttr=(SALOMEDSImpl_AttributeName*)it.Value().FindAttribute(SALOMEDSImpl_AttributeName::GetID())))
1693         {
1694           std::string Val(anAttr->Value());
1695           if (Val == theObjectName)
1696             {
1697               RefSO = GetSObject(it.Value());
1698               _find = true;
1699             }
1700         }
1701         if (!_find) RefSO = _FindObject(GetSObject(it.Value()), theObjectName, _find);
1702       }
1703   }
1704   return RefSO;
1705 }
1706
1707 //============================================================================
1708 /*! Function : _FindObjectIOR
1709  *  Purpose  : Find an Object with SALOMEDSImpl_IOR = anObjectIOR
1710  */
1711 //============================================================================
1712 SALOMEDSImpl_SObject
1713 SALOMEDSImpl_Study::_FindObjectIOR(const SALOMEDSImpl_SObject& SO,
1714                                    const std::string& theObjectIOR,
1715                                    bool& _find)
1716 {
1717   SALOMEDSImpl_SObject RefSO, aSO;
1718   if(!SO) return RefSO;
1719
1720   // Iterate on each objects and subobjects of the component
1721   // If objectName find, stop the loop and get the object reference
1722   SALOMEDSImpl_AttributeIOR* anAttr;
1723
1724   DF_ChildIterator it(SO.GetLabel());
1725   for (; it.More();it.Next()){
1726     if(!_find)
1727       {
1728         if ((anAttr=(SALOMEDSImpl_AttributeIOR*)it.Value().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID())))
1729         {
1730           std::string Val(anAttr->Value());
1731           if (Val == theObjectIOR)
1732             {
1733               RefSO = GetSObject(it.Value());
1734               _find = true;
1735             }
1736         }
1737         aSO = GetSObject(it.Value());
1738         if (!_find) RefSO =  _FindObjectIOR(aSO, theObjectIOR, _find);
1739       }
1740   }
1741   return RefSO;
1742 }
1743
1744 //============================================================================
1745 /*! Function : _GetNoteBookAccessor
1746  *  Purpose  : Find an Object with SALOMEDSImpl_IOR = anObjectIOR
1747  */
1748 //============================================================================
1749 std::string SALOMEDSImpl_Study::_GetNoteBookAccessor(){
1750   return std::string("notebook");
1751 }
1752
1753 //============================================================================
1754 /*! Function : _GetStudyVariablesScript
1755  *  Purpose  :
1756  */
1757 //============================================================================
1758 std::string SALOMEDSImpl_Study::_GetStudyVariablesScript()
1759 {
1760   std::string dump("");
1761
1762   if(myNoteBookVars.empty())
1763     return dump;
1764
1765   Kernel_Utils::Localizer loc;
1766
1767   dump += "####################################################\n";
1768   dump += "##       Begin of NoteBook variables section      ##\n";
1769   dump += "####################################################\n";
1770
1771   std::string set_method = _GetNoteBookAccessor()+".set(";
1772   std::string varName;
1773   std::string varValue;
1774   for(int i = 0 ; i < myNoteBookVars.size();i++ ) {
1775     varName = myNoteBookVars[i]->Name();
1776     varValue = myNoteBookVars[i]->SaveToScript();
1777     dump+=set_method+"\""+varName+"\", "+varValue+")\n";
1778   }
1779
1780   dump += "####################################################\n";
1781   dump += "##        End of NoteBook variables section       ##\n";
1782   dump += "####################################################\n";
1783
1784   return dump;
1785 }
1786
1787 //============================================================================
1788 /*! Function : _GetNoteBookAccess
1789  *  Purpose  :
1790  */
1791 //============================================================================
1792 std::string SALOMEDSImpl_Study::_GetNoteBookAccess()
1793 {
1794   std::string notebook = "import salome_notebook\n";
1795   notebook += _GetNoteBookAccessor() + " = salome_notebook.NoteBook()" ;
1796   return notebook;
1797 }
1798
1799 bool SALOMEDSImpl_Study::IsLocked()
1800 {
1801   _errorCode = "";
1802   return GetProperties()->IsLocked();
1803 }
1804
1805 void SALOMEDSImpl_Study::UpdateIORLabelMap(const std::string& anIOR,const std::string& anEntry)
1806 {
1807   _errorCode = "";
1808   DF_Label aLabel = DF_Label::Label(_doc->Main(), anEntry, true);
1809   std::map<std::string, DF_Label>::iterator it=myIORLabels.find(anIOR);
1810   if (it != myIORLabels.end()) myIORLabels.erase(it);
1811   myIORLabels[anIOR] = aLabel;
1812 }
1813
1814 void SALOMEDSImpl_Study::DeleteIORLabelMapItem(const std::string& anIOR)
1815 {
1816   std::map<std::string, DF_Label>::iterator it=myIORLabels.find(anIOR);
1817   if (it != myIORLabels.end())
1818     {
1819       //remove the ior entry and decref the genericobj (if it's one)
1820       myIORLabels.erase(it);
1821     }
1822 }
1823
1824 SALOMEDSImpl_Study* SALOMEDSImpl_Study::GetStudyImpl(const DF_Label& theLabel)
1825 {
1826   SALOMEDSImpl_StudyHandle* Att;
1827   if ((Att=(SALOMEDSImpl_StudyHandle*)theLabel.Root().FindAttribute(SALOMEDSImpl_StudyHandle::GetID()))) {
1828     return Att->Get();
1829   }
1830   return NULL;
1831 }
1832
1833 SALOMEDSImpl_SObject SALOMEDSImpl_Study::SObject(const DF_Label& theLabel)
1834 {
1835   return GetStudyImpl(theLabel)->GetSObject(theLabel);
1836 }
1837
1838 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::SComponent(const DF_Label& theLabel)
1839 {
1840   return GetStudyImpl(theLabel)->GetSComponent(theLabel);
1841 }
1842
1843
1844 void SALOMEDSImpl_Study::IORUpdated(const SALOMEDSImpl_AttributeIOR* theAttribute)
1845 {
1846   std::string aString = theAttribute->Label().Entry();
1847   GetStudyImpl(theAttribute->Label())->UpdateIORLabelMap(theAttribute->Value(), aString);
1848 }
1849
1850 std::vector<SALOMEDSImpl_SObject> SALOMEDSImpl_Study::FindDependances(const SALOMEDSImpl_SObject& anObject)
1851 {
1852   _errorCode = "";
1853   std::vector<SALOMEDSImpl_SObject> aSeq;
1854
1855   SALOMEDSImpl_AttributeTarget* aTarget;
1856   if ((aTarget=(SALOMEDSImpl_AttributeTarget*)anObject.GetLabel().FindAttribute(SALOMEDSImpl_AttributeTarget::GetID()))) {
1857     return aTarget->Get();
1858   }
1859
1860   return aSeq;
1861 }
1862
1863
1864 SALOMEDSImpl_AttributeStudyProperties* SALOMEDSImpl_Study::GetProperties()
1865 {
1866   _errorCode = "";
1867   return SALOMEDSImpl_AttributeStudyProperties::Set(_doc->Main());
1868 }
1869
1870 std::string SALOMEDSImpl_Study::GetLastModificationDate()
1871 {
1872   _errorCode = "";
1873   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
1874
1875   std::vector<std::string> aNames;
1876   std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
1877   aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
1878
1879   int aLastIndex = aNames.size()-1;
1880   char aResult[20];
1881   sprintf(aResult, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d",
1882           (int)(aDays[aLastIndex]),(int)(aMonths[aLastIndex]), (int)(aYears[aLastIndex]),
1883           (int)(aHours[aLastIndex]), (int)(aMinutes[aLastIndex]));
1884   std::string aResStr (aResult);
1885   return aResStr;
1886 }
1887
1888 std::vector<std::string> SALOMEDSImpl_Study::GetModificationsDate()
1889 {
1890   _errorCode = "";
1891   SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties();
1892
1893   std::vector<std::string> aNames;
1894   std::vector<int> aMinutes, aHours, aDays, aMonths, aYears;
1895   aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears);
1896
1897   int anIndex, aLength = aNames.size();
1898   std::vector<std::string> aDates;
1899
1900   for (anIndex = 1; anIndex < aLength; anIndex++) {
1901     char aDate[20];
1902     sprintf(aDate, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d",
1903             (int)(aDays[anIndex]), (int)(aMonths[anIndex]), (int)(aYears[anIndex]),
1904             (int)(aHours[anIndex]), (int)(aMinutes[anIndex]));
1905     aDates.push_back(aDate);
1906   }
1907   return aDates;
1908 }
1909
1910
1911
1912 //============================================================================
1913 /*! Function : GetUseCaseBuilder
1914  *  Purpose  : Returns a UseCase builder
1915  */
1916 //============================================================================
1917 SALOMEDSImpl_UseCaseBuilder* SALOMEDSImpl_Study::GetUseCaseBuilder()
1918 {
1919   _errorCode = "";
1920   return _useCaseBuilder;
1921 }
1922
1923 //============================================================================
1924 /*! Function : GetSComponent
1925  *  Purpose  :
1926  */
1927 //============================================================================
1928 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const std::string& theEntry)
1929 {
1930   SALOMEDSImpl_SComponent aSCO;
1931   if(_mapOfSCO.find(theEntry) != _mapOfSCO.end())
1932     aSCO = _mapOfSCO[theEntry];
1933   else {
1934     DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry);
1935     aSCO = SALOMEDSImpl_SComponent(aLabel);
1936     _mapOfSCO[theEntry] = aSCO;
1937   }
1938
1939   return aSCO;
1940 }
1941
1942 //============================================================================
1943 /*! Function : GetSComponent
1944  *  Purpose  :
1945  */
1946 //============================================================================
1947 SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const DF_Label& theLabel)
1948 {
1949   return SALOMEDSImpl_SComponent(theLabel);
1950 }
1951
1952 //============================================================================
1953 /*! Function : GetSObject
1954  *  Purpose  :
1955  */
1956 //============================================================================
1957 SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const std::string& theEntry)
1958 {
1959   SALOMEDSImpl_SObject aSO;
1960   std::map<std::string, SALOMEDSImpl_SObject>::iterator it=_mapOfSO.find(theEntry);
1961   if(it != _mapOfSO.end())
1962     aSO = it->second;
1963   else {
1964     DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry);
1965     aSO = SALOMEDSImpl_SObject(aLabel);
1966     _mapOfSO[theEntry] = aSO;
1967   }
1968
1969   return aSO;
1970 }
1971
1972 //============================================================================
1973 /*! Function : GetSObject
1974  *  Purpose  :
1975  */
1976 //============================================================================
1977 SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const DF_Label& theLabel)
1978 {
1979   return SALOMEDSImpl_SObject(theLabel);
1980 }
1981
1982 //============================================================================
1983 /*! Function : GetAttribute
1984  *  Purpose  :
1985  */
1986 //============================================================================
1987 DF_Attribute* SALOMEDSImpl_Study::GetAttribute(const std::string& theEntry,
1988                                                const std::string& theType)
1989 {
1990   SALOMEDSImpl_SObject aSO = GetSObject(theEntry);
1991   DF_Attribute* anAttr;
1992   aSO.FindAttribute(anAttr, theType);
1993   return anAttr;
1994 }
1995
1996 //! number of spaces for indentation in Python dump files (to replace \t symbols)
1997 static const int indent_size = 2;
1998
1999 static std::string replace_tabs( const std::string& in )
2000 {
2001   std::string out = in;
2002 #ifdef WITHOUT_TABS
2003   size_t pos = out.find( '\t' );
2004   while ( pos != std::string::npos ) {
2005     out.replace( pos, 1, indent_size, ' ' );
2006     pos = out.find( '\t' );
2007   }
2008 #endif
2009   return out;
2010 }
2011
2012 static std::string GetComponentHeader(const char* theComponentName)
2013 {
2014   std::stringstream txt;
2015   txt << "###" << std::endl;
2016   txt << "### " << theComponentName << " component" << std::endl;
2017   txt << "###" << std::endl;
2018   return txt.str();
2019 }
2020
2021 //============================================================================
2022 /*! Function : DumpStudy
2023  *  Purpose  :
2024  */
2025 //============================================================================
2026 bool SALOMEDSImpl_Study::DumpStudy(const std::string& thePath,
2027                                    const std::string& theBaseName,
2028                                    bool isPublished,
2029                                    bool isMultiFile,
2030                                    SALOMEDSImpl_DriverFactory* theFactory)
2031 {
2032   _errorCode = "";
2033
2034   if(theFactory == NULL) {
2035     _errorCode = "Null factory for creation of Engines";
2036     return false;
2037   }
2038
2039   std::vector<std::string> aSeq;
2040   std::string aCompType, aFactoryType;
2041
2042   //Build a list of all components in the Study
2043   SALOMEDSImpl_SComponentIterator itcomponent = NewComponentIterator();
2044
2045   for (; itcomponent.More(); itcomponent.Next()) {
2046     SALOMEDSImpl_SComponent sco = itcomponent.Value();
2047     aCompType = sco.ComponentDataType();
2048    if (aCompType == "GEOM")
2049       aSeq.insert(aSeq.begin(), aCompType);
2050     else
2051       aSeq.push_back(aCompType);
2052   }
2053   // re-arrange modules in the sequence, if specific order is given via SALOME_MODULES_ORDER environment variable.
2054   if ( getenv("SALOME_MODULES_ORDER") != 0 ) {
2055     std::string order = getenv("SALOME_MODULES_ORDER");
2056     std::vector<std::string> mlist;
2057     while ( !order.empty() ) {
2058       size_t idx = order.find( "," );
2059       std::string m = order.substr(0, idx);
2060       order = order.substr( ( idx == std::string::npos ) ? order.size() : idx+1 );
2061       if ( m.empty() || std::find( mlist.begin(), mlist.end(), m ) != mlist.end() ) continue;
2062       mlist.push_back( m );
2063     }
2064
2065     for ( std::vector<std::string>::reverse_iterator mit = mlist.rbegin(); mit != mlist.rend(); ++mit ) {
2066       std::vector<std::string>::iterator it = std::find( aSeq.begin(), aSeq.end(), *mit );
2067       if ( it != aSeq.end() ) {
2068         aSeq.erase( it );
2069         aSeq.insert( aSeq.begin(), *mit );
2070       }
2071     }
2072   }
2073
2074 #ifdef WIN32
2075   std::string aFileName =
2076     thePath + std::string("\\") + theBaseName + std::string(".py");
2077 #else
2078   std::string aFileName =
2079     thePath + std::string("/")  + theBaseName + std::string(".py");
2080 #endif
2081
2082   //Create a file that will contain a main Study script
2083   std::fstream fp;
2084   fp.open(aFileName.c_str(), std::ios::out);
2085
2086 #ifdef WIN32
2087   bool isOpened = fp.is_open();
2088 #else
2089   bool isOpened = fp.rdbuf()->is_open();
2090 #endif
2091
2092   if(!isOpened) {
2093     _errorCode = std::string("Can't create a file ")+aFileName;
2094     return false;
2095   }
2096
2097   std::stringstream sfp;
2098
2099   std::string aBatchModeScript = "salome";
2100
2101   //Output to the main Study script required Python modules import,
2102   //set sys.path and add a creation of the study.
2103
2104   // dump header
2105   sfp << GetDumpStudyComment() << std::endl;
2106
2107   // global imports
2108   sfp << "import sys" << std::endl;
2109   sfp << "import " << aBatchModeScript << std::endl << std::endl;
2110
2111   // initialization function
2112   sfp << aBatchModeScript << ".salome_init()" << std::endl;
2113
2114   // notebook initialization
2115   sfp << _GetNoteBookAccess() << std::endl;
2116
2117   // extend sys.path with the directory where the script is being dumped to
2118   sfp << "sys.path.insert(0, r\'" << thePath << "\')" << std::endl << std::endl;
2119
2120   // dump NoteBook variables
2121   sfp << _GetStudyVariablesScript();
2122
2123   // dump visual parameters if necessary
2124   bool isDumpVisuals = SALOMEDSImpl_IParameters::isDumpPython(this);
2125   int lastSavePoint = -1;
2126   if(isDumpVisuals) {
2127     lastSavePoint = SALOMEDSImpl_IParameters::getLastSavePoint(this);
2128     if(lastSavePoint > 0) {
2129       sfp << SALOMEDSImpl_IParameters::getStudyScript(this, lastSavePoint) << std::endl << std::endl;
2130     }
2131   }
2132
2133   std::vector<std::string> aSeqOfFileNames;
2134
2135   // dump all components and create the components specific scripts
2136   bool isOk = true;
2137   int aLength = aSeq.size();
2138   for(int i = 1; i <= aLength; i++) {
2139
2140     aCompType = aSeq[i-1];
2141     SALOMEDSImpl_SComponent sco = FindComponent(aCompType);
2142     SALOMEDSImpl_Driver* aDriver = NULL;
2143     // if there is an associated Engine call its method for saving
2144     std::string IOREngine;
2145     try {
2146       if (!sco.ComponentIOR(IOREngine)) {
2147         if (!aCompType.empty()) {
2148
2149           aDriver = theFactory->GetDriverByType(aCompType);
2150
2151           if (aDriver != NULL) {
2152             SALOMEDSImpl_StudyBuilder* SB = NewBuilder();
2153             if(!SB->LoadWith(sco, aDriver)) {
2154               _errorCode = SB->GetErrorCode();
2155               return false;
2156             }
2157           }
2158           else continue;
2159         }
2160       }
2161       else {
2162         aDriver = theFactory->GetDriverByIOR(IOREngine);
2163       }
2164     } catch(...) {
2165       _errorCode = "Can not restore information to dump it";
2166       return false;
2167     }
2168
2169     if(aDriver == NULL) continue;
2170
2171     bool isValidScript;
2172     long aStreamLength  = 0;
2173     SALOMEDSImpl_TMPFile* aStream = aDriver->DumpPython(isPublished, isMultiFile, isValidScript, aStreamLength);
2174     if ( !isValidScript )
2175       isOk = false;
2176
2177     std::stringstream sfp2;
2178
2179     //Output the Python script generated by the component in the newly created file.
2180     if ( isMultiFile )
2181       sfp2 << GetDumpStudyComment( aCompType.c_str() ) << std::endl;
2182     else
2183       sfp2 << GetComponentHeader( aCompType.c_str() ) << std::endl;
2184     sfp2 << aStream->Data();
2185
2186     if ( isMultiFile ) {
2187       //Create a file that will contain the component specific script
2188       std::fstream fp2;
2189 #ifdef WIN32
2190       aFileName=thePath+std::string("\\");
2191 #else
2192       aFileName=thePath+std::string("/");
2193 #endif
2194       std::string aScriptName;
2195       aScriptName += theBaseName;
2196       aScriptName += "_";
2197       aScriptName += aCompType;
2198
2199       aFileName += aScriptName+ std::string(".py");
2200       aSeqOfFileNames.push_back(aFileName);
2201
2202       fp2.open(aFileName.c_str(), std::ios::out);
2203
2204 #ifdef WIN32
2205       isOpened = fp2.is_open();
2206 #else
2207       isOpened = fp2.rdbuf()->is_open();
2208 #endif
2209
2210       if(!isOpened) {
2211         _errorCode = std::string("Can't create a file ")+aFileName;
2212         SALOMEDSImpl_Tool::RemoveTemporaryFiles(thePath, aSeqOfFileNames, false);
2213         return false;
2214       }
2215
2216       // replace '\t' symbols
2217       fp2 << replace_tabs( sfp2.str() );
2218
2219       fp2.close();
2220
2221       //Add to the main script a call to RebuildData of the generated by the component the Python script
2222       sfp << "import " << aScriptName << std::endl;
2223       sfp << aScriptName << ".RebuildData()" << std::endl;
2224     }
2225     else
2226       sfp << sfp2.str();
2227
2228     if(aStream) delete aStream;
2229   }
2230
2231   sfp << std::endl;
2232   sfp << "if salome.sg.hasDesktop():" << std::endl;
2233   sfp << "\tsalome.sg.updateObjBrowser()" << std::endl;
2234
2235   if(isDumpVisuals) { //Output the call to Session's method restoreVisualState
2236     sfp << "\tiparameters.getSession().restoreVisualState(1)" << std::endl;
2237   }
2238
2239   // replace '\t' symbols
2240   fp << replace_tabs( sfp.str() );
2241
2242   fp.close();
2243
2244   return isOk;
2245 }
2246
2247 //=======================================================================
2248 //function : GetDumpStudyComment
2249 //purpose  : return a header comment for a DumpStudy script
2250 //=======================================================================
2251
2252 std::string SALOMEDSImpl_Study::GetDumpStudyComment(const char* theComponentName)
2253 {
2254   std::stringstream txt;
2255   txt << "#!/usr/bin/env python" << std::endl << std::endl;
2256   txt << "###" << std::endl;
2257   txt << "### This file is generated automatically by SALOME v"
2258       << KERNEL_VERSION_STR
2259       << " with dump python functionality";
2260   if ( theComponentName )
2261     txt << " (" << theComponentName << " component)";
2262   txt << std::endl;
2263   txt << "###" << std::endl;
2264   return txt.str();
2265 }
2266
2267 void dumpSO(const SALOMEDSImpl_SObject& theSO,
2268             std::fstream& fp,
2269             const std::string& Tab,
2270             SALOMEDSImpl_Study* theStudy);
2271
2272 //============================================================================
2273 /*! Function : dump
2274  *  Purpose  :
2275  */
2276 //============================================================================
2277 void SALOMEDSImpl_Study::dump(const std::string& theFileName)
2278 {
2279   //Create a file that will contain a main Study script
2280   std::fstream fp;
2281   fp.open(theFileName.c_str(), std::ios::out);
2282
2283 #ifdef WIN32
2284   bool isOpened = fp.is_open();
2285 #else
2286   bool isOpened = fp.rdbuf()->is_open();
2287 #endif
2288
2289   if(!isOpened) {
2290     _errorCode = std::string("Can't create a file ")+theFileName;
2291     std::cout << "### SALOMEDSImpl_Study::dump Error: " << _errorCode << std::endl;
2292     return;
2293   }
2294
2295   SALOMEDSImpl_SObject aSO = FindObjectID("0:1");
2296   fp << "0:1" << std::endl;
2297   SALOMEDSImpl_ChildIterator Itr = NewChildIterator(aSO);
2298   std::string aTab("   ");
2299   for(; Itr.More(); Itr.Next()) {
2300     dumpSO(Itr.Value(), fp, aTab, this);
2301   }
2302
2303   fp.close();
2304 }
2305
2306
2307 void dumpSO(const SALOMEDSImpl_SObject& theSO,
2308             std::fstream& fp,
2309             const std::string& Tab,
2310             SALOMEDSImpl_Study* theStudy)
2311 {
2312   std::string aTab(Tab), anID(theSO.GetID());
2313   fp << aTab << anID << std::endl;
2314   std::vector<DF_Attribute*> attribs = theSO.GetLabel().GetAttributes();
2315   for(int i = 0; i<attribs.size(); i++) {
2316     SALOMEDSImpl_GenericAttribute* anAttr = dynamic_cast<SALOMEDSImpl_GenericAttribute*>(attribs[i]);
2317
2318     if(!anAttr) {
2319       continue;
2320     }
2321
2322     std::string aType = anAttr->GetClassType();
2323     fp << Tab << "  -- " << aType;
2324
2325     if(aType == std::string("AttributeReal")) {
2326       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeReal*>(anAttr)->Value();
2327     }
2328     else if(aType == std::string("AttributeInteger")) {
2329       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeInteger*>(anAttr)->Value();
2330     }
2331     else if(aType ==  std::string("AttributeName")) {
2332       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeName*>(anAttr)->Value();
2333     }
2334     else if(aType == std::string("AttributeComment")) {
2335       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeComment*>(anAttr)->Value();
2336     }
2337     else if(aType == std::string("AttributeReference")) {
2338       fp << " : " << dynamic_cast<SALOMEDSImpl_AttributeReference*>(anAttr)->Save();
2339     }
2340     fp << std::endl;
2341   }
2342
2343   SALOMEDSImpl_ChildIterator Itr = theStudy->NewChildIterator(theSO);
2344   std::string aNewTab("   ");
2345   aNewTab+=aTab;
2346   for(; Itr.More(); Itr.Next()) {
2347     dumpSO(Itr.Value(), fp, aNewTab, theStudy);
2348   }
2349
2350   return;
2351 }
2352
2353 void SALOMEDSImpl_Study::Modify()
2354 {
2355   _errorCode = "";
2356   _doc->SetModified(true);
2357 }
2358
2359 //============================================================================
2360 /*! Function :
2361  *  Purpose  :
2362  */
2363 //============================================================================
2364 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetCommonParameters(const char* theID, int theSavePoint)
2365 {
2366   if (theSavePoint < -1) return NULL;
2367   SALOMEDSImpl_StudyBuilder* builder = NewBuilder();
2368   SALOMEDSImpl_SObject so = FindComponent((char*)theID);
2369   if (!so) so = builder->NewComponent((char*)theID);
2370   SALOMEDSImpl_AttributeParameter* attParam = NULL;
2371
2372   if (theSavePoint == -1) {
2373     int ctag = 1;
2374     DF_Label savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 );
2375     DF_Label prevPointLabel;
2376     while ( !savePointLabel.IsNull() ) {
2377       ctag++;
2378       prevPointLabel = savePointLabel;
2379       savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 );
2380     }
2381     if ( !prevPointLabel.IsNull() )
2382       so = GetSObject( prevPointLabel );
2383   }
2384   if (theSavePoint > 0) { // Try to find SObject that contains attribute parameter ...
2385     DF_Label savePointLabel = so.GetLabel().FindChild( theSavePoint, /*create=*/0 );
2386     if ( !savePointLabel.IsNull() )
2387       so = GetSObject( savePointLabel );
2388     else // ... if it does not exist - create a new one
2389       so = builder->NewObjectToTag( so, theSavePoint );
2390   }
2391
2392   DF_Attribute* A;
2393   if (so) {
2394     builder->FindAttribute(so, A, "AttributeParameter");
2395     if ( !A ) { // first call of GetCommonParameters on "Interface Applicative" component
2396       A = builder->FindOrCreateAttribute(so, "AttributeParameter");
2397     }
2398     attParam = dynamic_cast<SALOMEDSImpl_AttributeParameter*>( A );
2399   }
2400   return attParam;
2401 }
2402
2403 //============================================================================
2404 /*! Function :
2405  *  Purpose  :
2406  */
2407 //============================================================================
2408 SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetModuleParameters(const char* theID,
2409                                                                          const char* theModuleName,
2410                                                                          int theSavePoint)
2411 {
2412   if(theSavePoint < -1) return NULL;
2413   SALOMEDSImpl_AttributeParameter* main_ap = GetCommonParameters(theID, theSavePoint);
2414   SALOMEDSImpl_SObject main_so = main_ap->GetSObject();
2415   SALOMEDSImpl_AttributeParameter* par = NULL;
2416
2417   SALOMEDSImpl_ChildIterator it = NewChildIterator(main_so);
2418   std::string moduleName(theModuleName);
2419   for(; it.More(); it.Next()) {
2420     SALOMEDSImpl_SObject so(it.Value());
2421     if((par=(SALOMEDSImpl_AttributeParameter*)so.GetLabel().FindAttribute(SALOMEDSImpl_AttributeParameter::GetID()))) {
2422       if(!par->IsSet("AP_MODULE_NAME", (Parameter_Types)3)) continue; //3 -> PT_STRING
2423       if(par->GetString("AP_MODULE_NAME") == moduleName) return par;
2424     }
2425   }
2426
2427   SALOMEDSImpl_StudyBuilder* builder = NewBuilder();
2428   SALOMEDSImpl_SObject so = builder->NewObject(main_so);
2429   par  = dynamic_cast<SALOMEDSImpl_AttributeParameter*>(builder->FindOrCreateAttribute(so, "AttributeParameter"));
2430   par->SetString("AP_MODULE_NAME", moduleName);
2431   return par;
2432 }
2433
2434 //============================================================================
2435 /*! Function : SetStudyLock
2436  *  Purpose  :
2437  */
2438 //============================================================================
2439 void SALOMEDSImpl_Study::SetStudyLock(const char* theLockerID)
2440 {
2441   _lockers.push_back(theLockerID);
2442 }
2443
2444 //============================================================================
2445 /*! Function : IsStudyLocked
2446  *  Purpose  :
2447  */
2448 //============================================================================
2449 bool SALOMEDSImpl_Study::IsStudyLocked()
2450 {
2451   return (_lockers.size() > 0);
2452 }
2453
2454 //============================================================================
2455 /*! Function : UnLockStudy
2456  *  Purpose  :
2457  */
2458 //============================================================================
2459 void SALOMEDSImpl_Study::UnLockStudy(const char* theLockerID)
2460 {
2461   std::vector<std::string>::iterator vsI = _lockers.begin();
2462   int length = _lockers.size();
2463   bool isFound = false;
2464   std::string id(theLockerID);
2465   for(int i = 0; i<length; i++, vsI++) {
2466     if(id == _lockers[i]) {
2467       isFound = true;;
2468       break;
2469     }
2470   }
2471   if(isFound) _lockers.erase(vsI);
2472 }
2473
2474 //============================================================================
2475 /*! Function : GetLockerID
2476  *  Purpose  :
2477  */
2478 //============================================================================
2479 std::vector<std::string> SALOMEDSImpl_Study::GetLockerID()
2480 {
2481   return _lockers;
2482 }
2483
2484 //============================================================================
2485 /*! Function : SetVariable
2486  *  Purpose  :
2487  */
2488 //============================================================================
2489 void SALOMEDSImpl_Study::SetVariable(const std::string& theVarName,
2490                                      const double theValue,
2491                                      const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2492 {
2493   bool modified = false;
2494   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2495
2496   if( aGVar == NULL ) {
2497
2498     SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName);
2499
2500     aSVar->setValue(theValue);
2501     myNoteBookVars.push_back(aSVar);
2502     modified = true;
2503   }
2504   else {
2505     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar)) {
2506       modified = aSVar->setValue(theValue) || modified;
2507       modified = aSVar->setType(theType) || modified;
2508     }
2509   }
2510   if(modified)
2511     Modify();
2512 }
2513
2514 //============================================================================
2515 /*! Function : SetStringVariable
2516  *  Purpose  :
2517  */
2518 //============================================================================
2519 void SALOMEDSImpl_Study::SetStringVariable(const std::string& theVarName,
2520                                            const std::string& theValue,
2521                                            const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2522 {
2523   bool modified = false;
2524   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2525
2526   if( aGVar == NULL ) {
2527
2528     SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName);
2529
2530     aSVar->setStringValue(theValue);
2531     myNoteBookVars.push_back(aSVar);
2532     modified = true;
2533   }
2534   else {
2535     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar)) {
2536       modified = aSVar->setStringValue(theValue) || modified;
2537       modified = aSVar->setType(theType) || modified;
2538     }
2539   }
2540   if(modified)
2541     Modify();
2542 }
2543
2544 //============================================================================
2545 /*! Function : SetStringVariableAsDouble
2546  *  Purpose  :
2547  */
2548 //============================================================================
2549 void SALOMEDSImpl_Study::SetStringVariableAsDouble(const std::string& theVarName,
2550                                                    const double theValue,
2551                                                    const SALOMEDSImpl_GenericVariable::VariableTypes theType)
2552 {
2553   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2554   if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2555     aSVar->setValue(theValue);
2556 }
2557
2558 //============================================================================
2559 /*! Function : GetReal
2560  *  Purpose  :
2561  */
2562 //============================================================================
2563 double SALOMEDSImpl_Study::GetVariableValue(const std::string& theVarName)
2564 {
2565   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2566
2567   if(aGVar != NULL )
2568     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2569       return aSVar->getValue();
2570
2571   return 0;
2572 }
2573
2574 //============================================================================
2575 /*! Function : GetString
2576  *  Purpose  :
2577  */
2578 //============================================================================
2579 std::string SALOMEDSImpl_Study::GetStringVariableValue(const std::string& theVarName)
2580 {
2581   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2582
2583   if(aGVar != NULL )
2584     if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast<SALOMEDSImpl_ScalarVariable*>(aGVar))
2585       return aSVar->getStringValue();
2586
2587   return 0;
2588 }
2589
2590 //============================================================================
2591 /*! Function : IsTypeOf
2592  *  Purpose  :
2593  */
2594 //============================================================================
2595 bool SALOMEDSImpl_Study::IsTypeOf(const std::string& theVarName,
2596                                   SALOMEDSImpl_GenericVariable::
2597                                   VariableTypes theType) const
2598 {
2599   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2600
2601   if(aGVar != NULL )
2602     return aGVar->Type() == theType;
2603
2604   return false;
2605 }
2606
2607 //============================================================================
2608 /*! Function : IsVariable
2609  *  Purpose  :
2610  */
2611 //============================================================================
2612 bool SALOMEDSImpl_Study::IsVariable(const std::string& theVarName) const
2613 {
2614   SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName);
2615   return (aGVar != NULL);
2616 }
2617
2618 //============================================================================
2619 /*! Function : GetVariableNames
2620  *  Purpose  :
2621  */
2622 //============================================================================
2623 std::vector<std::string> SALOMEDSImpl_Study::GetVariableNames() const
2624 {
2625   std::vector<std::string> aResult;
2626
2627   for(int i = 0; i < myNoteBookVars.size(); i++)
2628     aResult.push_back(myNoteBookVars[i]->Name());
2629
2630   return aResult;
2631 }
2632
2633 //============================================================================
2634 /*! Function : AddVariable
2635  *  Purpose  :
2636  */
2637 //============================================================================
2638 void SALOMEDSImpl_Study::AddVariable(SALOMEDSImpl_GenericVariable* theVariable)
2639 {
2640   myNoteBookVars.push_back(theVariable);
2641 }
2642
2643 //============================================================================
2644 /*! Function : AddVariable
2645  *  Purpose  :
2646  */
2647 //============================================================================
2648 SALOMEDSImpl_GenericVariable* SALOMEDSImpl_Study::GetVariable(const std::string& theName) const
2649 {
2650   SALOMEDSImpl_GenericVariable* aResult = NULL;
2651   for(int i = 0; i < myNoteBookVars.size();i++) {
2652     if(theName.compare(myNoteBookVars[i]->Name()) == 0) {
2653       aResult = myNoteBookVars[i];
2654       break;
2655     }
2656   }
2657   return aResult;
2658 }
2659
2660 //============================================================================
2661 /*! Function : RemoveVariable
2662  *  Purpose  :
2663  */
2664 //============================================================================
2665 bool SALOMEDSImpl_Study::RemoveVariable(const std::string& theVarName)
2666 {
2667   SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName );
2668   if( !aVariable )
2669     return false;
2670
2671   std::string aValue = aVariable->SaveToScript();
2672   ReplaceVariableAttribute( theVarName, aValue );
2673
2674   std::vector<SALOMEDSImpl_GenericVariable*>::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end();
2675   for( ; it != itEnd; it++ )
2676   {
2677     SALOMEDSImpl_GenericVariable* aVariableRef = *it;
2678     if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 )
2679     {
2680       myNoteBookVars.erase( it );
2681       Modify();
2682       break;
2683     }
2684   }
2685
2686   return true;
2687 }
2688
2689 //============================================================================
2690 /*! Function : RenameVariable
2691  *  Purpose  :
2692  */
2693 //============================================================================
2694 bool SALOMEDSImpl_Study::RenameVariable(const std::string& theVarName, const std::string& theNewVarName)
2695 {
2696   SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName );
2697   if( !aVariable )
2698     return false;
2699
2700   ReplaceVariableAttribute( theVarName, theNewVarName );
2701
2702   std::vector<SALOMEDSImpl_GenericVariable*>::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end();
2703   for( ; it != itEnd; it++ )
2704   {
2705     SALOMEDSImpl_GenericVariable* aVariableRef = *it;
2706     if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 )
2707     {
2708       aVariableRef->setName( theNewVarName );
2709       Modify();
2710       break;
2711     }
2712   }
2713
2714   return true;
2715 }
2716
2717 //============================================================================
2718 /*! Function : IsVariableUsed
2719  *  Purpose  :
2720  */
2721 //============================================================================
2722 bool SALOMEDSImpl_Study::IsVariableUsed(const std::string& theVarName)
2723 {
2724   return FindVariableAttribute( theVarName );
2725 }
2726
2727 //============================================================================
2728 /*! Function : FindVariableAttribute
2729  *  Purpose  :
2730  */
2731 //============================================================================
2732 bool SALOMEDSImpl_Study::FindVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder,
2733                                                SALOMEDSImpl_SObject theSObject,
2734                                                const std::string& theName)
2735 {
2736   SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject );
2737   for( ; anIter.More(); anIter.Next() )
2738     if( FindVariableAttribute( theStudyBuilder, anIter.Value(), theName ) )
2739       return true;
2740
2741   DF_Attribute* anAttr;
2742   if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) )
2743   {
2744     if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr )
2745     {
2746       std::string aString = aStringAttr->Value();
2747
2748       std::vector< std::vector<std::string> > aSections = ParseVariables( aString );
2749       for( int i = 0, n = aSections.size(); i < n; i++ )
2750       {
2751         std::vector<std::string> aVector = aSections[i];
2752         for( int j = 0, m = aVector.size(); j < m; j++ )
2753         {
2754           std::string aStr = aVector[j];
2755           if( aStr.compare( theName ) == 0 )
2756             return true;
2757         }
2758       }
2759     }
2760   }
2761   return false;
2762 }
2763
2764 //============================================================================
2765 /*! Function : FindVariableAttribute
2766  *  Purpose  :
2767  */
2768 //============================================================================
2769 bool SALOMEDSImpl_Study::FindVariableAttribute(const std::string& theName)
2770 {
2771   SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder();
2772   SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator();
2773   for( ; aCompIter.More(); aCompIter.Next() )
2774   {
2775     SALOMEDSImpl_SObject aComp = aCompIter.Value();
2776     if( FindVariableAttribute( aStudyBuilder, aComp, theName ) )
2777       return true;
2778   }
2779   return false;
2780 }
2781
2782 //============================================================================
2783 /*! Function : ReplaceVariableAttribute
2784  *  Purpose  :
2785  */
2786 //============================================================================
2787 void SALOMEDSImpl_Study::ReplaceVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder,
2788                                                   SALOMEDSImpl_SObject theSObject,
2789                                                   const std::string& theSource,
2790                                                   const std::string& theDest)
2791 {
2792   SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject );
2793   for( ; anIter.More(); anIter.Next() )
2794     ReplaceVariableAttribute( theStudyBuilder, anIter.Value(), theSource, theDest );
2795
2796   DF_Attribute* anAttr;
2797   if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) )
2798   {
2799     if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr )
2800     {
2801       bool isChanged = false;
2802       std::string aNewString, aCurrentString = aStringAttr->Value();
2803
2804       std::vector< std::vector<std::string> > aSections = ParseVariables( aCurrentString );
2805       for( int i = 0, n = aSections.size(); i < n; i++ )
2806       {
2807         std::vector<std::string> aVector = aSections[i];
2808         for( int j = 0, m = aVector.size(); j < m; j++ )
2809         {
2810           std::string aStr = aVector[j];
2811           if( aStr.compare( theSource ) == 0 )
2812           {
2813             isChanged = true;
2814             aStr = theDest;
2815           }
2816
2817           aNewString.append( aStr );
2818           if( j != m - 1 )
2819             aNewString.append( ":" );
2820         }
2821         if( i != n - 1 )
2822           aNewString.append( "|" );
2823       }
2824
2825       if( isChanged )
2826         aStringAttr->SetValue( aNewString );
2827     }
2828   }
2829 }
2830
2831 //============================================================================
2832 /*! Function : ReplaceVariableAttribute
2833  *  Purpose  :
2834  */
2835 //============================================================================
2836 void SALOMEDSImpl_Study::ReplaceVariableAttribute(const std::string& theSource, const std::string& theDest)
2837 {
2838   SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder();
2839   SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator();
2840   for( ; aCompIter.More(); aCompIter.Next() )
2841   {
2842     SALOMEDSImpl_SObject aComp = aCompIter.Value();
2843     ReplaceVariableAttribute( aStudyBuilder, aComp, theSource, theDest );
2844   }
2845 }
2846
2847 //============================================================================
2848 /*! Function : ParseVariables
2849  *  Purpose  :
2850  */
2851 //============================================================================
2852 std::vector< std::vector< std::string > > SALOMEDSImpl_Study::ParseVariables(const std::string& theVariables) const
2853 {
2854   return SALOMEDSImpl_Tool::splitStringWithEmpty( theVariables, OPERATION_SEPARATOR, VARIABLE_SEPARATOR );
2855 }
2856
2857 //============================================================================
2858 /*! Function : EnableUseCaseAutoFilling
2859  *  Purpose  :
2860  */
2861 //============================================================================
2862 void SALOMEDSImpl_Study::EnableUseCaseAutoFilling(bool isEnabled)
2863 {
2864   _errorCode = ""; _autoFill = isEnabled;
2865   if(isEnabled) {
2866     _builder->SetOnAddSObject(_cb);
2867     _builder->SetOnRemoveSObject(_cb);
2868   }
2869   else {
2870     _builder->SetOnAddSObject(NULL);
2871     _builder->SetOnRemoveSObject(NULL);
2872   }
2873 }
2874
2875 //============================================================================
2876 /*! Function : GetIORs
2877  *  Purpose  :
2878  */
2879 //============================================================================
2880 std::vector<std::string> SALOMEDSImpl_Study::GetIORs()
2881 {
2882   std::vector<std::string> anIORs;
2883   std::map<std::string, DF_Label>::const_iterator MI;
2884   for(MI = myIORLabels.begin(); MI!=myIORLabels.end(); MI++)
2885     anIORs.push_back(MI->first);
2886
2887   return anIORs;
2888 }
2889
2890 //============================================================================
2891 /*! Function : addSO_Notification
2892  *  Purpose  : This function tells all the observers that a SO has been added
2893  */
2894 //============================================================================
2895 bool SALOMEDSImpl_Study::addSO_Notification (const SALOMEDSImpl_SObject& theSObject)
2896 {
2897   if(_notifier)
2898     return _notifier->addSO_Notification(theSObject);
2899   else
2900     return false;
2901 }
2902
2903 //============================================================================
2904 /*! Function : removeSO_Notification
2905  *  Purpose  : This function tells all the observers that a SO has been removed
2906  */
2907 //============================================================================
2908 bool SALOMEDSImpl_Study::removeSO_Notification (const SALOMEDSImpl_SObject& theSObject)
2909 {
2910   if(_notifier)
2911     return _notifier->removeSO_Notification(theSObject);
2912   else
2913     return false;
2914 }
2915
2916 //============================================================================
2917 /*! Function : modifySO_Notification
2918  *  Purpose  : This function tells all the observers that a SO has been modified and
2919                pass the mofification reason
2920  */
2921 //============================================================================
2922 bool SALOMEDSImpl_Study::modifySO_Notification (const SALOMEDSImpl_SObject& theSObject, int reason)
2923 {
2924   if(_notifier)
2925     return _notifier->modifySO_Notification(theSObject, reason);
2926   else
2927     return false;
2928 }
2929
2930 //============================================================================
2931 /*! Function : setNotifier
2932  *  Purpose  : register a notifier
2933  */
2934 //============================================================================
2935 void SALOMEDSImpl_Study::setNotifier(SALOMEDSImpl_AbstractCallback* notifier)
2936 {
2937   _notifier=notifier;
2938 }
2939
2940 static SALOMEDSImpl_AbstractCallback* & getGenObjRegister( DF_Document* doc )
2941 {
2942   static std::vector< SALOMEDSImpl_AbstractCallback* > _genObjRegVec;
2943   if ( doc->GetDocumentID() >= (int)_genObjRegVec.size() )
2944     _genObjRegVec.resize( doc->GetDocumentID() + 1, 0 );
2945   return _genObjRegVec[ doc->GetDocumentID() ];
2946 }
2947
2948 //================================================================================
2949 /*!
2950  * \brief Stores theRegister
2951  */
2952 //================================================================================
2953
2954 void SALOMEDSImpl_Study::setGenObjRegister(SALOMEDSImpl_AbstractCallback* theRegister)
2955 {
2956   getGenObjRegister( _doc ) = theRegister;
2957 }
2958
2959 //================================================================================
2960 /*!
2961  * \brief Indirectly invokes GenericObj_i::Register()
2962  */
2963 //================================================================================
2964
2965 void SALOMEDSImpl_Study::RegisterGenObj  (const std::string& theIOR, DF_Label label)
2966 {
2967   if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() ))
2968     goRegister->RegisterGenObj( theIOR );
2969 }
2970
2971 //================================================================================
2972 /*!
2973  * \brief Indirectly invokes GenericObj_i::UnRegister()
2974  */
2975 //================================================================================
2976
2977 void SALOMEDSImpl_Study::UnRegisterGenObj(const std::string& theIOR, DF_Label label)
2978 {
2979   if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() ))
2980     goRegister->UnRegisterGenObj( theIOR );
2981 }
2982
2983 //#######################################################################################################
2984 //#                                     STATIC PRIVATE FUNCTIONS
2985 //#######################################################################################################
2986
2987 //============================================================================
2988 /*! Function : SaveAttributes
2989  *  Purpose  : Save attributes for object
2990  */
2991 //============================================================================
2992 static void SaveAttributes(const SALOMEDSImpl_SObject& aSO, HDFgroup *hdf_group_sobject)
2993 {
2994   hdf_size size[1];
2995   std::vector<DF_Attribute*> attrList = aSO.GetLabel().GetAttributes();
2996   DF_Attribute* anAttr = NULL;
2997   for(int i = 0, len = attrList.size(); i<len; i++) {
2998     anAttr = attrList[i];
2999     //The following attributes are not supposed to be written to the file
3000     std::string type = SALOMEDSImpl_GenericAttribute::Impl_GetType(anAttr);
3001     if(type == std::string("AttributeIOR")) continue; //IOR attribute is not saved
3002     std::string aSaveStr =anAttr->Save();
3003     //cout << "Saving: " << aSO.GetID() << " type: "<< type<<"|" << endl;
3004     size[0] = (hdf_int32) strlen(aSaveStr.c_str()) + 1;
3005     HDFdataset *hdf_dataset = new HDFdataset((char*)type.c_str(), hdf_group_sobject, HDF_STRING,size, 1);
3006     hdf_dataset->CreateOnDisk();
3007     hdf_dataset->WriteOnDisk((char*)aSaveStr.c_str());
3008     hdf_dataset->CloseOnDisk();
3009     hdf_dataset=0; //will be deleted by hdf_sco_group destructor
3010   }
3011 }
3012
3013 //===========================================================================
3014 //Function : ReadAttributes
3015 //===========================================================================
3016 static void ReadAttributes(SALOMEDSImpl_Study* theStudy,
3017                            const SALOMEDSImpl_SObject& aSO,
3018                            HDFdataset* hdf_dataset)
3019 {
3020   hdf_dataset->OpenOnDisk();
3021
3022   DF_Attribute* anAttr = NULL;
3023   char* current_string = new char[hdf_dataset->GetSize()+1];
3024   hdf_dataset->ReadFromDisk(current_string);
3025   //cout << "Reading attr type = " << hdf_dataset->GetName() << "  SO = " << aSO.GetID() << endl;
3026   if (!strcmp(hdf_dataset->GetName(),"COMPONENTDATATYPE")) {
3027     anAttr = theStudy->NewBuilder()->FindOrCreateAttribute(aSO, "AttributeComment");
3028   }
3029   else if (!strcmp(hdf_dataset->GetName(),"AttributeReference") ||
3030            !strcmp(hdf_dataset->GetName(),"Reference")) { // Old format maintainance
3031     theStudy->NewBuilder()->Addreference(aSO, theStudy->CreateObjectID(current_string));
3032     delete [] (current_string);
3033     hdf_dataset->CloseOnDisk();
3034     return;
3035   }
3036   else {
3037     anAttr = theStudy->NewBuilder()->FindOrCreateAttribute(aSO, hdf_dataset->GetName());
3038   }
3039
3040   if (anAttr) {
3041     anAttr->Load(current_string);
3042   }
3043
3044   delete [] (current_string);
3045   hdf_dataset->CloseOnDisk();
3046 }
3047
3048 //============================================================================
3049 //Function : BuildlTree
3050 //============================================================================
3051 static void BuildTree (SALOMEDSImpl_Study* theStudy, HDFgroup* hdf_current_group)
3052 {
3053   hdf_current_group->OpenOnDisk();
3054   SALOMEDSImpl_SObject aSO;
3055   char* Entry = hdf_current_group->GetName();
3056   if (strcmp(Entry,"STUDY_STRUCTURE") == 0) {
3057     aSO = theStudy->CreateObjectID("0:1");
3058   }
3059   else {
3060     aSO = theStudy->CreateObjectID(Entry);
3061   }
3062
3063   char name[HDF_NAME_MAX_LEN+1];
3064   int nbsons = hdf_current_group->nInternalObjects();
3065   for (int i=0; i<nbsons; i++) {
3066     hdf_current_group->InternalObjectIndentify(i,name);
3067     if (strncmp(name, "INTERNAL_COMPLEX",16) == 0) continue;
3068     hdf_object_type type = hdf_current_group->InternalObjectType(name);
3069
3070     if (type == HDF_DATASET) {
3071       HDFdataset* new_dataset = new HDFdataset(name,hdf_current_group);
3072       ReadAttributes(theStudy,aSO,new_dataset);
3073       new_dataset = 0; // will be deleted by father destructor
3074     }
3075     else if (type == HDF_GROUP)   {
3076       HDFgroup* new_group = new HDFgroup(name,hdf_current_group);
3077       BuildTree (theStudy, new_group);
3078       new_group = 0; // will be deleted by father destructor
3079     }
3080   }
3081   hdf_current_group->CloseOnDisk();
3082 }
3083
3084
3085 //============================================================================
3086 //Function : Translate_IOR_to_persistentID
3087 //============================================================================
3088 static void Translate_IOR_to_persistentID (const SALOMEDSImpl_SObject& so,
3089                                            SALOMEDSImpl_Driver*        engine,
3090                                            bool                        isMultiFile,
3091                                            bool                        isASCII)
3092 {
3093   DF_ChildIterator itchild(so.GetLabel());
3094   std::string ior_string,  persistent_string, curid;
3095
3096   for (; itchild.More(); itchild.Next()) {
3097     SALOMEDSImpl_SObject current = SALOMEDSImpl_Study::SObject(itchild.Value());
3098     SALOMEDSImpl_AttributeIOR* IOR = NULL;
3099     if ((IOR=(SALOMEDSImpl_AttributeIOR*)current.GetLabel().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID()))) {
3100       ior_string = IOR->Value();
3101
3102       persistent_string = engine->IORToLocalPersistentID (current, ior_string, isMultiFile, isASCII);
3103       SALOMEDSImpl_AttributePersistentRef::Set(current.GetLabel(), persistent_string);
3104     }
3105     Translate_IOR_to_persistentID (current, engine, isMultiFile, isASCII);
3106   }
3107 }
3108
3109 void ReadNoteBookVariables(SALOMEDSImpl_Study* theStudy, HDFgroup* theGroup)
3110 {
3111   if(!theGroup)
3112     return;
3113
3114   HDFgroup* new_group =0;
3115   HDFdataset* new_dataset =0;
3116
3117   char aVarName[HDF_NAME_MAX_LEN+1];
3118   char *currentVarType = 0;
3119   char *currentVarValue = 0;
3120   char *currentVarIndex = 0;
3121   int order = 0;
3122   //Open HDF group with notebook variables
3123   theGroup->OpenOnDisk();
3124
3125   //Get Nb of variables
3126   int aNbVars = theGroup->nInternalObjects();
3127
3128   std::map<int,SALOMEDSImpl_GenericVariable*> aVarsMap;
3129
3130   for( int iVar=0;iVar < aNbVars;iVar++ ) {
3131     theGroup->InternalObjectIndentify(iVar,aVarName);
3132     hdf_object_type type = theGroup->InternalObjectType(aVarName);
3133     if(type == HDF_GROUP) {
3134
3135       //Read Variable
3136       new_group = new HDFgroup(aVarName,theGroup);
3137       new_group->OpenOnDisk();
3138
3139       //Read Type
3140       new_dataset = new HDFdataset("VARIABLE_TYPE",new_group);
3141       new_dataset->OpenOnDisk();
3142       currentVarType = new char[new_dataset->GetSize()+1];
3143       new_dataset->ReadFromDisk(currentVarType);
3144       new_dataset->CloseOnDisk();
3145       new_dataset = 0; //will be deleted by hdf_sco_group destructor
3146
3147       //Read Order
3148       if(new_group->ExistInternalObject("VARIABLE_INDEX")) {
3149         new_dataset = new HDFdataset("VARIABLE_INDEX",new_group);
3150         new_dataset->OpenOnDisk();
3151         currentVarIndex = new char[new_dataset->GetSize()+1];
3152         new_dataset->ReadFromDisk(currentVarIndex);
3153         new_dataset->CloseOnDisk();
3154         new_dataset = 0; //will be deleted by hdf_sco_group destructor
3155         order = atoi(currentVarIndex);
3156         delete [] currentVarIndex;
3157       }
3158       else
3159         order = iVar;
3160
3161       //Read Value
3162       new_dataset = new HDFdataset("VARIABLE_VALUE",new_group);
3163       new_dataset->OpenOnDisk();
3164       currentVarValue = new char[new_dataset->GetSize()+1];
3165       new_dataset->ReadFromDisk(currentVarValue);
3166       new_dataset->CloseOnDisk();
3167       new_dataset = 0; //will be deleted by hdf_sco_group destructor
3168
3169       new_group->CloseOnDisk();
3170       new_group = 0;  //will be deleted by hdf_sco_group destructor
3171
3172       SALOMEDSImpl_GenericVariable::VariableTypes aVarType =
3173         SALOMEDSImpl_GenericVariable::String2VariableType(std::string(currentVarType));
3174       delete [] currentVarType;
3175
3176       //Create variable and add it in the study
3177       SALOMEDSImpl_GenericVariable* aVariable =
3178         new SALOMEDSImpl_ScalarVariable(aVarType,std::string(aVarName));
3179       aVariable->Load(std::string(currentVarValue));
3180       aVarsMap.insert(std::make_pair(order,aVariable));
3181       delete [] currentVarValue;
3182     }
3183   }
3184
3185   std::map<int,SALOMEDSImpl_GenericVariable*>::const_iterator it= aVarsMap.begin();
3186   for(;it!=aVarsMap.end();it++)
3187     theStudy->AddVariable((*it).second);
3188
3189   theGroup->CloseOnDisk();
3190 }
3191