ModelHighAPI_Dumper.h

// Copyright (C) 2014-2026  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef ModelHighAPI_Dumper_H_
#define ModelHighAPI_Dumper_H_
 
#include "ModelHighAPI.h"
 
#include <list>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <stack>
#include <string>
 
class GeomAPI_Pnt;
class GeomAPI_Dir;
 
class GeomDataAPI_Dir;
class GeomDataAPI_Point;
class GeomDataAPI_Point2D;
class GeomDataAPI_Point2DArray;
 
class ModelAPI_Attribute;
class ModelAPI_AttributeBoolean;
class ModelAPI_AttributeDouble;
class ModelAPI_AttributeDoubleArray;
class ModelAPI_AttributeIntArray;
class ModelAPI_AttributeInteger;
class ModelAPI_AttributeRefAttr;
class ModelAPI_AttributeRefAttrList;
class ModelAPI_AttributeReference;
class ModelAPI_AttributeRefList;
class ModelAPI_AttributeSelection;
class ModelAPI_AttributeSelectionList;
class ModelAPI_AttributeString;
class ModelAPI_AttributeStringArray;
class ModelAPI_CompositeFeature;
class ModelAPI_Document;
class ModelAPI_Entity;
class ModelAPI_Feature;
class ModelAPI_Folder;
class ModelAPI_Object;
class ModelAPI_Result;
 
typedef std::shared_ptr<ModelAPI_Document> DocumentPtr;
typedef std::shared_ptr<ModelAPI_Entity>   EntityPtr;
typedef std::shared_ptr<ModelAPI_Feature>  FeaturePtr;
typedef std::shared_ptr<ModelAPI_Folder>   FolderPtr;
typedef std::shared_ptr<ModelAPI_Result>   ResultPtr;
 
typedef std::set<std::string>                                                ModulesSet;
typedef std::map<DocumentPtr, std::map<std::string, std::pair<int, int> > >  NbFeaturesMap;
 
class ModelHighAPI_Dumper
{
public:
  class DumpStorage
  {
  public:
    DumpStorage() {}
    MODELHIGHAPI_EXPORT DumpStorage(const DumpStorage& theOther);
    MODELHIGHAPI_EXPORT const DumpStorage& operator=(const DumpStorage& theOther);
 
    virtual ~DumpStorage() {}
 
    void setFilenameSuffix(const std::string& theSuffix) { myFilenameSuffix = theSuffix; }
 
  protected:
    std::ostringstream& buffer() { return myDumpBuffer; }
    std::ostringstream& fullDump() { return myFullDump; }
 
    MODELHIGHAPI_EXPORT virtual void reserveBuffer();
    MODELHIGHAPI_EXPORT virtual void restoreReservedBuffer();
 
    MODELHIGHAPI_EXPORT
    virtual void write(const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect);
 
    MODELHIGHAPI_EXPORT
    virtual bool exportTo(const std::string& theFilename, const ModulesSet& theUsedModules);
 
  private:
    std::string myFilenameSuffix;
    std::ostringstream myDumpBuffer;
    std::ostringstream myFullDump;
 
    std::stack<std::string> myDumpBufferHideout;
 
    friend class ModelHighAPI_Dumper;
  };
  typedef std::shared_ptr<DumpStorage> DumpStoragePtr;
 
  class DumpStorageGeom : public DumpStorage
  {
  protected:
    MODELHIGHAPI_EXPORT
    virtual void write(const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect);
  };
 
  class DumpStorageWeak : public DumpStorage
  {
  protected:
    MODELHIGHAPI_EXPORT
    virtual void write(const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect);
  };
 
public:
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper();
 
  MODELHIGHAPI_EXPORT
  static void setInstance(ModelHighAPI_Dumper* theDumper);
 
  MODELHIGHAPI_EXPORT
  void setIsMultiDump(const bool theValue);
 
  MODELHIGHAPI_EXPORT
  static ModelHighAPI_Dumper* getInstance();
 
