Exemple #1
0
void IJK6Topology_Init(
		IJK6Topology*					self,
		Name						name,
		Dictionary*					dictionary,
		IJK						size,
		Bool						isPeriodic[3] )
{
	/* General info */
	self->type = IJK6Topology_Type;
	self->_sizeOfSelf = sizeof(IJK6Topology);
	self->_deleteSelf = False;
	self->dictionary = dictionary;
	
	/* Virtual info */
	self->_delete = _IJK6Topology_Delete;
	self->_print = _IJK6Topology_Print;
	self->_copy = _IJKTopology_Copy;
	self->_defaultConstructor = (Stg_Component_DefaultConstructorFunction*)IJK6Topology_DefaultNew;
	self->_construct = _IJK6Topology_Construct;
	self->_build = _IJK6Topology_Build,
	self->_initialise = _IJK6Topology_Initialise;
	self->_execute = _IJK6Topology_Execute;
	self->_destroy = _IJK6Topology_Destroy;
	self->neighbourCount = _IJK6Topology_NeighbourCount;
	self->buildNeighbours = _IJK6Topology_BuildNeighbours;

	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	
	/* IJK6Topology info */
	_Topology_Init( (Topology*)self );
	_IJKTopology_Init( (IJKTopology*)self, size, isPeriodic, False );
	_IJK6Topology_Init( self );
}
Exemple #2
0
void Sync_Init( Sync* self,
		Dictionary* dictionary, Name name )
{
	/* General info */
	self->type = Sync_Type;
	self->_sizeOfSelf = sizeof(Sync);
	self->_deleteSelf = False;
	self->dictionary = dictionary;
	
	/* Virtual info */
	self->_delete = _Sync_Delete;
	self->_print = _Sync_Print;
	self->_copy = NULL;
	self->_defaultConstructor = Sync_DefaultNew;
	self->_construct = _Sync_Construct;
	self->_build = _Sync_Build;
	self->_initialise = _Sync_Initialise;
	self->_execute = _Sync_Execute;
	self->_destroy = _Sync_Destroy;
	
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	
	/* Sync info */
	_Sync_Init( self );
}
Exemple #3
0
Stg_Class* _Stg_Class_New( SizeT _sizeOfSelf, 
		Type				type, 
		Stg_Class_DeleteFunction*	_delete, 
		Stg_Class_PrintFunction*	_print, 
		Stg_Class_CopyFunction*		_copy )
{
	Stg_Class*		self;
	
	/* Allocate memory */
	assert( _sizeOfSelf >= sizeof(Stg_Class) );
	self = (Stg_Class*)Memory_Alloc_Bytes_Unnamed( _sizeOfSelf, type );
	memset( self, 0, _sizeOfSelf );
	self->_sizeOfSelf = _sizeOfSelf;
	self->_deleteSelf = True;

	/* Init count to for this pointer to one. */
	Memory_CountInc( self );
	
	/* General info */
	self->type = type;
	
	/* Virtual functions */
	self->_delete = _delete;
	self->_print = _print;
	self->_copy = _copy;
	
	/* Stg_Class info */
	_Stg_Class_Init( self );
	
	return self;
}
Exemple #4
0
void MeshLayout_Init(
		MeshLayout*					self,
		Name						name,
		ElementLayout*				elementLayout,
		NodeLayout*					nodeLayout,
		MeshDecomp*					decomp )
{
	/* General info */
	self->type = MeshLayout_Type;
	self->_sizeOfSelf = sizeof(MeshLayout);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _MeshLayout_Delete;
	self->_print = _MeshLayout_Print;
	self->_copy = _MeshLayout_Copy;
	self->_defaultConstructor = (Stg_Component_DefaultConstructorFunction*)MeshLayout_DefaultNew;
	self->_construct = _MeshLayout_Construct;
	self->_build = _MeshLayout_Build;
	self->_initialise = _MeshLayout_Initialise;
	self->_execute = _MeshLayout_Execute;
	self->_destroy = _MeshLayout_Destroy;
	
	/* MeshLayout info */

	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	_MeshLayout_Init( self, elementLayout, nodeLayout, decomp );
}
Exemple #5
0
void Stg_ObjectAdaptor_InitOfPointer( 
		Stg_ObjectAdaptor* 				self, 
		void*						dataPtr, 
		Name						name, 
		Bool						iOwn,
		Bool						isGlobal,
		Stg_ObjectAdaptor_DeletePointerFunction*	ptrDelete,
		Stg_ObjectAdaptor_PrintPointerFunction*		ptrPrint,
		Stg_ObjectAdaptor_CopyPointerFunction*		ptrCopy )
{
	/* General info */
	self->type = Stg_ObjectAdaptor_Type;
	self->_sizeOfSelf = sizeof(Stg_ObjectAdaptor);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _Stg_ObjectAdaptor_Delete;
	self->_print = _Stg_ObjectAdaptor_Print;
	self->_copy = _Stg_ObjectAdaptor_Copy;
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, GLOBAL );

	/* Stg_ObjectAdaptor info */
	_Stg_ObjectAdaptor_Init( self, dataPtr, iOwn, isGlobal, False, ptrDelete, ptrPrint, ptrCopy );
}
void Stg_ObjectList_Init2( Stg_ObjectList* self, Index initialSize, Index delta ) {
   /* General info */
   self->type = Stg_ObjectList_Type;
   self->_sizeOfSelf = sizeof(Stg_ObjectList);
   self->_deleteSelf = False;
   
   /* Virtual info */
   self->_delete = _Stg_ObjectList_Delete;
   self->_print = _Stg_ObjectList_Print;
   self->_copy = _Stg_ObjectList_Copy;
   self->_append = _Stg_ObjectList_Append;
   self->_prepend = _Stg_ObjectList_Prepend;
   self->_replaceAll = _Stg_ObjectList_ReplaceAll;
   self->_replace = _Stg_ObjectList_Replace; 
   self->_insertBefore = _Stg_ObjectList_InsertBefore;  
   self->_insertAfter = _Stg_ObjectList_InsertAfter;  
   self->_remove = _Stg_ObjectList_Remove;  
   self->_getIndex = _Stg_ObjectList_GetIndex;  
   self->_get = _Stg_ObjectList_Get;  
   self->_allocMoreMemory = _Stg_ObjectList_AllocMoreMemory;  
   self->_insertAtIndex = _Stg_ObjectList_InsertAtIndex;  
   self->_removeByIndex = _Stg_ObjectList_RemoveByIndex;  
   self->_deleteAllObjects = _Stg_ObjectList_DeleteAllObjects;
   _Stg_Class_Init( (Stg_Class*)self );
   _Stg_ObjectList_Init( (Stg_ObjectList*)self, initialSize, delta );

}
void RefinedRegionsGeometry_Init(
    RefinedRegionsGeometry*					self,
    Name						name,
    Dictionary*					dictionary )
{
    /* General info */
    self->type = RefinedRegionsGeometry_Type;
    self->_sizeOfSelf = sizeof(RefinedRegionsGeometry);
    self->_deleteSelf = False;
    self->dictionary = dictionary;

    /* Virtual info */
    self->_delete = _RefinedRegionsGeometry_Delete;
    self->_print = _RefinedRegionsGeometry_Print;
    self->_copy = _RefinedRegionsGeometry_Copy;
    self->_defaultConstructor = RefinedRegionsGeometry_DefaultNew;
    self->_construct = _RefinedRegionsGeometry_Construct;
    self->_build = _RefinedRegionsGeometry_Build;
    self->_initialise = _RefinedRegionsGeometry_Initialise;
    self->_execute = _RefinedRegionsGeometry_Execute;
    self->_destroy = _RefinedRegionsGeometry_Destroy;
    self->buildPoints = _RefinedRegionsGeometry_BuildPoints;
    self->pointAt = _RefinedRegionsGeometry_PointAt;

    _Stg_Class_Init( (Stg_Class*)self );
    _Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
    _Stg_Component_Init( (Stg_Component*)self );

    _Geometry_Init( (Geometry*)self );

    /* RefinedRegionsGeometry info */
    _RefinedRegionsGeometry_Init( self, NULL );
}
	/** Initialise a ParallelDelaunay */
