Class representing SegmentLengthAroundVertex hypothesis. More...

#include <SMESH_2smeshpy.hxx>

Inheritance diagram for _pySegmentLengthAroundVertexHyp:

Public Member Functions
	_pySegmentLengthAroundVertexHyp (const Handle(_pyCommand)&theCrCmd)
virtual bool	Addition2Creation (const Handle(_pyCommand)&theAdditionCmd, const _pyID &theMesh)
	Convert the command adding "SegmentLengthAroundVertex" to mesh into regular1D.LengthNearVertex( length, vertex )
void	SetConvMethodAndType (const char creationMethod, const char type)
void	AddArgMethod (const char *method, const int nbArgs=1)
const TColStd_SequenceOfAsciiString &	GetArgs () const
const std::list< Handle(_pyCommand)> &	GetArgCommands () const
void	ClearAllCommands ()
	clear creation, arg and unkown commands
virtual bool	IsAlgo () const
bool	IsValid () const
bool	IsWrapped () const
const _pyID &	GetGeom () const
void	SetMesh (const _pyID &theMeshId)
const _pyID &	GetMesh () const
const TCollection_AsciiString &	GetAlgoType () const
const TCollection_AsciiString &	GetAlgoCreationMethod () const
bool	CanBeCreatedBy (const TCollection_AsciiString &algoType) const
const TCollection_AsciiString &	GetCreationMethod (const TCollection_AsciiString &algoType) const
virtual bool	IsWrappable (const _pyID &theMesh)
const	Handle (_pyCommand)&GetCreationCmd()
void	Process (const Handle(_pyCommand)&theCommand)
	Remember hypothesis parameter values.
void	Flush ()
	Finish conversion.
virtual void	Assign (const Handle(_pyHypothesis)&theOther, const _pyID &theMesh)
	Assign fields of theOther to me except myIsWrapped.
const _pyID &	GetID ()
int	GetNbCalls () const
void	SetCreationCmd (Handle(_pyCommand) cmd)
int	GetCommandNb ()
virtual const char *	AccessorMethod () const
	Return method name giving access to an interaface object wrapped by python class.
Static Public Member Functions
static	Handle (_pyHypothesis) NewHypothesis(const Handle(_pyCommand)&theCreationCmd)
static _pyID	FatherID (const _pyID &childID)
	Return ID of a father.
Protected Attributes
bool	myIsAlgo
bool	myIsWrapped
_pyID	myGeom
_pyID	myMesh
std::map < TCollection_AsciiString, TCollection_AsciiString >	myType2CreationMethod
TColStd_SequenceOfAsciiString	myArgs
TColStd_SequenceOfAsciiString	myArgMethods
TColStd_SequenceOfInteger	myNbArgsByMethod
std::list< Handle(_pyCommand)>	myArgCommands
std::list< Handle(_pyCommand)>	myUnknownCommands

Detailed Description

Class representing SegmentLengthAroundVertex hypothesis.

Definition at line 412 of file SMESH_2smeshpy.hxx.

Constructor & Destructor Documentation

_pySegmentLengthAroundVertexHyp._pySegmentLengthAroundVertexHyp ( const Handle(_pyCommand)& theCrCmd )

Definition at line 415 of file SMESH_2smeshpy.hxx.

: _pyHypothesis(theCrCmd) {}

Member Function Documentation

const char * _pyObject::AccessorMethod ( ) const [virtual, inherited]

Return method name giving access to an interaface object wrapped by python class.

Return values:

const char* - method name

Reimplemented in _pyGen, _pyMesh, and _pyAlgorithm.

Definition at line 2484 of file SMESH_2smeshpy.cxx.

{
  return 0;
}

void _pyHypothesis.AddArgMethod	(	const char *	method,
		const int	nbArgs = `1`
	)		`[inherited]`

Definition at line 305 of file SMESH_2smeshpy.hxx.

  { myArgMethods.Append( (char*)method ); myNbArgsByMethod.Append( nbArgs ); }

bool _pySegmentLengthAroundVertexHyp::Addition2Creation	(	const Handle(_pyCommand)&	theCmd,
		const _pyID &	theMeshID
	)		`[virtual]`

Convert the command adding "SegmentLengthAroundVertex" to mesh into regular1D.LengthNearVertex( length, vertex )

Parameters:

theCmd	- The command like mesh.AddHypothesis( vertex, SegmentLengthAroundVertex )
theMesh	- The mesh needing this hypo

Return values:

bool	- false if the command cant be converted

Reimplemented from _pyHypothesis.

Definition at line 1905 of file SMESH_2smeshpy.cxx.

References ex01_cube2build.algo, _pyObject.FatherID(), SMESH_box.geom, _pyCommand.GetArg(), _pyHypothesis.Handle(), _pyHypothesis.IsWrappable(), _pyHypothesis.myArgs, and _pyCommand.SetArg().