  MODELHIGHAPI_EXPORT
  virtual ~ModelHighAPI_Dumper();
 
  MODELHIGHAPI_EXPORT
  void addCustomStorage(const DumpStoragePtr& theStorage);
  MODELHIGHAPI_EXPORT
  void clearCustomStorage();
  MODELHIGHAPI_EXPORT
  bool process(const std::shared_ptr<ModelAPI_Document>& theDoc, const std::string& theFileName);
 
  MODELHIGHAPI_EXPORT
  void setDumpDir(const std::string& theDumpDir) { myDumpDir = theDumpDir; }
  MODELHIGHAPI_EXPORT std::string getDumpDir() const { return myDumpDir; }
 
  MODELHIGHAPI_EXPORT
  void importModule(const std::string& theModuleName);
 
  MODELHIGHAPI_EXPORT
  const std::string& name(const EntityPtr& theEntity, bool theSaveNotDumped = true,
                          bool theUseEntityName = false, bool theSetIsDumped = false);
 
  MODELHIGHAPI_EXPORT
  const std::string& parentName(const FeaturePtr& theFeature);
 
  virtual void dumpParameter(const FeaturePtr& theFeature) = 0;
  virtual void dumpFeature(const FeaturePtr& theFeature, const bool theForce = false) = 0;
  virtual void dumpFolder(const FolderPtr& theFolder) = 0;
 
  MODELHIGHAPI_EXPORT
  void postpone(const EntityPtr& theEntity);
 
  MODELHIGHAPI_EXPORT
  void doNotDumpFeature(const FeaturePtr& theFeature)
  { myFeaturesToSkip.insert(theFeature); }
 
  MODELHIGHAPI_EXPORT
  void dumpSubFeatureNameAndColor(const std::string theSubFeatureGet,
                                  const FeaturePtr& theSubFeature);
 
  virtual std::string attributeGetter(const FeaturePtr& theFeature,
                                      const std::string& theAttrName) const = 0;
 
  virtual std::string featureWrapper(const FeaturePtr& theFeature) const = 0;
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const char theChar);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const char* theString);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::string& theString);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::wstring& theString);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const bool theValue);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const int theValue);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const double theValue);
  friend
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(ModelHighAPI_Dumper& theDumper,
                                std::basic_ostream<char>& (*theEndl)(std::basic_ostream<char>&));
 
  MODELHIGHAPI_EXPORT void newline();
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomAPI_Pnt>& thePoint);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomAPI_Dir>& theDir);
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomDataAPI_Dir>& theDir);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomDataAPI_Point>& thePoint);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomDataAPI_Point2D>& thePoint);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<GeomDataAPI_Point2DArray>& thePointArray);
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeBoolean>& theAttrBool);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeInteger>& theAttrInt);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeIntArray>& theArray);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeDouble>& theAttrReal);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeDoubleArray>& theArray);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::shared_ptr<ModelAPI_AttributeString>& theAttrStr);
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const FeaturePtr& theEntity);
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const FolderPtr& theFolder);
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const ResultPtr& theResult);
 
  MODELHIGHAPI_EXPORT
  ModelHighAPI_Dumper& operator<<(const std::list<ResultPtr>& theResults);
 
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_Attribute>& theAttr);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_Object>& theObject);
 
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeRefAttr>& theRefAttr);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeRefAttrList>& theRefAttrList);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeRefList>& theRefList);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeSelection>& theAttrSelect);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeSelectionList>& theAttrSelList);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
  operator<<(const std::shared_ptr<ModelAPI_AttributeReference>& theReference);
  MODELHIGHAPI_EXPORT ModelHighAPI_Dumper&
    operator<<(const std::shared_ptr<ModelAPI_AttributeStringArray>& theArray);
 
  MODELHIGHAPI_EXPORT void clearNotDumped();
 
  MODELHIGHAPI_EXPORT
  bool isDumped(const EntityPtr& theEntity) const;
  MODELHIGHAPI_EXPORT
  bool isDumped(const std::shared_ptr<ModelAPI_AttributeRefAttr>& theRefAttr) const;
  MODELHIGHAPI_EXPORT
  bool isDumped(const std::shared_ptr<ModelAPI_AttributeRefList>& theRefList) const;
 
  MODELHIGHAPI_EXPORT
  size_t indexOfFirstNotDumped(const std::shared_ptr<ModelAPI_AttributeRefList>& theRefList) const;
 
  MODELHIGHAPI_EXPORT virtual void exportVariables() const;
 
  MODELHIGHAPI_EXPORT virtual void exportVariable(const std::string& /*theEntry*/,
                                                  const std::string& /*theVarName*/) const {}
 
  MODELHIGHAPI_EXPORT bool dumpCommentBeforeFeature(const FeaturePtr& theFeature) const;
 
