src/ModelHighAPI/ModelHighAPI_Dumper.cpp

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