void ParallelDelaunay_Init(
	ParallelDelaunay*					self,
	Name						name,
	Dictionary*					dictionary,
	CoordF						*sites,
	int							numSites,
	int							rank,
	int							numProcs,
	MPI_Comm					*comm,
	DelaunayAttributes			*attr )
{
	self->type = ParallelDelaunay_Type;
	self->_sizeOfSelf = sizeof( ParallelDelaunay );
	self->_deleteSelf = False;
	self->dictionary = dictionary;

	self->_delete = _ParallelDelaunay_Delete;
	self->_print = _ParallelDelaunay_Print;
	self->_copy = _ParallelDelaunay_Copy;
	self->_defaultConstructor = (Stg_Component_DefaultConstructorFunction*)ParallelDelaunay_DefaultNew;
	self->_construct = _ParallelDelaunay_Construct;
	self->_build = _ParallelDelaunay_Build;
	self->_initialise = _ParallelDelaunay_Initialise;
	self->_execute = _ParallelDelaunay_Execute;
	self->_destroy = _ParallelDelaunay_Destroy;

	self->attributes = Memory_Alloc_Unnamed( DelaunayAttributes );
	memcpy( self->attributes, attr, sizeof( DelaunayAttributes ) );
	self->attributes->BuildBoundingTriangle = 0;
	
	self->dictionary = dictionary;
	self->numSites = numSites;
	self->numInputSites = numSites;
	self->points = sites;
	self->leftProc = 0;
	self->rightProc = 0;
	self->haloSites[0] = NULL;
	self->haloSites[1] = NULL;
	self->localTriangulation = NULL;
	self->rank = rank;
	self->numProcs = numProcs;
	self->comm = comm;
	
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	_ParallelDelaunay_Init( self );
}
void ConditionFunction_Register_Init( ConditionFunction_Register* self ) { 
   /* General info */
   self->type = ConditionFunction_Register_Type;
   self->_sizeOfSelf = sizeof( ConditionFunction_Register );
   self->_deleteSelf = False;
   
   /* Virtual info */
   self->_delete = _ConditionFunction_Register_Delete;
   self->_print = _ConditionFunction_Register_Print;
   self->_copy = NULL;
   
   _Stg_Class_Init((Stg_Class*)self );
   
   /* Stg_Class info */
   _ConditionFunction_Register_Init( self );
}
void AnalyticFunction_Init( AnalyticFunction* self, AnalyticFunction_SolFunc* apply, Name name ) {
   /* General info */
   self->type = AnalyticFunction_Type;
   self->_sizeOfSelf = sizeof(AnalyticFunction);
   self->_deleteSelf = False;
   
   /* Virtual info */
   self->_delete = _AnalyticFunction_Delete;
   self->_print = _AnalyticFunction_Print;
   self->_copy = NULL;
   
   _Stg_Class_Init((Stg_Class*)self);
   
   /* Stg_Class info */
   _AnalyticFunction_Init( self, apply, name );
}
Exemple #11
0
void Stg_ObjectAdaptor_InitOfClass( Stg_ObjectAdaptor* self, void* dataPtr, Name name, Bool iOwn, Bool isGlobal ) {
	/* General info */
	self->type = Stg_ObjectAdaptor_Type;
	self->_sizeOfSelf = sizeof(Stg_ObjectAdaptor);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _Stg_ObjectAdaptor_Delete;
	self->_print = _Stg_ObjectAdaptor_Print;
	self->_copy = _Stg_ObjectAdaptor_Copy;
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );

	/* Stg_ObjectAdaptor info */
	_Stg_ObjectAdaptor_Init( self, dataPtr, iOwn, isGlobal, True, NULL, NULL, NULL );
}
void Variable_Register_Init(Variable_Register* self)
{ 
	/* General info */
	self->type = Variable_Register_Type;
	self->_sizeOfSelf = sizeof(Variable_Register);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _Variable_Register_Delete;
	self->_print = _Variable_Register_Print;
	self->_copy = _Variable_Register_Copy;
	
	_Stg_Class_Init((Stg_Class*)self);
	
	/* Stg_Class info */
	_Variable_Register_Init(self);
}
void EntryPoint_Register_Init( void* entryPoint_Register ) {
	EntryPoint_Register* self = (EntryPoint_Register*)entryPoint_Register;
	
	/* General info */
	self->type = EntryPoint_Register_Type;
	self->_sizeOfSelf = sizeof(EntryPoint_Register);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _EntryPoint_Register_Delete;
	self->_print = _EntryPoint_Register_Print;
	self->_copy = NULL;
	_Stg_Class_Init( (Stg_Class*)self );
	
	/* EntryPoint_Register info */
	_EntryPoint_Register_Init( self );
}
Exemple #14
0
void ClassHook_Init( void* hook, Name name, Func_Ptr funcPtr, char* addedBy, void* reference ) {
	ClassHook* self = (ClassHook*)hook;

	/* General info */
	self->type = ClassHook_Type;
	self->_sizeOfSelf = sizeof(ClassHook);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _ClassHook_Delete;
	self->_print = _ClassHook_Print;
	self->_copy = _ClassHook_Copy;
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	
	_ClassHook_Init( self, funcPtr, addedBy, reference );
}
void ConditionFunction_Init(ConditionFunction* self, ConditionFunction_ApplyFunc* apply, Name name)
{
	/* General info */
	self->type = ConditionFunction_Type;
	self->_sizeOfSelf = sizeof(ConditionFunction);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _ConditionFunction_Delete;
	self->_print = _ConditionFunction_Print;
	self->_copy = NULL;
	
	_Stg_Class_Init((Stg_Class*)self);
	
	/* Stg_Class info */
	_ConditionFunction_Init(self, apply, name);
}
Exemple #16
0
void IndexMap_Init(
		IndexMap*					self,
		unsigned					delta )
{
	/* General info */
	self->type = IndexMap_Type;
	self->_sizeOfSelf = sizeof(IndexMap);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _IndexMap_Delete;
	self->_print = _IndexMap_Print;
	self->_copy = NULL;
	_Stg_Class_Init( (Stg_Class*)self );
	
	/* IndexMap info */
	_IndexMap_Init( self, delta );
}
Exemple #17
0
void _MemoryPool_Init( MemoryPool* self ){
	int i = 0;
	
	/* General info */
	
	assert( self );
	_Stg_Class_Init ((Stg_Class*) self);
	
	self->elements = Memory_Alloc_Bytes_Unnamed( self->elementSize * self->numElements, char );
	memset( self->elements, 0, self->elementSize * self->numElements );

	self->pool = Memory_Alloc_Bytes_Unnamed( sizeof( char* ) * self->numElements, char* );
	memset( self->pool, 0, sizeof(char*) * self->numElements );
	
	for( i=0; i<self->numElements; i++ ){
		self->pool[i] = &(self->elements[i*self->elementSize]);
	}
}
/** Initialise an existing entry point. See EntryPoint_New() for argument descriptions. */
void EntryPoint_Init( void* entryPoint, const Name name, unsigned int castType ) {
   EntryPoint* self = (EntryPoint*)entryPoint;

   /* General info */
   self->type = EntryPoint_Type;
   self->_sizeOfSelf = sizeof(EntryPoint);
   self->_deleteSelf = False;
   
   /* Virtual info */
   self->_delete = _EntryPoint_Delete;
   self->_print = _EntryPoint_Print;
   self->_copy = _EntryPoint_Copy;
   self->_getRun = _EntryPoint_GetRun;
   _Stg_Class_Init( (Stg_Class*)self );
   _Stg_Object_Init( (Stg_Object*)self, (Name) name, GLOBAL );
   
   /* EntryPoint info */
   _EntryPoint_Init( self, castType );
}
Exemple #19
0
void FrictionVC_Init(
		FrictionVC*						self,
		Name						name,
		Name						_dictionaryEntryName, 
		Variable_Register*				variable_Register, 
		ConditionFunction_Register*			conFunc_Register, 
		Dictionary*					dictionary,
		void*						_mesh )
{
	/* General info */
	self->type = FrictionVC_Type;
	self->_sizeOfSelf = sizeof(FrictionVC);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _FrictionVC_Delete;
	self->_print = _FrictionVC_Print;
	self->_copy = _FrictionVC_Copy;
	self->_defaultConstructor = (Stg_Component_DefaultConstructorFunction*)FrictionVC_DefaultNew;
	self->_construct = _FrictionVC_Construct;
	self->_build = _FrictionVC_Build;
	self->_initialise = _VariableCondition_Initialise;
	self->_execute = _VariableCondition_Execute;
	self->_destroy = _VariableCondition_Destroy;
	self->_buildSelf = _FrictionVC_BuildSelf;
	self->_printConcise = _FrictionVC_PrintConcise;
	self->_readDictionary = _FrictionVC_ReadDictionary;
	self->_getSet = _FrictionVC_GetSet;
	self->_getVariableCount = _FrictionVC_GetVariableCount;
	self->_getVariableIndex = _FrictionVC_GetVariableIndex;
	self->_getValueIndex = _FrictionVC_GetValueIndex;
	self->_getValueCount = _FrictionVC_GetValueCount;
	self->_getValue = _FrictionVC_GetValue;
	
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	_VariableCondition_Init( (VariableCondition*)self, variable_Register, conFunc_Register, dictionary );
	
	/* Stg_Class info */
	_FrictionVC_Init( self, _dictionaryEntryName, _mesh );
}
void FeEntryPoint_Init( void* feEntryPoint, Name name, unsigned int castType ) {
	FeEntryPoint* self = (FeEntryPoint*)feEntryPoint;
	
	/* General info */
	self->type = FeEntryPoint_Type;
	self->_sizeOfSelf = sizeof(FeEntryPoint);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _EntryPoint_Delete;
	self->_print = _EntryPoint_Print;
	self->_copy = _EntryPoint_Copy;
	self->_getRun = _FeEntryPoint_GetRun;
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, GLOBAL );
	_EntryPoint_Init( (EntryPoint*)self, castType );
	
	/* FeEntryPoint info */
	_FeEntryPoint_Init( self );
}
void ContextEntryPoint_Init( void* contextEntryPoint, Name name, unsigned int castType ) {
	ContextEntryPoint* self = (ContextEntryPoint*)contextEntryPoint;
	
	/* General info */
	self->type = ContextEntryPoint_Type;
	self->_sizeOfSelf = sizeof(ContextEntryPoint);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _EntryPoint_Delete;
	self->_print = _EntryPoint_Print;
	self->_copy = NULL;
	self->_getRun = _ContextEntryPoint_GetRun;
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, GLOBAL );
	_EntryPoint_Init( (EntryPoint*)self, castType );
	
	/* ContextEntryPoint info */
	_ContextEntryPoint_Init( self );
}
Exemple #22
0
void UniqueList_Init(
		UniqueList*					self,
		SizeT						elementSize,
		unsigned					delta )
{
	/* General info */
	self->type = UniqueList_Type;
	self->_sizeOfSelf = sizeof(UniqueList);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _UniqueList_Delete;
	self->_print = _UniqueList_Print;
	self->_copy = NULL;
	self->_append = _UniqueList_Append;
	self->_mutate = _List_Mutate;
	_Stg_Class_Init( (Stg_Class*)self );
	_List_Init( (List*)self, elementSize, delta );
	
	/* UniqueList info */
	_UniqueList_Init( self );
}
Exemple #23
0
void SetVC_Init(
		SetVC*						self,
		Name						name,
		Name						_dictionaryEntryName, 
		Variable_Register*				variable_Register, 
		ConditionFunction_Register*			conFunc_Register,
		Dictionary*					dictionary )
{
	/* General info */
	self->type = SetVC_Type;
	self->_sizeOfSelf = sizeof(SetVC);
	self->_deleteSelf = False;
	
	/* Virtual info */
	self->_delete = _SetVC_Delete;
	self->_print = _SetVC_Print;
	self->_copy = _SetVC_Copy;
	self->_build = _VariableCondition_Build;
	self->_initialise = _VariableCondition_Initialise;
	self->_execute = _VariableCondition_Execute;
	self->_buildSelf = NULL;
	self->_printConcise = _SetVC_PrintConcise;
	self->_readDictionary = _SetVC_ReadDictionary;
	self->_getSet = _SetVC_GetSet;
	self->_getVariableCount = _SetVC_GetVariableCount;
	self->_getVariableIndex = _SetVC_GetVariableIndex;
	self->_getValueIndex = _SetVC_GetValueIndex;
	self->_getValueCount = _SetVC_GetValueCount;
	self->_getValue = _SetVC_GetValue;
	
	_Stg_Class_Init( (Stg_Class*)self );
	_Stg_Object_Init( (Stg_Object*)self, name, NON_GLOBAL );
	_Stg_Component_Init( (Stg_Component*)self );
	_VariableCondition_Init( (VariableCondition*)self, variable_Register, conFunc_Register, dictionary );
	
	
	/* Stg_Class info */
	_SetVC_Init( self,  _dictionaryEntryName );
}
void _MemoryPool_Init( MemoryPool* self ){
	int i = 0;
	
	/* General info */
	
	assert( self );
	_Stg_Class_Init ((Stg_Class*) self);
	
	assert( self->numMemChunks == 1 );

	self->chunks = (MemChunk*)Memory_Alloc_Bytes_Unnamed( sizeof(MemChunk)*self->numMemChunks, "char*" );
	self->chunks[self->numMemChunks-1].memory = (char*)Memory_Alloc_Bytes_Unnamed( self->elementSize * self->numElements, "char" );
	memset( self->chunks[self->numMemChunks-1].memory, 0, self->elementSize * self->numElements );
	self->chunks[self->numMemChunks-1].numFree = self->numElements;
	self->chunks[self->numMemChunks-1].maxFree = self->numElements;

	self->pool = (char**)Memory_Alloc_Bytes_Unnamed( sizeof( char* ) * self->numElements, "char*" );
	memset( self->pool, 0, sizeof(char*) * self->numElements );
	
	for( i=0; i<self->numElements; i++ ){
		self->pool[i] = &(self->chunks[self->numMemChunks-1].memory[i*self->elementSize]);
	}
}
void STree_Init( STree* self ) {
    _Stg_Class_Init( (Stg_Class*)self );
    _STree_Init( self );
}
void ISet_Init( ISet* self ) {
    _Stg_Class_Init( (Stg_Class*)self );
    _ISet_Init( self );
}
void ISetIter_Init( ISetIter* self ) {
    _Stg_Class_Init( (Stg_Class*)self );
    _Iter_Init( (Iter*)self );
    _ISetIter_Init( self );
}
void IGraph_Init( IGraph* self ) {
    _Stg_Class_Init( (Stg_Class*)self );
    _MeshTopology_Init( self );
    _IGraph_Init( self );
}