protected:
  MODELHIGHAPI_EXPORT void dumpEntitySetName();
 
private:
  ModelHighAPI_Dumper(const ModelHighAPI_Dumper&);
  const ModelHighAPI_Dumper& operator=(const ModelHighAPI_Dumper&);
 
  bool process(const std::shared_ptr<ModelAPI_Document>& theDoc);
 
  bool process(const std::shared_ptr<ModelAPI_CompositeFeature>& theComposite,
               bool isForce = false,
               bool isDumpModelDo = true);
 
  MODELHIGHAPI_EXPORT
  bool processSubs(const std::shared_ptr<ModelAPI_CompositeFeature>& theComposite,
                   bool theDumpModelDo = false);
 
  void saveResultNames(const FeaturePtr& theFeature);
 
  bool hasColoredShape(const ResultPtr& theResult, bool theGetSubResults = false) const;
 
  bool isParentResult(const ResultPtr& theResult) const;
 
  bool isDefaultColor(const ResultPtr& theResult) const;
 
  bool isDefaultDeflection(const ResultPtr& theResult) const;
 
  bool isDefaultTransparency(const ResultPtr& theResult) const;
 
  void dumpPostponed(bool theDumpFolders = false);
 
  //Dump global variables for multifile dump
  void dumpGlobalForMultiFile(const FeaturePtr& theEntity);
 
private:
  struct EntityName {
    std::string myCurrentName; 
    std::string myUserName;    
    bool        myIsDefault;   
    bool        myIsDumped;    
 
    EntityName() {}
 
    EntityName(const std::string& theCurName, const std::string& theUserName, bool theDefault)
      : myCurrentName(theCurName),
        myUserName(theUserName),
        myIsDefault(theDefault),
        myIsDumped(false)
    {}
  };
  typedef std::map<EntityPtr, EntityName> EntityNameMap;
 
  struct LastDumpedEntity {
    EntityPtr            myEntity;   
    bool                 myUserName; 
    std::list<ResultPtr> myResults;
 
    LastDumpedEntity(EntityPtr theEntity, bool theUserName,
      const std::list<ResultPtr>& theResults = std::list<ResultPtr>())
      : myEntity(theEntity), myUserName(theUserName), myResults(theResults)
    {}
  };
  typedef std::stack<LastDumpedEntity> DumpStack;
 
  static ModelHighAPI_Dumper* mySelf;
 
  class DumpStorageBuffer;
  DumpStorageBuffer*  myDumpStorage;        
 
  ModulesSet          myModules;            
  EntityNameMap       myNames;              
  DumpStack           myEntitiesStack;      
 
  NbFeaturesMap       myFeatureCount;       
 
  std::set<FeaturePtr> myFeaturesToSkip;
 
  std::list<EntityPtr> myPostponed; 
  bool myDumpPostponedInProgress; 
 
  std::string myDumpDir;
  bool myIsMultifile;
 
protected:
  std::set<EntityPtr> myNotDumpedEntities;
 
  friend class SketchAPI_Sketch;
  friend class ModelHighAPI_Folder;
};
 
#endif