{
  if ( IsWrappable( theMeshID )) {

    _pyID vertex = theCmd->GetArg( 1 );

    // the problem here is that segment algo will not be found
    // by pyHypothesis::Addition2Creation() for <vertex>, so we try to find
    // geometry where segment algorithm is assigned
    Handle(_pyHypothesis) algo;
    _pyID geom = vertex;
    while ( algo.IsNull() && !geom.IsEmpty()) {
      // try to find geom as a father of <vertex>
      geom = FatherID( geom );
      algo = theGen->FindAlgo( geom, theMeshID, this );
    }
    if ( algo.IsNull() )
      return false; // also possible to find geom as brother of veretex...
    // set geom instead of vertex
    theCmd->SetArg( 1, geom );

    // set vertex as a second arg
    if ( myArgs.Length() < 1) myArgs.Append( "1" ); // :(
    myArgs.Append( vertex );

    // mesh.AddHypothesis(vertex, SegmentLengthAroundVertex) -->
    // theMeshID.LengthNearVertex( length, vertex )
    return _pyHypothesis::Addition2Creation( theCmd, theMeshID );
  }
  return false;
}

void _pyHypothesis::Assign	(	const Handle(_pyHypothesis)&	theOther,
		const _pyID &	theMesh
	)		`[virtual, inherited]`

Assign fields of theOther to me except myIsWrapped.

Definition at line 1647 of file SMESH_2smeshpy.cxx.

References _pyHypothesis.myArgCommands, _pyHypothesis.myArgMethods, _pyHypothesis.myArgs, _pyHypothesis.myGeom, _pyHypothesis.myIsAlgo, _pyHypothesis.myIsWrapped, _pyHypothesis.myMesh, _pyHypothesis.myNbArgsByMethod, _pyHypothesis.myType2CreationMethod, and _pyHypothesis.myUnknownCommands.

{
  myIsWrapped = false;
  myMesh = theMesh;

  // myCreationCmd = theOther->myCreationCmd;
  myIsAlgo = theOther->myIsAlgo;
  myGeom = theOther->myGeom;
  myType2CreationMethod = theOther->myType2CreationMethod;
  myArgs = theOther->myArgs;
  myArgMethods = theOther->myArgMethods;
  myNbArgsByMethod = theOther->myNbArgsByMethod;
  myArgCommands = theOther->myArgCommands;
  myUnknownCommands = theOther->myUnknownCommands;
}

bool _pyHypothesis.CanBeCreatedBy ( const TCollection_AsciiString & algoType ) const [inherited]

Definition at line 320 of file SMESH_2smeshpy.hxx.

  { return myType2CreationMethod.find( algoType ) != myType2CreationMethod.end(); }

void _pyHypothesis::ClearAllCommands ( ) [inherited]

clear creation, arg and unkown commands

Definition at line 1629 of file SMESH_2smeshpy.cxx.

References _pyHypothesis.myArgCommands, and _pyHypothesis.myUnknownCommands.

{
  GetCreationCmd()->Clear();
  list<Handle(_pyCommand)>::iterator cmd = myArgCommands.begin();
  for ( ; cmd != myArgCommands.end(); ++cmd )
    ( *cmd )->Clear();
  cmd = myUnknownCommands.begin();
  for ( ; cmd != myUnknownCommands.end(); ++cmd )
    ( *cmd )->Clear();
}

_pyID _pyObject::FatherID ( const _pyID & childID ) [static, inherited]

Return ID of a father.

Definition at line 2494 of file SMESH_2smeshpy.cxx.

Referenced by Addition2Creation().

{
  int colPos = childID.SearchFromEnd(':');
  if ( colPos > 0 )
    return childID.SubString( 1, colPos-1 );
  return "";
}

void _pyHypothesis::Flush ( ) [virtual, inherited]

Finish conversion.

Implements _pyObject.

Reimplemented in _pyComplexParamHypo, _pyLayerDistributionHypo, and _pyNumberOfSegmentsHyp.

Definition at line 1598 of file SMESH_2smeshpy.cxx.

References _pyGen.AddAlgoAccessorMethod(), _pyGen.AddMeshAccessorMethod(), _pyHypothesis.IsWrapped(), _pyHypothesis.myArgCommands, and _pyHypothesis.myUnknownCommands.

{
  if ( IsWrapped() ) {
  }
  else {
    list < Handle(_pyCommand) >::iterator cmd = myArgCommands.begin();
    for ( ; cmd != myArgCommands.end(); ++cmd ) {
      // Add access to a wrapped mesh
      theGen->AddMeshAccessorMethod( *cmd );
      // Add access to a wrapped algorithm
      theGen->AddAlgoAccessorMethod( *cmd );
    }
    cmd = myUnknownCommands.begin();
    for ( ; cmd != myUnknownCommands.end(); ++cmd ) {
      // Add access to a wrapped mesh
      theGen->AddMeshAccessorMethod( *cmd );
      // Add access to a wrapped algorithm
      theGen->AddAlgoAccessorMethod( *cmd );
    }
  }
  // forget previous hypothesis modifications
  myArgCommands.clear();
  myUnknownCommands.clear();
}

