-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <list>
#include <map>
#include <vector>
+#include <set>
#include <SALOMEconfig.h>
#include CORBA_CLIENT_HEADER(SALOMEDS)
* This file was created in order to respond to requirement of bug PAL10494:
* SMESH python dump uses idl interface.
*
- * The creation reason is that smesh.py commands defining hypotheses encapsulate
- * several SMESH engine method calls. As well, the dependencies between smesh.py
+ * The creation reason is that smeshBuilder.py commands defining hypotheses encapsulate
+ * several SMESH engine method calls. As well, the dependencies between smeshBuilder.py
* classes differ from ones between corresponding SMESH IDL interfaces.
*
* Everything here is for internal usage by SMESH_2smeshpy::ConvertScript()
bool IsEmpty() const { return myString.IsEmpty(); }
_AString GetIndentation();
const _AString & GetResultValue();
- const int GetNbResultValues();
+ int GetNbResultValues();
_AString GetResultValue(int res);
const _AString & GetObject();
const _AString & GetMethod();
_pyID myID;
Handle(_pyCommand) myCreationCmd;
std::list< Handle(_pyCommand) > myProcessedCmds;
+ std::list< Handle(_pyCommand) > myArgCmds; // where this obj is used as an argument
bool myIsPublished;
void setID(const _pyID& theID);
void AddProcessedCmd( const Handle(_pyCommand) & cmd )
{ if (myProcessedCmds.empty() || myProcessedCmds.back()!=cmd) myProcessedCmds.push_back( cmd );}
std::list< Handle(_pyCommand) >& GetProcessedCmds() { return myProcessedCmds; }
+ void AddArgCmd( const Handle(_pyCommand) & cmd ) { myArgCmds.push_back( cmd ); }
virtual void Process(const Handle(_pyCommand) & cmd) { AddProcessedCmd(cmd); }
virtual void Flush() = 0;
virtual const char* AccessorMethod() const;
- virtual bool CanClear() { return !myIsPublished; }
+ virtual bool CanClear();
virtual void ClearCommands();
virtual void Free() {}
public:
_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
+ std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands);
Handle(_pyCommand) AddCommand( const _AString& theCommand );
void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 );
- void SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd );
- void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
+ void SetCommandAfter ( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd );
+ void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
Handle(_pyCommand)& GetLastCommand();
std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
_pyID GenerateNewID( const _pyID& theID );
void AddObject( Handle(_pyObject)& theObj );
+ void CheckObjectIsReCreated( Handle(_pyObject)& theObj );
void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
- Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
- Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
+ Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
+ Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
const Handle(_pyHypothesis)& theHypothesis);
bool IsGeomObject(const _pyID& theObjID) const;
bool IsNotPublished(const _pyID& theObjID) const;
+ void ObjectCreationRemoved(const _pyID& theObjID);
+ void KeepAgrCmds(const _pyID& theObjID) { myKeepAgrCmdsIDs.push_back( theObjID ); }
bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
{ myFile2ExportedMesh[ file ] = mesh; }
void setNeighbourCommand( Handle(_pyCommand)& theCmd,
Handle(_pyCommand)& theOtherCmd,
const bool theIsAfter );
-
+ //void addFilterUser( Handle(_pyCommand)& theCmd, const Handle(_pyObject)& user );
+
private:
- std::map< _pyID, Handle(_pyMesh) > myMeshes;
- std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
- std::map< _pyID, Handle(_pyObject) > myObjects;
- std::list< Handle(_pyHypothesis) > myHypos;
- std::list< Handle(_pyCommand) > myCommands;
- int myNbCommands;
+ std::map< _pyID, Handle(_pyMesh) > myMeshes;
+ std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
+ std::map< _pyID, Handle(_pyObject) > myObjects;
+ std::map< _pyID, Handle(_pyHypothesis) > myHypos;
+ std::list< _pyID > myKeepAgrCmdsIDs;
+ std::list< Handle(_pyCommand) > myCommands;
+ int myNbCommands;
Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
- Handle(_pyCommand) myLastCommand;
- int myNbFilters;
- bool myToKeepAllCommands;
- SALOMEDS::Study_var myStudy;
- int myGeomIDNb, myGeomIDIndex;
- std::map< _AString, ExportedMeshData > myFile2ExportedMesh;
- Handle( _pyHypothesisReader ) myHypReader;
+ std::set< TCollection_AsciiString >& myRemovedObjIDs;
+ Handle(_pyCommand) myLastCommand;
+ int myNbFilters;
+ bool myToKeepAllCommands;
+ SALOMEDS::Study_var myStudy;
+ int myGeomIDNb, myGeomIDIndex;
+ std::map< _AString, ExportedMeshData > myFile2ExportedMesh;
+ Handle( _pyHypothesisReader ) myHypReader;
DEFINE_STANDARD_RTTI (_pyGen)
};
class _pyMesh: public _pyObject
{
std::list< Handle(_pyHypothesis) > myHypos;
- std::list< Handle(_pyCommand) > myAddHypCmds;
+ std::list< Handle(_pyCommand) > myAddHypCmds, myNotConvertedAddHypCmds;
std::list< Handle(_pySubMesh) > mySubmeshes;
std::list< Handle(_pyGroup) > myGroups;
std::list< Handle(_pyMeshEditor)> myEditors;
_pyID myGeom, myMesh;
struct CreationMethod {
_AString myMethod; // method of algo or mesh creating a hyp
- // myArgNb(i)-th arg of myArgMethods(i) of hyp becomes an i-th arg of myAlgoMethod
+ // myArgNb(i)-th arg of myArgMethods(i) of hyp becomes an i-th arg of myMethod
std::vector<_AString> myArgMethods;
std::vector<int> myArgNb; // arg nb countered from 1
std::vector<_AString> myArgs; // creation arguments
// a hypothesis can be created by different algos by different methods
typedef std::map<_AString, CreationMethod > TType2CrMethod;
TType2CrMethod myAlgoType2CreationMethod;
+ std::set< _AString > myAccumulativeMethods;
CreationMethod* myCurCrMethod; // used for adding to myAlgoType2CreationMethod
std::list<Handle(_pyCommand)> myArgCommands;
std::list<Handle(_pyCommand)> myUnusedCommands;
void AddArgMethod(const _AString& method, const int argNb = 1)
{ myCurCrMethod->myArgMethods.push_back( method );
myCurCrMethod->myArgNb.push_back( argNb ); }
+ void AddAccumulativeMethod( const _AString& method)
+ { myAccumulativeMethods.insert( method ); }
//const TColStd_SequenceOfAsciiString& GetArgs() const { return myArgs; }
const std::list<Handle(_pyCommand)>& GetArgCommands() const { return myArgCommands; }
void ClearAllCommands();
// -------------------------------------------------------------------------------------
class _pySelfEraser: public _pyObject
{
+ bool myIgnoreOwnCalls; // not to erase only if this obj is used as argument
public:
- _pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
- :_pyObject(theCreationCmd) { myIsPublished = true; }
+ _pySelfEraser(const Handle(_pyCommand)& theCreationCmd);
+ void IgnoreOwnCalls() { myIgnoreOwnCalls = true; }
virtual void Flush();
DEFINE_STANDARD_RTTI (_pySelfEraser)
class _pyFilter: public _pyObject
{
_pyID myNewID, myMesh;
- std::list< Handle(_pyObject) > myUsers;
+ //std::list< Handle(_pyObject) > myUsers;
public:
_pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID="");
- void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
+ //void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
virtual void Process( const Handle(_pyCommand)& theCommand);
virtual void Flush();
- virtual bool CanClear();
- virtual void Free() { myUsers.clear(); }
+ //virtual bool CanClear();
+ //virtual void Free() { myUsers.clear(); }
const _pyID& GetNewID() const { return myNewID; }
DEFINE_STANDARD_RTTI (_pyFilter)
virtual void Process( const Handle(_pyCommand)& theCommand);
virtual void Flush();
virtual void Free() { myFilter.Nullify(); }
+ virtual bool CanClear();
+ void RemovedWithContents();
DEFINE_STANDARD_RTTI (_pyGroup)
};
