src/ModelHighAPI/ModelHighAPI_Dumper.cpp

   1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "ModelHighAPI_Dumper.h"
  21
  22 #include <Config_PropManager.h>
  23
  24 #include <GeomAPI_Pnt.h>
  25 #include <GeomAPI_Dir.h>
  26 #include <GeomAPI_ShapeExplorer.h>
  27 #include <GeomAPI_ShapeIterator.h>
  28 #include <GeomAlgoAPI_NExplode.h>
  29
  30 #include <GeomDataAPI_Dir.h>
  31 #include <GeomDataAPI_Point.h>
  32 #include <GeomDataAPI_Point2D.h>
  33
  34 #include <ModelAPI_AttributeBoolean.h>
  35 #include <ModelAPI_AttributeDouble.h>
  36 #include <ModelAPI_AttributeIntArray.h>
  37 #include <ModelAPI_AttributeInteger.h>
  38 #include <ModelAPI_AttributeRefAttr.h>
  39 #include <ModelAPI_AttributeRefAttrList.h>
  40 #include <ModelAPI_AttributeReference.h>
  41 #include <ModelAPI_AttributeRefList.h>
  42 #include <ModelAPI_AttributeSelection.h>
  43 #include <ModelAPI_AttributeSelectionList.h>
  44 #include <ModelAPI_AttributeString.h>
  45 #include <ModelAPI_AttributeStringArray.h>
  46 #include <ModelAPI_CompositeFeature.h>
  47 #include <ModelAPI_Document.h>
  48 #include <ModelAPI_Entity.h>
  49 #include <ModelAPI_Feature.h>
  50 #include <ModelAPI_FiltersFeature.h>
  51 #include <ModelAPI_Folder.h>
  52 #include <ModelAPI_Result.h>
  53 #include <ModelAPI_ResultBody.h>
  54 #include <ModelAPI_ResultConstruction.h>
  55 #include <ModelAPI_ResultGroup.h>
  56 #include <ModelAPI_ResultPart.h>
  57 #include <ModelAPI_Session.h>
  58 #include <ModelAPI_Tools.h>
  59
  60 #include <ModelGeomAlgo_Shape.h>
  61
  62 #include <PartSetPlugin_Part.h>
  63
  64 #include <OSD_OpenFile.hxx>
  65
  66 #include <fstream>
  67
  68 // ===========    Implementation of storage of dumped data    ===========
  69 static const int THE_DUMP_PRECISION = 16;
  70
  71 class ModelHighAPI_Dumper::DumpStorageBuffer : public ModelHighAPI_Dumper::DumpStorage
  72 {
  73 public:
  74   void addStorage(const ModelHighAPI_Dumper::DumpStoragePtr& theStorage)
  75   { myStorageArray.push_back(theStorage); }
  76
  77   void clear() { myStorageArray.clear(); }
  78
  79   bool isBufferEmpty()
  80   {
  81     return myStorageArray.empty() || myStorageArray.front()->buffer().str().empty();
  82   }
  83
  84   void mergeBuffer()
  85   {
  86     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
  87     for (; anIt != myStorageArray.end(); ++anIt) {
  88       // avoid multiple empty lines
  89       std::string aBuf = (*anIt)->buffer().str();
  90       size_t anInd = std::string::npos;
  91       while ((anInd = aBuf.find("\n\n\n")) != std::string::npos)
  92         aBuf.erase(anInd, 1);
  93
  94       (*anIt)->fullDump() << aBuf;
  95       (*anIt)->buffer().str("");
  96     }
  97   }
  98
  99   void write(const std::string& theValue)
 100   {
 101     if (myStorageArray.empty())
 102       addStorage(DumpStoragePtr(new DumpStorage));
 103
 104     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
 105     for (; anIt != myStorageArray.end(); ++anIt)
 106       (*anIt)->buffer() << theValue;
 107   }
 108
 109   DumpStorageBuffer& operator<<(const char theChar)
 110   {
 111     std::ostringstream out;
 112     out << theChar;
 113     write(out.str());
 114     return *this;
 115   }
 116
 117   DumpStorageBuffer& operator<<(const char* theString)
 118   {
 119     write(theString);
 120     return *this;
 121   }
 122
 123   DumpStorageBuffer& operator<<(const std::string& theString)
 124   {
 125     write(theString);
 126     return *this;
 127   }
 128
 129   DumpStorageBuffer& operator<<(const bool theValue)
 130   {
 131     std::ostringstream out;
 132     out << theValue;
 133     write(out.str());
 134     return *this;
 135   }
 136
 137   DumpStorageBuffer& operator<<(const int theValue)
 138   {
 139     std::ostringstream out;
 140     out << theValue;
 141     write(out.str());
 142     return *this;
 143   }
 144
 145   DumpStorageBuffer& operator<<(const double theValue)
 146   {
 147     std::ostringstream out;
 148     out << std::setprecision(THE_DUMP_PRECISION) << theValue;
 149     write(out.str());
 150     return *this;
 151   }
 152   /// Dump std::endl
 153   friend
 154   DumpStorageBuffer& operator<<(DumpStorageBuffer& theBuffer,
 155                                 std::basic_ostream<char>& (*theEndl)(std::basic_ostream<char>&))
 156   {
 157     theBuffer.write("\n");
 158     return theBuffer;
 159   }
 160
 161   void dumpArray(int theSize, double* theValues, std::string* theTexts)
 162   {
 163     std::ostringstream anOutput;
 164     anOutput << std::setprecision(THE_DUMP_PRECISION);
 165     for (int i = 0; i < theSize; ++i) {
 166       if (i > 0)
 167         anOutput << ", ";
 168       if (theTexts[i].empty())
 169         anOutput << theValues[i];
 170       else
 171         anOutput << "\"" << theTexts[i] << "\"";
 172     }
 173     write(anOutput.str());
 174   }
 175
 176   virtual void write(const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect)
 177   {
 178     if (myStorageArray.empty())
 179       addStorage(DumpStoragePtr(new DumpStorage));
 180
 181     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
 182     for (; anIt != myStorageArray.end(); ++anIt)
 183       (*anIt)->write(theAttrSelect);
 184   }
 185
 186   virtual void reserveBuffer()
 187   {
 188     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
 189     for (; anIt != myStorageArray.end(); ++anIt)
 190       (*anIt)->reserveBuffer();
 191   }
 192
 193   virtual void restoreReservedBuffer()
 194   {
 195     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
 196     for (; anIt != myStorageArray.end(); ++anIt)
 197       (*anIt)->restoreReservedBuffer();
 198   }
 199
 200   virtual bool exportTo(const std::string& theFilename, const ModulesSet& theUsedModules)
 201   {
 202     static const std::string THE_EXT = ".py";
 203     std::string aFilenameBase = theFilename;
 204     if (aFilenameBase.rfind(THE_EXT) == aFilenameBase.size() - THE_EXT.size())
 205       aFilenameBase = aFilenameBase.substr(0, aFilenameBase.size() - THE_EXT.size());
 206
 207     bool isOk = true;
 208     std::list<ModelHighAPI_Dumper::DumpStoragePtr>::iterator anIt = myStorageArray.begin();
 209     for (; anIt != myStorageArray.end(); ++anIt) {
 210       std::string aFilename = aFilenameBase + (*anIt)->myFilenameSuffix + THE_EXT;
 211       isOk = (*anIt)->exportTo(aFilename, theUsedModules) && isOk;
 212     }
 213     return isOk;
 214   }
 215
 216 private:
 217   std::list<ModelHighAPI_Dumper::DumpStoragePtr> myStorageArray;
 218 };
 219
 220
 221 ModelHighAPI_Dumper::DumpStorage::DumpStorage(const DumpStorage& theOther)
 222   : myFilenameSuffix(theOther.myFilenameSuffix),
 223     myDumpBufferHideout(theOther.myDumpBufferHideout)
 224 {
 225   myFullDump.str(theOther.myFullDump.str());
 226   myDumpBuffer.str(theOther.myDumpBuffer.str());
 227 }
 228
 229 const ModelHighAPI_Dumper::DumpStorage&
 230 ModelHighAPI_Dumper::DumpStorage::operator=(const ModelHighAPI_Dumper::DumpStorage& theOther)
 231 {
 232   myFilenameSuffix = theOther.myFilenameSuffix;
 233   myFullDump.str(theOther.myFullDump.str());
 234   myDumpBuffer.str(theOther.myDumpBuffer.str());
 235   myDumpBufferHideout = theOther.myDumpBufferHideout;
 236   return *this;
 237 }
 238
 239 void ModelHighAPI_Dumper::DumpStorage::reserveBuffer()
 240 {
 241   myDumpBufferHideout.push(myDumpBuffer.str());
 242   myDumpBuffer.str("");
 243 }
 244
 245 void ModelHighAPI_Dumper::DumpStorage::restoreReservedBuffer()
 246 {
 247   myDumpBuffer << myDumpBufferHideout.top();
 248   myDumpBufferHideout.pop();
 249 }
 250
 251 bool ModelHighAPI_Dumper::DumpStorage::exportTo(const std::string& theFilename,
 252                                                 const ModulesSet& theUsedModules)
 253 {
 254   std::ofstream aFile;
 255   OSD_OpenStream(aFile, theFilename.c_str(), std::ofstream::out);
 256   if (!aFile.is_open())
 257     return false;
 258
 259   // standard header imported modules
 260   for (ModulesSet::const_iterator aModIt = theUsedModules.begin();
 261     aModIt != theUsedModules.end(); ++aModIt) {
 262     aFile << "from " << *aModIt << " import *" << std::endl;
 263   }
 264   if (!theUsedModules.empty())
 265     aFile << std::endl;
 266
 267   aFile << "from salome.shaper import model" << std::endl << std::endl;
 268   aFile << "model.begin()" << std::endl;
 269
 270   // dump collected data
 271   aFile << myFullDump.str();
 272   aFile << myDumpBuffer.str();
 273
 274   // standard footer
 275   aFile << "model.end()" << std::endl;
 276   aFile.close();
 277
 278   return true;
 279 }
 280
 281 static void getShapeAndContext(const AttributeSelectionPtr& theAttrSelect,
 282                                GeomShapePtr& theShape, ResultPtr& theContext)
 283 {
 284   if (theAttrSelect->isInitialized()) {
 285     theShape = theAttrSelect->value();
 286     theContext = theAttrSelect->context();
 287     if (!theShape.get())
 288       theShape = theContext->shape();
 289
 290     if (theAttrSelect->isGeometricalSelection() &&
 291         theShape.get() && theShape->shapeType() == GeomAPI_Shape::COMPOUND &&
 292         theContext.get() && !theShape->isEqual(theContext->shape()) &&
 293         theContext->groupName() != ModelAPI_ResultPart::group() &&
 294         theContext->groupName() != ModelAPI_ResultGroup::group()) {
 295       GeomAPI_ShapeIterator anIt(theShape);
 296       theShape = anIt.current();
 297     }
 298   }
 299 }
 300
 301 void ModelHighAPI_Dumper::DumpStorage::write(const AttributeSelectionPtr& theAttrSelect)
 302 {
 303   myDumpBuffer << "model.selection(";
 304
 305   GeomShapePtr aShape;
 306   ResultPtr aContext;
 307   getShapeAndContext(theAttrSelect, aShape, aContext);
 308
 309   if (aShape.get()) {
 310     myDumpBuffer << "\"" << aShape->shapeTypeStr() << "\", \""
 311                  << theAttrSelect->namingName() << "\"";
 312   }
 313
 314   myDumpBuffer << ")";
 315 }
 316
 317 static int possibleSelectionsByPoint(const GeomPointPtr& thePoint,
 318                                      const ResultPtr& theResult,
 319                                      const GeomShapePtr& theShape,
 320                                      const FeaturePtr& theStartFeature,
 321                                      const FeaturePtr& theEndFeature)
 322 {
 323   DocumentPtr aDoc1 = theStartFeature->document();
 324   DocumentPtr aDoc2 = theEndFeature->document();
 325
 326   std::list<FeaturePtr> aFeatures = aDoc1->allFeatures();
 327   if (aDoc1 != aDoc2) {
 328     std::list<FeaturePtr> anAdditionalFeatures = aDoc2->allFeatures();
 329     aFeatures.insert(aFeatures.end(), anAdditionalFeatures.begin(), anAdditionalFeatures.end());
 330   }
 331
 332   CompositeFeaturePtr aLastCompositeFeature;
 333
 334   std::list<FeaturePtr>::const_iterator aFIt = aFeatures.begin();
 335   while (aFIt != aFeatures.end() && *aFIt != theStartFeature) {
 336     CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aFIt);
 337     if (aCompFeat)
 338       aLastCompositeFeature = aCompFeat;
 339     ++aFIt;
 340   }
 341
 342   // collect the list of composite features, containing the last feature;
 343   // these features should be excluded from searching,
 344   // because the feature cannot select sub-shapes from its parent
 345   std::set<FeaturePtr> aEndFeatureParents = ModelAPI_Tools::getParents(theEndFeature);
 346
 347   int aNbPossibleSelections = 0;
 348   for (; aFIt != aFeatures.end() && *aFIt != theEndFeature; ++aFIt) {
 349     bool isSkipFeature = false;
 350     if (aLastCompositeFeature && aLastCompositeFeature->isSub(*aFIt))
 351       isSkipFeature = true;
 352     CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*aFIt);
 353     if (aCompFeat) {
 354       ResultPartPtr aPartRes =
 355           std::dynamic_pointer_cast<ModelAPI_ResultPart>(aCompFeat->firstResult());
 356       if (!aPartRes)
 357         aLastCompositeFeature = aCompFeat;
 358       if (aEndFeatureParents.find(aCompFeat) != aEndFeatureParents.end()) {
 359         // do not process the parent for the last feature,
 360         // because it cannot select objects from its parent
 361         isSkipFeature = true;
 362       }
 363     }
 364     if (isSkipFeature)
 365       continue;
 366
 367     std::list<ModelGeomAlgo_Shape::SubshapeOfResult> anApproproate;
 368     if (ModelGeomAlgo_Shape::findSubshapeByPoint(*aFIt, thePoint, theShape->shapeType(),
 369                                                  anApproproate)) {
 370       std::list<ModelGeomAlgo_Shape::SubshapeOfResult>::iterator anApIt = anApproproate.begin();
 371       for (; anApIt != anApproproate.end(); ++anApIt) {
 372         ++aNbPossibleSelections;
 373
 374         // stop if the target shape and result are found
 375         GeomShapePtr aCurShape = anApIt->mySubshape;
 376         if (!aCurShape)
 377           aCurShape = anApIt->myResult->shape();
 378
 379         if (anApIt->myResult->isSame(theResult) && aCurShape->isSame(theShape))
 380           break;
 381       }
 382     }
 383   }
 384   return aNbPossibleSelections;
 385 }
 386
 387 void ModelHighAPI_Dumper::DumpStorageGeom::write(const AttributeSelectionPtr& theAttrSelect)
 388 {
 389   GeomShapePtr aShape;
 390   ResultPtr aContext;
 391   getShapeAndContext(theAttrSelect, aShape, aContext);
 392
 393   // how to dump selection: construction features are dumped by name always
 394   FeaturePtr aSelectedFeature;
 395   FeaturePtr aFeature = theAttrSelect->contextFeature();
 396   if (aShape && aContext && !aFeature)
 397     aSelectedFeature = ModelAPI_Feature::feature(aContext->data()->owner());
 398   bool isDumpByGeom = aSelectedFeature && aSelectedFeature->isInHistory();
 399
 400   if (isDumpByGeom) {
 401     myDumpBuffer << "model.selection(\"" << aShape->shapeTypeStr();
 402     // check the selected item is a ResultPart;
 403     // in this case it is necessary to get shape with full transformation
 404     // for correct calculation of the middle point
 405     ResultPartPtr aResPart =
 406       std::dynamic_pointer_cast<ModelAPI_ResultPart>(theAttrSelect->context());
 407     if (aResPart && aShape->shapeType() == GeomAPI_Shape::COMPOUND)
 408       aShape = aResPart->shape();
 409     GeomPointPtr aMiddlePoint = aShape->middlePoint();
 410     // calculate number of features, which could be selected by the same point
 411     FeaturePtr anOwner = ModelAPI_Feature::feature(theAttrSelect->owner());
 412     int aNbPossibleSelections = possibleSelectionsByPoint(aMiddlePoint,
 413         theAttrSelect->context(), aShape, aSelectedFeature, anOwner);
 414
 415     // produce the index if the number of applicable features is greater than 1
 416     std::string anIndex;
 417     if (aNbPossibleSelections > 1) {
 418       std::ostringstream anOutput;
 419       anOutput << "_" << aNbPossibleSelections;
 420       anIndex = anOutput.str();
 421     }
 422
 423     myDumpBuffer << std::setprecision(THE_DUMP_PRECISION)
 424                  << anIndex << "\", ("
 425                  << aMiddlePoint->x() << ", "
 426                  << aMiddlePoint->y() << ", "
 427                  << aMiddlePoint->z() << ")";
 428     myDumpBuffer << ")";
 429   }
 430   else
 431     DumpStorage::write(theAttrSelect);
 432 }
 433
 434 void ModelHighAPI_Dumper::DumpStorageWeak::write(const AttributeSelectionPtr& theAttrSelect)
 435 {
 436   GeomShapePtr aShape;
 437   ResultPtr aContext;
 438   getShapeAndContext(theAttrSelect, aShape, aContext);
 439
 440   bool aStandardDump = true;
 441   if (aShape.get() && aContext.get() &&
 442       aShape != aContext->shape()) { // weak naming for local selection only
 443     GeomAlgoAPI_NExplode aNExplode(aContext->shape(), aShape->shapeType());
 444     int anIndex = aNExplode.index(aShape);
 445     if (anIndex != 0) { // found a week-naming index, so, export it
 446       myDumpBuffer << "model.selection(\"" << aShape->shapeTypeStr() << "\", \""
 447                    << theAttrSelect->contextName(aContext) << "\", " << anIndex << ")";
 448       aStandardDump = false;
 449     }
 450   }
 451   if (aStandardDump)
 452     DumpStorage::write(theAttrSelect);
 453 }
 454 // ======================================================================
 455
 456
 457 static int gCompositeStackDepth = 0;
 458
 459 ModelHighAPI_Dumper* ModelHighAPI_Dumper::mySelf = 0;
 460
 461 ModelHighAPI_Dumper::ModelHighAPI_Dumper()
 462   : myDumpStorage(new DumpStorageBuffer),
 463     myDumpPostponedInProgress(false)
 464 {
 465 }
 466
 467 ModelHighAPI_Dumper::~ModelHighAPI_Dumper()
 468 {
 469   delete myDumpStorage;
 470 }
 471
 472 void ModelHighAPI_Dumper::setInstance(ModelHighAPI_Dumper* theDumper)
 473 {
 474   if (mySelf == 0)
 475     mySelf = theDumper;
 476 }
 477
 478 ModelHighAPI_Dumper* ModelHighAPI_Dumper::getInstance()
 479 {
 480   return mySelf;
 481 }
 482
 483 void ModelHighAPI_Dumper::addCustomStorage(const ModelHighAPI_Dumper::DumpStoragePtr& theStorage)
 484 {
 485   myDumpStorage->addStorage(theStorage);
 486 }
 487
 488 void ModelHighAPI_Dumper::clearCustomStorage()
 489 {
 490   myDumpStorage->clear();
 491
 492   myNames.clear();
 493   myModules.clear();
 494   myFeatureCount.clear();
 495   myPostponed.clear();
 496   while (!myEntitiesStack.empty())
 497     myEntitiesStack.pop();
 498   clearNotDumped();
 499 }
 500
 501 void ModelHighAPI_Dumper::clearNotDumped()
 502 {
 503   myNotDumpedEntities.clear();
 504 }
 505
 506 // Convert string to integer. If the string is not a number, return -1
 507 static int toInt(const std::string& theString)
 508 {
 509   std::string::const_iterator aChar = theString.begin();
 510   for (; aChar != theString.end(); ++aChar)
 511     if (!std::isdigit(*aChar))
 512       break;
 513   if (aChar != theString.end())
 514     return -1; // not a number
 515   return std::stoi(theString);
 516 }
 517
 518 const std::string& ModelHighAPI_Dumper::name(const EntityPtr& theEntity,
 519                                              bool theSaveNotDumped,
 520                                              bool theUseEntityName)
 521 {
 522   EntityNameMap::const_iterator aFound = myNames.find(theEntity);
 523   if (aFound != myNames.end())
 524     return aFound->second.myCurrentName;
 525
 526   // entity is not found, store it
 527   std::string aName, aKind;
 528   bool isDefaultName = false;
 529   bool isSaveNotDumped = theSaveNotDumped;
 530   std::ostringstream aDefaultName;
 531   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theEntity);
 532   if (aFeature) {
 533     aName = aFeature->name();
 534     aKind = aFeature->getKind();
 535   } else {
 536     FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(theEntity);
 537     if (aFolder) {
 538       aName = aFolder->data()->name();
 539       aKind = ModelAPI_Folder::ID();
 540       isSaveNotDumped = false;
 541     }
 542   }
 543
 544   ObjectPtr anObject = std::dynamic_pointer_cast<ModelAPI_Object>(theEntity);
 545   if (anObject) {
 546     DocumentPtr aDoc = anObject->document();
 547     std::pair<int, int>& aNbFeatures = myFeatureCount[aDoc][aKind];
 548     aNbFeatures.first += 1;
 549
 550     size_t anIndex = aName.find(aKind);
 551     if (anIndex == 0 && aName[aKind.length()] == '_') { // name starts with "FeatureKind_"
 552       std::string anIdStr = aName.substr(aKind.length() + 1);
 553       int anId = toInt(anIdStr);
 554
 555       // Check number of already registered objects of such kind. Index of current object
 556       // should be the same to identify feature's name as automatically generated.
 557       if (aNbFeatures.first == anId && aNbFeatures.second < anId) {
 558         // name is not user-defined
 559         isDefaultName = true;
 560
 561         // check there are postponed features of this kind,
 562         // dump their names, because the sequence of features may be changed
 563         for (std::list<EntityPtr>::const_iterator aPpIt = myPostponed.begin();
 564             aPpIt != myPostponed.end(); ++aPpIt) {
 565           FeaturePtr aCurFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*aPpIt);
 566           if (aCurFeature && aCurFeature->getKind() == aKind) {
 567             myNames[*aPpIt].myIsDefault = false;
 568             isDefaultName = false;
 569           }
 570         }
 571       }
 572
 573       if (anId > aNbFeatures.second)
 574         aNbFeatures.second = anId;
 575     }
 576
 577     // obtain default name for the feature
 578     if (theUseEntityName)
 579       aDefaultName << aName;
 580     else {
 581       int aFullIndex = 0;
 582       NbFeaturesMap::const_iterator aFIt = myFeatureCount.begin();
 583       for (; aFIt != myFeatureCount.end(); ++aFIt) {
 584         std::map<std::string, std::pair<int, int> >::const_iterator aFound =
 585           aFIt->second.find(aKind);
 586         if (aFound != aFIt->second.end())
 587           aFullIndex += aFound->second.first;
 588       }
 589       aDefaultName << aKind << "_" << aFullIndex;
 590     }
 591   }
 592
 593   myNames[theEntity] = EntityName(aDefaultName.str(), aName, isDefaultName);
 594   if (isSaveNotDumped)
 595     myNotDumpedEntities.insert(theEntity);
 596
 597   // store names of results
 598   if (aFeature)
 599     saveResultNames(aFeature);
 600
 601   return myNames[theEntity].myCurrentName;
 602 }
 603
 604 const std::string& ModelHighAPI_Dumper::parentName(const FeaturePtr& theEntity)
 605 {
 606   const std::set<AttributePtr>& aRefs = theEntity->data()->refsToMe();
 607   std::set<AttributePtr>::const_iterator aRefIt = aRefs.begin();
 608   for (; aRefIt != aRefs.end(); ++aRefIt) {
 609     CompositeFeaturePtr anOwner = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(
 610         ModelAPI_Feature::feature((*aRefIt)->owner()));
 611     if (anOwner)
 612       return name(anOwner);
 613   }
 614
 615   static const std::string DUMMY;
 616   return DUMMY;
 617 }
 618
 619 void ModelHighAPI_Dumper::saveResultNames(const FeaturePtr& theFeature)
 620 {
 621   // Default name of the feature
 622   bool isFeatureDefaultName = myNames[theFeature].myIsDefault;
 623
 624   // Save only names of results which is not correspond to default feature name
 625   const std::list<ResultPtr>& aResults = theFeature->results();
 626   std::list<ResultPtr> allRes;
 627   ModelAPI_Tools::allResults(theFeature, allRes);
 628   for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
 629     std::pair<std::string, bool> aName = ModelAPI_Tools::getDefaultName(*aRes);
 630     std::string aDefaultName = aName.first;
 631     std::string aResName = (*aRes)->data()->name();
 632     bool isUserDefined = !(isFeatureDefaultName && aDefaultName == aResName);
 633     myNames[*aRes] =
 634       EntityName(aResName, (isUserDefined ? aResName : std::string()), !isUserDefined);
 635   }
 636 }
 637
 638 bool ModelHighAPI_Dumper::process(const std::shared_ptr<ModelAPI_Document>& theDoc,
 639                                   const std::string& theFileName)
 640 {
 641   // dump top level document feature
 642   static const std::string aDocName("partSet");
 643   myNames[theDoc] = EntityName(aDocName, std::string(), true);
 644   *this << aDocName << " = model.moduleDocument()" << std::endl;
 645
 646   // dump subfeatures and store result to file
 647   bool isOk = process(theDoc) && myDumpStorage->exportTo(theFileName, myModules);
 648   clearCustomStorage();
 649   return isOk;
 650 }
 651
 652 bool ModelHighAPI_Dumper::process(const std::shared_ptr<ModelAPI_Document>& theDoc)
 653 {
 654   bool isOk = true;
 655   std::list<ObjectPtr> anObjects = theDoc->allObjects();
 656   std::list<ObjectPtr>::const_iterator anObjIt = anObjects.begin();
 657   // firstly, dump all parameters
 658   for (; anObjIt != anObjects.end(); ++ anObjIt) {
 659     FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIt);
 660     if (aFeature)
 661       dumpParameter(aFeature);
 662   }
 663   // dump all other features
 664   for (anObjIt = anObjects.begin(); anObjIt != anObjects.end(); ++anObjIt) {
 665     CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*anObjIt);
 666     if (aCompFeat) {
 667       // iteratively process composite features,
 668       // if the composite feature is the last in the document, no need to dump "model.do()" action
 669       std::list<ObjectPtr>::const_iterator aNext = anObjIt;
 670       isOk = process(aCompFeat, false, ++aNext != anObjects.end()) && isOk;
 671     }
 672     else if (!isDumped(EntityPtr(*anObjIt))) {
 673       // dump folder
 674       FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(*anObjIt);
 675       if (aFolder)
 676         dumpFolder(aFolder);
 677       else {
 678         FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIt);
 679         if (aFeature) // dump common feature
 680           dumpFeature(aFeature);
 681       }
 682     }
 683   }
 684   // dump folders if any
 685   dumpPostponed(true);
 686   return isOk;
 687 }
 688
 689 bool ModelHighAPI_Dumper::process(const std::shared_ptr<ModelAPI_CompositeFeature>& theComposite,
 690                                   bool isForce, bool isDumpModelDo)
 691 {
 692   // increase composite features stack
 693   ++gCompositeStackDepth;
 694   // dump composite itself
 695   if (!isDumped(EntityPtr(theComposite)) || isForce)
 696     dumpFeature(FeaturePtr(theComposite), isForce);
 697
 698   // sub-part is processed independently, because it provides separate document
 699   if (theComposite->getKind() == PartSetPlugin_Part::ID()) {
 700     // dump name of the part if it is different from default
 701     if (!myEntitiesStack.empty())
 702       dumpEntitySetName();
 703
 704     // decrease composite features stack because we run into separate document
 705     --gCompositeStackDepth;
 706
 707     ResultPartPtr aPartResult =
 708         std::dynamic_pointer_cast<ModelAPI_ResultPart>(theComposite->lastResult());
 709     if (!aPartResult)
 710       return false;
 711     DocumentPtr aSubDoc = aPartResult->partDoc();
 712     if (!aSubDoc)
 713       return false;
 714     // set name of document
 715     const std::string& aPartName = myNames[theComposite].myCurrentName;
 716     std::string aDocName = aPartName + "_doc";
 717     myNames[aSubDoc] = EntityName(aDocName, std::string(), true);
 718
 719     // dump document in a separate line
 720     *this << aDocName << " = " << aPartName << ".document()" << std::endl;
 721     // dump features in the document
 722     bool aRes = process(aSubDoc);
 723     if (isDumpModelDo)
 724       *this << "model.do()\n";
 725     *this << std::endl;
 726     return aRes;
 727   }
 728
 729   // dump sub-features
 730   bool isOk = processSubs(theComposite);
 731   // decrease composite features stack
 732   --gCompositeStackDepth;
 733
 734   return isOk;
 735 }
 736
 737 bool ModelHighAPI_Dumper::processSubs(
 738   const std::shared_ptr<ModelAPI_CompositeFeature>& theComposite,
 739   bool theDumpModelDo)
 740 {
 741   bool isOk = true;
 742   // dump all sub-features;
 743   bool isSubDumped = false;
 744   int aNbSubs = theComposite->numberOfSubs();
 745   for (int anIndex = 0; anIndex < aNbSubs; ++anIndex) {
 746     FeaturePtr aFeature = theComposite->subFeature(anIndex);
 747     if (isDumped(EntityPtr(aFeature)))
 748       continue;
 749
 750     isSubDumped = true;
 751     CompositeFeaturePtr aCompFeat = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
 752     if (aCompFeat) // iteratively process composite features
 753       isOk = process(aCompFeat) && isOk;
 754     else
 755       dumpFeature(aFeature, true);
 756   }
 757
 758   bool isDumpSetName = !myEntitiesStack.empty() &&
 759       myEntitiesStack.top().myEntity == EntityPtr(theComposite);
 760   bool isForceModelDo = isSubDumped && isDumpSetName &&
 761       (myEntitiesStack.top().myUserName || !myEntitiesStack.top().myResults.empty());
 762   // It is necessary for the sketch to create its result when complete (command "model.do()").
 763   // This option is set by flat theDumpModelDo.
 764   // However, nested sketches are rebuilt by parent feature, so, they do not need
 765   // explicit call of "model.do()". This will be controlled by the depth of the stack.
 766   if (isForceModelDo || (theDumpModelDo && gCompositeStackDepth <= 1))
 767     *this << "model.do()" << std::endl;
 768
 769   // dump "setName" for composite feature
 770   if (isDumpSetName)
 771     dumpEntitySetName();
 772   return isOk;
 773 }
 774
 775 void ModelHighAPI_Dumper::postpone(const EntityPtr& theEntity)
 776 {
 777   // keep the name
 778   name(theEntity, false);
 779   myPostponed.push_back(theEntity);
 780 }
 781
 782 void ModelHighAPI_Dumper::dumpPostponed(bool theDumpFolders)
 783 {
 784   if (myDumpPostponedInProgress)
 785     return;
 786
 787   myDumpPostponedInProgress = true;
 788   // make a copy of postponed entities, because the list will be updated
 789   // if some features are not able to be dumped
 790   std::list<EntityPtr> aPostponedCopy = myPostponed;
 791   myPostponed.clear();
 792
 793   // iterate over postponed entities and try to dump them
 794   std::list<EntityPtr>::const_iterator anIt = aPostponedCopy.begin();
 795   for (; anIt != aPostponedCopy.end(); ++anIt) {
 796     FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(*anIt);
 797     if (aFolder) {
 798       if (theDumpFolders)
 799         dumpFolder(aFolder);
 800       else
 801         myPostponed.push_back(*anIt);
 802     }
 803     else {
 804       FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anIt);
 805       if (aFeature)
 806         dumpFeature(aFeature, true);
 807     }
 808   }
 809   myDumpPostponedInProgress = false;
 810 }
 811
 812 void ModelHighAPI_Dumper::dumpSubFeatureNameAndColor(const std::string theSubFeatureGet,
 813                                                      const FeaturePtr& theSubFeature)
 814 {
 815   name(theSubFeature, false);
 816   myNames[theSubFeature] = EntityName(theSubFeatureGet, theSubFeature->name(), false);
 817
 818   // store results if they have user-defined names or colors
 819   std::list<ResultPtr> aResultsWithNameOrColor;
 820   const std::list<ResultPtr>& aResults = theSubFeature->results();
 821   std::list<ResultPtr>::const_iterator aResIt = aResults.begin();
 822   for (; aResIt != aResults.end(); ++aResIt) {
 823     std::string aResName = (*aResIt)->data()->name();
 824     myNames[*aResIt] = EntityName(aResName, aResName, false);
 825     aResultsWithNameOrColor.push_back(*aResIt);
 826   }
 827
 828   // store just dumped entity to stack
 829   myEntitiesStack.push(LastDumpedEntity(theSubFeature, true, aResultsWithNameOrColor));
 830
 831   dumpEntitySetName();
 832 }
 833
 834 void ModelHighAPI_Dumper::importModule(const std::string& theModuleName)
 835 {
 836   myModules.insert(theModuleName);
 837 }
 838
 839 void ModelHighAPI_Dumper::dumpEntitySetName()
 840 {
 841   const LastDumpedEntity& aLastDumped = myEntitiesStack.top();
 842   bool isBufferEmpty = myDumpStorage->isBufferEmpty();
 843
 844   // dump "setName" for the entity
 845   if (aLastDumped.myUserName) {
 846     EntityName& anEntityNames = myNames[aLastDumped.myEntity];
 847     if (!anEntityNames.myIsDefault)
 848       *myDumpStorage << anEntityNames.myCurrentName << ".setName(\""
 849                      << anEntityNames.myUserName << "\")\n";
 850     // don't dump "setName" for the entity twice
 851     anEntityNames.myUserName.clear();
 852     anEntityNames.myIsDefault = true;
 853   }
 854   // dump "setName" for results
 855   std::list<ResultPtr>::const_iterator aResIt = aLastDumped.myResults.begin();
 856   std::list<ResultPtr>::const_iterator aResEnd = aLastDumped.myResults.end();
 857   for (; aResIt != aResEnd; ++aResIt) {
 858     // set result name
 859     EntityName& anEntityNames = myNames[*aResIt];
 860     if (!anEntityNames.myIsDefault) {
 861       *this << *aResIt;
 862       *myDumpStorage << ".setName(\"" << anEntityNames.myUserName << "\")\n";
 863       // don't dump "setName" for the entity twice
 864       anEntityNames.myUserName.clear();
 865       anEntityNames.myIsDefault = true;
 866     }
 867     // set result color
 868     if (!isDefaultColor(*aResIt)) {
 869       AttributeIntArrayPtr aColor = (*aResIt)->data()->intArray(ModelAPI_Result::COLOR_ID());
 870       if (aColor && aColor->isInitialized()) {
 871         *this << *aResIt;
 872         *myDumpStorage << ".setColor(" << aColor->value(0) << ", " << aColor->value(1)
 873                        << ", " << aColor->value(2) << ")\n";
 874       }
 875     }
 876     // set result deflection
 877     if (!isDefaultDeflection(*aResIt)) {
 878       AttributeDoublePtr aDeflectionAttr =
 879         (*aResIt)->data()->real(ModelAPI_Result::DEFLECTION_ID());
 880       if(aDeflectionAttr.get() && aDeflectionAttr->isInitialized()) {
 881         *this << *aResIt;
 882         *myDumpStorage << ".setDeflection(" << aDeflectionAttr->value() << ")\n";
 883       }
 884     }
 885     // set result transparency
 886     if (!isDefaultTransparency(*aResIt)) {
 887       AttributeDoublePtr aTransparencyAttr =
 888         (*aResIt)->data()->real(ModelAPI_Result::TRANSPARENCY_ID());
 889       if(aTransparencyAttr.get() && aTransparencyAttr->isInitialized()) {
 890         *this << *aResIt;
 891         *myDumpStorage << ".setTransparency(" << aTransparencyAttr->value() << ")\n";
 892       }
 893     }
 894   }
 895
 896   myNames[aLastDumped.myEntity].myIsDumped = true;
 897   myEntitiesStack.pop();
 898
 899   // clean buffer if it was clear before
 900   if (isBufferEmpty)
 901     myDumpStorage->mergeBuffer();
 902 }
 903
 904 bool ModelHighAPI_Dumper::isDumped(const EntityPtr& theEntity) const
 905 {
 906   EntityNameMap::const_iterator aFound = myNames.find(theEntity);
 907   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theEntity);
 908   return (aFound != myNames.end() && aFound->second.myIsDumped) ||
 909          myFeaturesToSkip.find(aFeature) != myFeaturesToSkip.end();
 910 }
 911
 912 bool ModelHighAPI_Dumper::isDumped(const AttributeRefAttrPtr& theRefAttr) const
 913 {
 914   FeaturePtr aFeature;
 915   if (theRefAttr->isObject())
 916     aFeature = ModelAPI_Feature::feature(theRefAttr->object());
 917   else
 918     aFeature = ModelAPI_Feature::feature(theRefAttr->attr()->owner());
 919   return aFeature && isDumped(EntityPtr(aFeature));
 920 }
 921
 922 bool ModelHighAPI_Dumper::isDumped(const AttributeRefListPtr& theRefList) const
 923 {
 924   std::list<ObjectPtr> aRefs = theRefList->list();
 925   std::list<ObjectPtr>::iterator anIt = aRefs.begin();
 926   for (; anIt != aRefs.end(); ++anIt) {
 927     FeaturePtr aFeature = ModelAPI_Feature::feature(*anIt);
 928     if (aFeature && !isDumped(EntityPtr(aFeature)))
 929       return false;
 930   }
 931   return true;
 932 }
 933
 934 static bool isSketchSub(const FeaturePtr& theFeature)
 935 {
 936   static const std::string SKETCH("Sketch");
 937   CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theFeature);
 938   return anOwner && anOwner->getKind() == SKETCH;
 939 }
 940
 941 bool ModelHighAPI_Dumper::isDefaultColor(const ResultPtr& theResult) const
 942 {
 943   AttributeIntArrayPtr aColor = theResult->data()->intArray(ModelAPI_Result::COLOR_ID());
 944   if (!aColor || !aColor->isInitialized())
 945     return true;
 946
 947   // check the result belongs to sketch entity, do not dump color in this way
 948   ResultConstructionPtr aResConstr =
 949       std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theResult);
 950   if (aResConstr) {
 951     FeaturePtr aFeature = ModelAPI_Feature::feature(theResult->data()->owner());
 952     if (isSketchSub(aFeature))
 953       return true;
 954   }
 955
 956   std::string aSection, aName, aDefault;
 957   theResult->colorConfigInfo(aSection, aName, aDefault);
 958
 959   // dump current color
 960   std::ostringstream aColorInfo;
 961   aColorInfo << aColor->value(0) << "," << aColor->value(1) << "," << aColor->value(2);
 962
 963   return aDefault == aColorInfo.str();
 964 }
 965
 966 bool ModelHighAPI_Dumper::isDefaultDeflection(const ResultPtr& theResult) const
 967 {
 968   AttributeDoublePtr aDeflectionAttr = theResult->data()->real(ModelAPI_Result::DEFLECTION_ID());
 969   if(!aDeflectionAttr || !aDeflectionAttr->isInitialized()) {
 970     return true;
 971   }
 972
 973   double aCurrent = aDeflectionAttr->value();
 974   double aDefault = -1;
 975
 976   bool isConstruction = false;
 977   std::string aResultGroup = theResult->groupName();
 978   if (aResultGroup == ModelAPI_ResultConstruction::group())
 979     isConstruction = true;
 980   else if (aResultGroup == ModelAPI_ResultBody::group()) {
 981     GeomShapePtr aGeomShape = theResult->shape();
 982     if (aGeomShape.get()) {
 983       // if the shape could not be exploded on faces, it contains only wires, edges, and vertices
 984       // correction of deviation for them should not influence to the application performance
 985       GeomAPI_ShapeExplorer anExp(aGeomShape, GeomAPI_Shape::FACE);
 986       isConstruction = !anExp.more();
 987     }
 988   }
 989   if (isConstruction)
 990     aDefault = Config_PropManager::real("Visualization", "construction_deflection");
 991   else
 992     aDefault = Config_PropManager::real("Visualization", "body_deflection");
 993
 994   return fabs(aCurrent - aDefault) < 1.e-12;
 995 }
 996
 997 bool ModelHighAPI_Dumper::isDefaultTransparency(const ResultPtr& theResult) const
 998 {
 999   AttributeDoublePtr anAttribute = theResult->data()->real(ModelAPI_Result::TRANSPARENCY_ID());
1000   if(!anAttribute || !anAttribute->isInitialized()) {
1001     return true;
1002   }
1003   return fabs(anAttribute->value()) < 1.e-12;
1004 }
1005
1006 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const char theChar)
1007 {
1008   *myDumpStorage << theChar;
1009   return *this;
1010 }
1011
1012 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const char* theString)
1013 {
1014   *myDumpStorage << theString;
1015   return *this;
1016 }
1017
1018 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const std::string& theString)
1019 {
1020   *myDumpStorage << theString;
1021   return *this;
1022 }
1023
1024 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const bool theValue)
1025 {
1026   *myDumpStorage << (theValue ? "True" : "False");
1027   return *this;
1028 }
1029
1030 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const int theValue)
1031 {
1032   *myDumpStorage << theValue;
1033   return *this;
1034 }
1035
1036 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const double theValue)
1037 {
1038   *myDumpStorage << theValue;
1039   return *this;
1040 }
1041
1042 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const std::shared_ptr<GeomAPI_Pnt>& thePoint)
1043 {
1044   importModule("GeomAPI");
1045   *myDumpStorage << "GeomAPI_Pnt(" << thePoint->x() << ", "
1046                  << thePoint->y() << ", " << thePoint->z() << ")";
1047   return *this;
1048 }
1049
1050 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const std::shared_ptr<GeomAPI_Dir>& theDir)
1051 {
1052   importModule("GeomAPI");
1053   *myDumpStorage << "GeomAPI_Dir(" << theDir->x() << ", "
1054                  << theDir->y() << ", " << theDir->z() << ")";
1055   return *this;
1056 }
1057
1058 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1059     const std::shared_ptr<GeomDataAPI_Dir>& theDir)
1060 {
1061   *myDumpStorage << theDir->x() << ", " << theDir->y() << ", " << theDir->z();
1062   return *this;
1063 }
1064
1065 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1066     const std::shared_ptr<GeomDataAPI_Point>& thePoint)
1067 {
1068   static const int aSize = 3;
1069   double aValues[aSize] = {thePoint->x(), thePoint->y(), thePoint->z()};
1070   std::string aTexts[aSize] = {thePoint->textX(), thePoint->textY(), thePoint->textZ()};
1071   myDumpStorage->dumpArray(aSize, aValues, aTexts);
1072   return *this;
1073 }
1074
1075 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1076     const std::shared_ptr<GeomDataAPI_Point2D>& thePoint)
1077 {
1078   static const int aSize = 2;
1079   double aValues[aSize] = {thePoint->x(), thePoint->y()};
1080   std::string aTexts[aSize] = {thePoint->textX(), thePoint->textY()};
1081   myDumpStorage->dumpArray(aSize, aValues, aTexts);
1082   return *this;
1083 }
1084
1085 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1086     const std::shared_ptr<ModelAPI_AttributeBoolean>& theAttrBool)
1087 {
1088   *myDumpStorage << (theAttrBool->value() ? "True" : "False");
1089   return *this;
1090 }
1091
1092 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1093     const std::shared_ptr<ModelAPI_AttributeInteger>& theAttrInt)
1094 {
1095   std::string aText = theAttrInt->text();
1096   if (aText.empty())
1097     *myDumpStorage << theAttrInt->value();
1098   else
1099     *myDumpStorage << "\"" << aText << "\"";
1100   return *this;
1101 }
1102
1103 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1104     const std::shared_ptr<ModelAPI_AttributeDouble>& theAttrReal)
1105 {
1106   std::string aText = theAttrReal->text();
1107   if (aText.empty())
1108     *myDumpStorage << theAttrReal->value();
1109   else
1110     *myDumpStorage << "\"" << aText << "\"";
1111   return *this;
1112 }
1113
1114 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1115     const std::shared_ptr<ModelAPI_AttributeString>& theAttrStr)
1116 {
1117   *myDumpStorage << "\"" << theAttrStr->value() << "\"";
1118   return *this;
1119 }
1120
1121 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FolderPtr& theFolder)
1122 {
1123   *myDumpStorage << name(theFolder);
1124
1125   // add dumped folder to a stack
1126   if (!myNames[theFolder].myIsDumped &&
1127      (myEntitiesStack.empty() || myEntitiesStack.top().myEntity != theFolder))
1128     myEntitiesStack.push(LastDumpedEntity(theFolder, !myNames[theFolder].myIsDefault));
1129
1130   return *this;
1131 }
1132
1133 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const FeaturePtr& theEntity)
1134 {
1135   *myDumpStorage << name(theEntity);
1136
1137   if (!myNames[theEntity].myIsDumped) {
1138     bool isUserDefinedName = !myNames[theEntity].myIsDefault;
1139     // store results if they have user-defined names or colors
1140     std::list<ResultPtr> aResultsWithNameOrColor;
1141     std::list<ResultPtr> allRes;
1142     ModelAPI_Tools::allResults(theEntity, allRes);
1143     for(std::list<ResultPtr>::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) {
1144       if(!myNames[*aRes].myIsDefault || !isDefaultColor(*aRes) ||
1145          !isDefaultDeflection(*aRes) || !isDefaultTransparency(*aRes))
1146         aResultsWithNameOrColor.push_back(*aRes);
1147     }
1148     // store just dumped entity to stack
1149     if (myEntitiesStack.empty() || myEntitiesStack.top().myEntity != theEntity)
1150       myEntitiesStack.push(
1151           LastDumpedEntity(theEntity, isUserDefinedName, aResultsWithNameOrColor));
1152   }
1153
1154   // remove entity from the list of not dumped items
1155   myNotDumpedEntities.erase(theEntity);
1156   return *this;
1157 }
1158
1159 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const ResultPtr& theResult)
1160 {
1161   // iterate in the structure of sub-results to the parent
1162   ResultPtr aCurRes = theResult;
1163   FeaturePtr aFeature = ModelAPI_Feature::feature(theResult);
1164   std::list<int> anIndices; // indexes of results in the parent result, starting from topmost
1165   while(aCurRes.get()) {
1166     ResultBodyPtr aParent = ModelAPI_Tools::bodyOwner(aCurRes);
1167     if (aParent) {
1168       anIndices.push_front(ModelAPI_Tools::bodyIndex(aCurRes));
1169     } else { // index of the result in the feature
1170       std::list<ResultPtr>::const_iterator aRes = aFeature->results().cbegin();
1171       for(int anIndex = 0; aRes != aFeature->results().cend(); aRes++, anIndex++) {
1172         if (*aRes == aCurRes) {
1173           anIndices.push_front(anIndex);
1174           break;
1175         }
1176       }
1177     }
1178     aCurRes = aParent;
1179   }
1180
1181   *myDumpStorage << name(aFeature);
1182   for (std::list<int>::iterator anI = anIndices.begin(); anI != anIndices.end(); anI++) {
1183     if (anI == anIndices.begin()) {
1184       if(*anI == 0) {
1185         *myDumpStorage << ".result()";
1186       }
1187       else {
1188         *myDumpStorage << ".results()[" << *anI << "]";
1189       }
1190     } else {
1191       *myDumpStorage << ".subResult(" << *anI << ")";
1192     }
1193   }
1194
1195   return *this;
1196 }
1197
1198 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const std::list<ResultPtr>& theResults)
1199 {
1200   *this << "[";
1201   for (std::list<ResultPtr>::const_iterator anIt = theResults.begin();
1202        anIt != theResults.end(); ++anIt) {
1203     if (anIt != theResults.begin())
1204       *this << ", ";
1205     *this << *anIt;
1206   }
1207   *this << "]";
1208   return *this;
1209 }
1210
1211 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const ObjectPtr& theObject)
1212 {
1213   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
1214   if(aFeature.get()) {
1215     *myDumpStorage << name(aFeature);
1216     return *this;
1217   }
1218
1219   ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1220   if(aResult.get()) {
1221     *this << aResult;
1222     return *this;
1223   }
1224
1225   return *this;
1226 }
1227
1228 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(const AttributePtr& theAttr)
1229 {
1230   FeaturePtr anOwner = ModelAPI_Feature::feature(theAttr->owner());
1231
1232   std::string aWrapperPrefix, aWrapperSuffix;
1233   // Check the attribute belongs to copied (in multi-translation or multi-rotation) feature.
1234   // In this case we need to cast explicitly feature to appropriate type.
1235   AttributeBooleanPtr isCopy = anOwner->boolean("Copy");
1236   AttributeReferencePtr hasParent = anOwner->reference("ParentFeature");
1237   if ((isCopy.get() && isCopy->value()) || (hasParent && hasParent->value())) {
1238     aWrapperPrefix = featureWrapper(anOwner) + "(";
1239     aWrapperSuffix = ")";
1240     importModule("SketchAPI");
1241   }
1242
1243   *myDumpStorage << aWrapperPrefix << name(anOwner) << aWrapperSuffix
1244                  << "." << attributeGetter(anOwner, theAttr->id()) << "()";
1245   return *this;
1246 }
1247
1248 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1249     const std::shared_ptr<ModelAPI_AttributeRefAttr>& theRefAttr)
1250 {
1251   if (theRefAttr->isObject())
1252     *this << theRefAttr->object();
1253   else
1254     *this << theRefAttr->attr();
1255   return *this;
1256 }
1257
1258 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1259     const std::shared_ptr<ModelAPI_AttributeRefAttrList>& theRefAttrList)
1260 {
1261   *myDumpStorage << "[";
1262   std::list<std::pair<ObjectPtr, AttributePtr> > aList = theRefAttrList->list();
1263   bool isAdded = false;
1264   std::list<std::pair<ObjectPtr, AttributePtr> >::const_iterator anIt = aList.begin();
1265   for (; anIt != aList.end(); ++anIt) {
1266     if (isAdded)
1267       *myDumpStorage << ", ";
1268     else
1269       isAdded = true;
1270     if (anIt->first)
1271       *this << anIt->first;
1272     else if (anIt->second)
1273       * this << anIt->second;
1274   }
1275   *myDumpStorage << "]";
1276   return *this;
1277 }
1278
1279 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1280     const std::shared_ptr<ModelAPI_AttributeReference>& theReference)
1281 {
1282   *this << theReference->value();
1283   return *this;
1284 }
1285
1286 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1287     const std::shared_ptr<ModelAPI_AttributeRefList>& theRefList)
1288 {
1289   static const int aThreshold = 2;
1290   static bool aDumpAsIs = false;
1291   // if number of elements in the list if greater than a threshold,
1292   // dump it in a separate line with specific name
1293   if (aDumpAsIs || theRefList->size() <= aThreshold) {
1294     *myDumpStorage << "[";
1295     std::list<ObjectPtr> aList = theRefList->list();
1296     bool isAdded = false;
1297     std::list<ObjectPtr>::const_iterator anIt = aList.begin();
1298     for (; anIt != aList.end(); ++anIt) {
1299       if (isAdded)
1300         *myDumpStorage << ", ";
1301       else
1302         isAdded = true;
1303
1304       *this << *anIt;
1305     }
1306     *myDumpStorage << "]";
1307   } else {
1308     // name of list
1309     FeaturePtr anOwner = ModelAPI_Feature::feature(theRefList->owner());
1310     std::string aListName = name(anOwner) + "_objects";
1311     // reserve dumped buffer and store list "as is"
1312     myDumpStorage->reserveBuffer();
1313     aDumpAsIs = true;
1314     *this << aListName << " = " << theRefList << "\n";
1315     aDumpAsIs = false;
1316     // append reserved data to the end of the current buffer
1317     myDumpStorage->restoreReservedBuffer();
1318     *myDumpStorage << aListName;
1319   }
1320   return *this;
1321 }
1322
1323 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1324     const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect)
1325 {
1326   myDumpStorage->write(theAttrSelect);
1327   return *this;
1328 }
1329
1330 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1331     const std::shared_ptr<ModelAPI_AttributeSelectionList>& theAttrSelList)
1332 {
1333   static const int aThreshold = 2;
1334   static bool aDumpAsIs = false;
1335   // if number of elements in the list if greater than a threshold,
1336   // dump it in a separate line with specific name
1337   if (aDumpAsIs || theAttrSelList->size() <= aThreshold) {
1338     *myDumpStorage << "[";
1339
1340     GeomShapePtr aShape;
1341     std::string aShapeTypeStr;
1342
1343     bool isAdded = false;
1344
1345     for(int anIndex = 0; anIndex < theAttrSelList->size(); ++anIndex) {
1346       AttributeSelectionPtr anAttribute = theAttrSelList->value(anIndex);
1347       aShape = anAttribute->value();
1348       if(!aShape.get()) {
1349         ResultPtr aContext = anAttribute->context();
1350         if (aContext.get())
1351           aShape = aContext->shape();
1352       }
1353
1354       if(!aShape.get()) {
1355         continue;
1356       }
1357
1358       if(isAdded) {
1359         *myDumpStorage << ", ";
1360       } else {
1361         isAdded = true;
1362       }
1363       *this << anAttribute;
1364     }
1365
1366     // check selection list is obtained by filters
1367     FiltersFeaturePtr aFilters = theAttrSelList->filters();
1368     if (aFilters) {
1369       if (theAttrSelList->size() > 0)
1370         *myDumpStorage << ", ";
1371       dumpFeature(aFilters, true);
1372     }
1373
1374     *myDumpStorage << "]";
1375   } else {
1376     // obtain name of list (the feature may contain several selection lists)
1377     FeaturePtr anOwner = ModelAPI_Feature::feature(theAttrSelList->owner());
1378     std::string aListName = name(anOwner) + "_objects";
1379     std::list<AttributePtr> aSelLists =
1380         anOwner->data()->attributes(ModelAPI_AttributeSelectionList::typeId());
1381     if (aSelLists.size() > 1) {
1382       int anIndex = 1;
1383       for (std::list<AttributePtr>::iterator aSIt = aSelLists.begin();
1384            aSIt != aSelLists.end(); ++aSIt, ++anIndex)
1385         if ((*aSIt).get() == theAttrSelList.get())
1386           break;
1387       std::ostringstream aSStream;
1388       aSStream << aListName << "_" << anIndex;
1389       aListName = aSStream.str();
1390     }
1391     // reserve dumped buffer and store list "as is"
1392     myDumpStorage->reserveBuffer();
1393     aDumpAsIs = true;
1394     *this << aListName << " = " << theAttrSelList << "\n";
1395     aDumpAsIs = false;
1396     // append reserved data to the end of the current buffer
1397     myDumpStorage->restoreReservedBuffer();
1398     *myDumpStorage << aListName;
1399   }
1400   return *this;
1401 }
1402
1403 ModelHighAPI_Dumper& ModelHighAPI_Dumper::operator<<(
1404   const std::shared_ptr<ModelAPI_AttributeStringArray>& theArray)
1405 {
1406   std::ostringstream aBuffer;
1407   aBuffer << "[";
1408   for(int anIndex = 0; anIndex < theArray->size(); ++anIndex) {
1409     if (anIndex != 0)
1410       aBuffer << ", ";
1411
1412     aBuffer << "\"" << theArray->value(anIndex) << "\"";
1413   }
1414   aBuffer << "]";
1415
1416   myDumpStorage->write(aBuffer.str());
1417   return *this;
1418 }
1419
1420 /// Dump std::endl
1421 ModelHighAPI_Dumper& operator<<(ModelHighAPI_Dumper& theDumper,
1422                                 std::basic_ostream<char>& (*theEndl)(std::basic_ostream<char>&))
1423 {
1424   *theDumper.myDumpStorage << theEndl;
1425
1426   if (!theDumper.myEntitiesStack.empty()) {
1427     bool isCopy;
1428     // all copies have been stored into stack, pop them all
1429     do {
1430       isCopy = false;
1431       // Name for composite feature is dumped when all sub-entities are dumped
1432       // (see method ModelHighAPI_Dumper::processSubs).
1433       const ModelHighAPI_Dumper::LastDumpedEntity& aLastDumped = theDumper.myEntitiesStack.top();
1434       CompositeFeaturePtr aComposite =
1435           std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aLastDumped.myEntity);
1436       if (!aComposite) {
1437         theDumper.dumpEntitySetName();
1438         FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aLastDumped.myEntity);
1439         if (aFeature) {
1440           AttributeBooleanPtr aCopyAttr = aFeature->boolean("Copy");
1441           isCopy = aCopyAttr.get() && aCopyAttr->value();
1442         }
1443       }
1444     } while (isCopy && !theDumper.myEntitiesStack.empty());
1445   }
1446
1447   // store all not-dumped entities first
1448   std::set<EntityPtr> aNotDumped = theDumper.myNotDumpedEntities;
1449   theDumper.myDumpStorage->reserveBuffer();
1450   std::set<EntityPtr>::const_iterator anIt = aNotDumped.begin();
1451   for (; anIt != aNotDumped.end(); ++anIt) {
1452     // if the feature is composite, dump it with all subs
1453     CompositeFeaturePtr aCompFeat =
1454         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(*anIt);
1455     if (aCompFeat)
1456       theDumper.process(aCompFeat, true);
1457     else {
1458       FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anIt);
1459       theDumper.dumpFeature(aFeature, true);
1460       // dump the Projection feature which produces this "Copy" entity
1461       AttributeBooleanPtr aCopyAttr = aFeature->boolean("Copy");
1462       if (aCopyAttr.get() && aCopyAttr->value())
1463       {
1464         const std::set<AttributePtr>& aRefs = aFeature->data()->refsToMe();
1465         std::set<AttributePtr>::iterator aRefIt = aRefs.begin();
1466         for (; aRefIt != aRefs.end(); ++aRefIt)
1467           if ((*aRefIt)->id() == "ProjectedFeature")
1468           { // process projection only
1469             FeaturePtr anOwner = ModelAPI_Feature::feature((*aRefIt)->owner());
1470             if (anOwner && !theDumper.isDumped(EntityPtr(anOwner)))
1471               theDumper.dumpFeature(anOwner, true);
1472           }
1473       }
1474     }
1475   }
1476
1477   // then store the reserved data
1478   theDumper.myDumpStorage->restoreReservedBuffer();
1479   theDumper.myDumpStorage->mergeBuffer();
1480
1481   // now, store all postponed features
1482   theDumper.dumpPostponed();
1483
1484   return theDumper;
1485 }