const TCollection_AsciiString& _pyHypothesis.GetAlgoCreationMethod ( ) const [inherited]

Definition at line 318 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Addition2Creation().

  { return myType2CreationMethod.begin()->second; }

const TCollection_AsciiString& _pyHypothesis.GetAlgoType ( ) const [inherited]

Definition at line 316 of file SMESH_2smeshpy.hxx.

Referenced by _pyLayerDistributionHypo.Addition2Creation(), and _pyHypothesis.Addition2Creation().

  { return myType2CreationMethod.begin()->first; }

const std::list<Handle(_pyCommand)>& _pyHypothesis.GetArgCommands ( ) const [inherited]

Definition at line 308 of file SMESH_2smeshpy.hxx.

{ return myArgCommands; }

const TColStd_SequenceOfAsciiString& _pyHypothesis.GetArgs ( ) const [inherited]

Definition at line 307 of file SMESH_2smeshpy.hxx.

{ return myArgs; }

int _pyObject.GetCommandNb ( ) [inherited]

Definition at line 167 of file SMESH_2smeshpy.hxx.

{ return myCreationCmd->GetOrderNb(); }

const TCollection_AsciiString& _pyHypothesis.GetCreationMethod ( const TCollection_AsciiString & algoType ) const [inherited]

Definition at line 322 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Addition2Creation().

  { return myType2CreationMethod.find( algoType )->second; }

const _pyID& _pyHypothesis.GetGeom ( ) const [inherited]

Definition at line 313 of file SMESH_2smeshpy.hxx.

{ return myGeom; }

const _pyID& _pyObject.GetID ( ) [inherited]

Definition at line 162 of file SMESH_2smeshpy.hxx.

Referenced by _pyMesh._pyMesh(), _pyAlgorithm.Addition2Creation(), _pyLayerDistributionHypo.Addition2Creation(), _pyHypothesis.Addition2Creation(), and _pyMesh.Flush().

{ return myCreationCmd->GetResultValue(); }

const _pyID& _pyHypothesis.GetMesh ( ) const [inherited]

Definition at line 315 of file SMESH_2smeshpy.hxx.

{ return myMesh; }

int _pyObject.GetNbCalls ( ) const [inherited]

Definition at line 165 of file SMESH_2smeshpy.hxx.

References _pyObject.myNbCalls.

Referenced by _pySubMesh.Flush(), and _pySelfEraser.Flush().

{ return myNbCalls; }

static _pyHypothesis.Handle ( _pyHypothesis ) const [static, inherited]

Referenced by Addition2Creation(), and _pyHypothesis.Addition2Creation().

const _pyObject.Handle ( _pyCommand ) [inherited]

Reimplemented in _pyGen, and _pyGen.

Definition at line 164 of file SMESH_2smeshpy.hxx.

{ return myCreationCmd; }

virtual bool _pyHypothesis.IsAlgo ( ) const [virtual, inherited]

Definition at line 310 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Addition2Creation().

{ return myIsAlgo; }

bool _pyHypothesis.IsValid ( ) const [inherited]

Definition at line 311 of file SMESH_2smeshpy.hxx.

{ return !myType2CreationMethod.empty(); }

virtual bool _pyHypothesis.IsWrappable ( const _pyID & theMesh ) [virtual, inherited]

Reimplemented in _pyAlgorithm.

Definition at line 324 of file SMESH_2smeshpy.hxx.

References _pyGen.theMesh.

Referenced by Addition2Creation(), _pyNumberOfSegmentsHyp.Addition2Creation(), and _pyHypothesis.Addition2Creation().

{ return !myIsWrapped && myMesh == theMesh; }

bool _pyHypothesis.IsWrapped ( ) const [inherited]

Definition at line 312 of file SMESH_2smeshpy.hxx.

Referenced by _pyNumberOfSegmentsHyp.Flush(), _pyComplexParamHypo.Flush(), and _pyHypothesis.Flush().

{ return myIsWrapped; }

void _pyHypothesis::Process ( const Handle(_pyCommand)& theCommand ) [virtual, inherited]

Remember hypothesis parameter values.

Parameters:

theCommand - The called hypothesis method

Reimplemented from _pyObject.

Reimplemented in _pyComplexParamHypo, and _pyLayerDistributionHypo.

Definition at line 1573 of file SMESH_2smeshpy.cxx.

References _pyCommand.GetArg(), _pyCommand.GetMethod(), _pyHypothesis.myArgCommands, _pyHypothesis.myArgMethods, _pyHypothesis.myArgs, _pyHypothesis.myIsAlgo, _pyHypothesis.myNbArgsByMethod, and _pyHypothesis.myUnknownCommands.

{
  ASSERT( !myIsAlgo );
  // set args
  int nbArgs = 0;
  for ( int i = 1; i <= myArgMethods.Length(); ++i ) {
    if ( myArgMethods( i ) == theCommand->GetMethod() ) {
      while ( myArgs.Length() < nbArgs + myNbArgsByMethod( i ))
        myArgs.Append( "[]" );
      for ( int iArg = 1; iArg <= myNbArgsByMethod( i ); ++iArg )
        myArgs( nbArgs + iArg ) = theCommand->GetArg( iArg ); // arg value
      myArgCommands.push_back( theCommand );
      return;
    }
    nbArgs += myNbArgsByMethod( i );
  }
  myUnknownCommands.push_back( theCommand );
}

void _pyHypothesis.SetConvMethodAndType	(	const char *	creationMethod,
		const char *	type
	)		`[inherited]`

Definition at line 303 of file SMESH_2smeshpy.hxx.

  { myType2CreationMethod[ (char*)type ] = (char*)creationMethod; }

void _pyObject.SetCreationCmd ( Handle(_pyCommand) cmd ) [inherited]

Definition at line 166 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Addition2Creation().

{ myCreationCmd = cmd; }

void _pyHypothesis.SetMesh ( const _pyID & theMeshId ) [inherited]

Definition at line 314 of file SMESH_2smeshpy.hxx.

{ if ( myMesh.IsEmpty() ) myMesh = theMeshId; }

Field Documentation

std::list<Handle(_pyCommand)> _pyHypothesis.myArgCommands [protected, inherited]

Definition at line 299 of file SMESH_2smeshpy.hxx.

Referenced by _pyLayerDistributionHypo.Addition2Creation(), _pyHypothesis.Addition2Creation(), _pyHypothesis.Assign(), _pyHypothesis.ClearAllCommands(), _pyNumberOfSegmentsHyp.Flush(), _pyLayerDistributionHypo.Flush(), _pyHypothesis.Flush(), _pyLayerDistributionHypo.Process(), _pyComplexParamHypo.Process(), and _pyHypothesis.Process().

TColStd_SequenceOfAsciiString _pyHypothesis.myArgMethods [protected, inherited]

Definition at line 297 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Assign(), and _pyHypothesis.Process().

TColStd_SequenceOfAsciiString _pyHypothesis.myArgs [protected, inherited]

Definition at line 296 of file SMESH_2smeshpy.hxx.

Referenced by Addition2Creation(), _pyNumberOfSegmentsHyp.Addition2Creation(), _pyHypothesis.Addition2Creation(), _pyHypothesis.Assign(), _pyComplexParamHypo.Process(), and _pyHypothesis.Process().

_pyID _pyHypothesis.myGeom [protected, inherited]

Definition at line 292 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Addition2Creation(), and _pyHypothesis.Assign().

bool _pyHypothesis.myIsAlgo [protected, inherited]

Definition at line 291 of file SMESH_2smeshpy.hxx.

Referenced by _pyAlgorithm._pyAlgorithm(), _pyHypothesis._pyHypothesis(), _pyHypothesis.Assign(), and _pyHypothesis.Process().

bool _pyHypothesis.myIsWrapped [protected, inherited]

Definition at line 291 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis._pyHypothesis(), _pyLayerDistributionHypo.Addition2Creation(), _pyHypothesis.Addition2Creation(), and _pyHypothesis.Assign().

_pyID _pyHypothesis.myMesh [protected, inherited]

Definition at line 292 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Assign().

TColStd_SequenceOfInteger _pyHypothesis.myNbArgsByMethod [protected, inherited]

Definition at line 298 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Assign(), and _pyHypothesis.Process().

std::map<TCollection_AsciiString, TCollection_AsciiString > _pyHypothesis.myType2CreationMethod [protected, inherited]

Definition at line 294 of file SMESH_2smeshpy.hxx.

Referenced by _pyHypothesis.Assign().

std::list<Handle(_pyCommand)> _pyHypothesis.myUnknownCommands [protected, inherited]

Definition at line 300 of file SMESH_2smeshpy.hxx.

Referenced by _pyNumberOfSegmentsHyp.Addition2Creation(), _pyHypothesis.Addition2Creation(), _pyHypothesis.Assign(), _pyHypothesis.ClearAllCommands(), _pyNumberOfSegmentsHyp.Flush(), _pyComplexParamHypo.Flush(), _pyHypothesis.Flush(), and _pyHypothesis.Process().

_pySegmentLengthAroundVertexHyp Class Reference

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation