void _ConditionFunction_Register_Print(void* conditionFunction_Register, Stream* stream)
{
ConditionFunction_Register* self = (ConditionFunction_Register*)conditionFunction_Register;
/* Set the Journal for printing informations */
Stream* conditionFunction_RegisterStream = stream;
/* General info */
Journal_Printf( conditionFunction_RegisterStream, "ConditionFunction_Register (ptr): %p\n", self);
/* Virtual info */
/* ConditionFunction_Register info */
Journal_Printf( conditionFunction_RegisterStream, "\tcount: %u\n", self->count);
Journal_Printf( conditionFunction_RegisterStream, "\t_size: %lu\n", self->_size);
Journal_Printf( conditionFunction_RegisterStream, "\t_delta: %lu\n", self->_delta);
Journal_Printf( conditionFunction_RegisterStream, "\t_cf (ptr): %p\n", self->_cf);
if (self->_cf)
{
ConditionFunction_Index cf_I;
for (cf_I = 0; cf_I < self->count; cf_I++)
Journal_Printf( conditionFunction_RegisterStream, "\t\t_cf[%u]: %p\n", cf_I, self->_cf[cf_I]);
}
/* Parent class info */
_Stg_Class_Print( self, conditionFunction_RegisterStream );
}
void _TestSuite_Print( void* testSuite, struct Stream* stream ) {
TestSuite* self = (TestSuite*)testSuite;
/* Print parent */
Journal_Printf( stream, "TestSuite (ptr): (%p)\n", self );
_Stg_Class_Print( self, stream );
}
void _EntryPoint_Register_Print( void* entryPoint_Register, Stream* stream ) {
EntryPoint_Register* self = (EntryPoint_Register*)entryPoint_Register;
#ifdef DEBUG
EntryPoint_Index entryPoint_I;
#endif
/* General info */
Journal_Printf( (void*) stream, "EntryPoint_Register (ptr): %p\n", self );
/* Print parent */
_Stg_Class_Print( self, stream );
/* Virtual info */
/* EntryPoint_Register info */
Journal_Printf( (void*) stream, "\tcount: %u\n", self->count );
Journal_Printf( (void*) stream, "\t_size: %lu\n", self->_size );
Journal_Printf( (void*) stream, "\t_delta: %lu\n", self->_delta );
Journal_Printf( (void*) stream, "\tentryPoint (ptr): %p\n", self->entryPoint );
Journal_Printf( (void*) stream, "\tentryPoint[0-%u]:\n", self->count );
#ifdef DEBUG
for( entryPoint_I = 0; entryPoint_I < self->count; entryPoint_I++ ) {
Journal_Printf( (void*) stream, "entryPoint[%u]: ", entryPoint_I );
Stg_Class_Print( self->entryPoint[entryPoint_I], stream);
}
#else
Journal_Printf( (void*) stream, "...\n" );
#endif
Journal_Printf( (void*) stream, "\t]\n" );
}
void _LinkedDofInfo_Print( void* linkedDofInfo, Stream* stream ) {
LinkedDofInfo* self = (LinkedDofInfo*)linkedDofInfo;
Index dofSet_I = 0;
Node_Index node_I = 0;
Dof_Index nodeLocalDof_I = 0;
/* General info */
Journal_Printf( stream, "LinkedDofInfo (ptr): %p\n", self );
/* Print parent */
_Stg_Class_Print( self, stream );
Journal_Printf( stream, "%d Linked dof sets active:\n", self->linkedDofSetsCount );
Stream_Indent( stream );
for ( dofSet_I = 0; dofSet_I < self->linkedDofSetsCount; dofSet_I++ ) {
Journal_Printf( stream, "Set %u: has eqNum %d\n", dofSet_I, self->eqNumsOfLinkedDofs[dofSet_I] );
}
Stream_UnIndent( stream );
Journal_Printf( stream, "Linked dof sets table:\n", self->linkedDofSetsCount );
Stream_Indent( stream );
for ( node_I = 0; node_I < self->dofLayout->_numItemsInLayout; node_I++ ) {
Journal_Printf( stream, "Node %d: ", node_I );
for ( nodeLocalDof_I = 0; nodeLocalDof_I < self->dofLayout->dofCounts[node_I]; nodeLocalDof_I++ ) {
Journal_Printf( stream, "%d, ", self->linkedDofTbl[node_I][nodeLocalDof_I] );
}
Journal_Printf( stream, "\n" );
}
Stream_UnIndent( stream );
}
void _EntryPoint_Print( void* entryPoint, Stream* stream ) {
EntryPoint* self = (EntryPoint*)entryPoint;
#if DEBUG
assert( self );
assert( stream );
#endif
/* General info */
Journal_Printf( (void*) stream, "EntryPoint (ptr) (%p):\n", self );
/* Virtual info */
Journal_Printf( (void*) stream, "\t_getRun (ptr): %p\n", self->_getRun );
/* EntryPoint info */
Journal_Printf( (void*) stream, "\tname: %s\n", self->name );
Journal_Printf( (void*) stream, "\tcastType: %u\n", self->castType );
Journal_Printf( (void*) stream, "\trun (ptr): %p\n", self->run );
Journal_Printf( (void*) stream, "\thooks: \n" );
Stg_Class_Print( self->hooks, stream );
Journal_Printf( (void*) stream, "\n" );
/* Print parent */
_Stg_Class_Print( self, stream );
}
void _Variable_Register_Print(void* variable_Register, Stream* stream)
{
Variable_Register* self = (Variable_Register*)variable_Register;
/* Set the Journal for printing informations */
Stream* variable_RegisterStream = Journal_Register( InfoStream_Type, "Variable_RegisterStream");
/* General info */
Journal_Printf( variable_RegisterStream, "Variable_Register (ptr): %p\n", self);
/* Virtual info */
/* Stg_Class info */
Journal_Printf( variable_RegisterStream, "\tcount: %u\n", self->count);
Journal_Printf( variable_RegisterStream, "\t_size: %lu\n", self->_size);
Journal_Printf( variable_RegisterStream, "\t_delta: %lu\n", self->_delta);
Journal_Printf( variable_RegisterStream, "\t_variable (ptr): %p\n", self->_variable);
if (self->_variable)
{
Variable_Index var_I;
for (var_I = 0; var_I < self->count; var_I++)
Stg_Class_Print(self->_variable[var_I], stream);
}
/* Print parent */
_Stg_Class_Print(self, variable_RegisterStream);
}
/* Print implementation */
void _Stg_ObjectList_Print( void* objectList, struct Stream* stream ) {
Stg_ObjectList* self = (Stg_ObjectList*) objectList;
/* General info */
Journal_Printf( stream, "Stg_ObjectList (ptr):%p\n", (void*)self );
Stream_Indent( stream );
/* Print parent class */
_Stg_Class_Print( self, stream );
/* Virtual info */
Journal_Printf( stream, "_append(func ptr): %p\n", (void*)self->_append );
Journal_Printf( stream, "_prepend(func ptr): %p\n", (void*)self->_prepend );
Journal_Printf( stream, "_replaceAll(func ptr): %p\n", (void*)self->_replaceAll );
Journal_Printf( stream, "_replace(func ptr): %p\n", (void*)self->_replace );
Journal_Printf( stream, "_insertBefore(func ptr): %p\n", (void*)self->_insertBefore );
Journal_Printf( stream, "_insertAfter(func ptr): %p\n", (void*)self->_insertAfter );
Journal_Printf( stream, "_remove(func ptr): %p\n", (void*)self->_remove );
Journal_Printf( stream, "_getIndex(func ptr): %p\n", (void*)self->_getIndex );
Journal_Printf( stream, "_get(func ptr): %p\n", (void*)self->_get );
Journal_Printf( stream, "_allocMoreMemory(func ptr): %p\n", (void*)self->_allocMoreMemory );
Journal_Printf( stream, "_insertAtIndex(func ptr): %p\n", (void*)self->_insertAtIndex );
Journal_Printf( stream, "_removeByIndex(func ptr): %p\n", (void*)self->_removeByIndex );
Journal_Printf( stream, "_deleteAllObjects(func ptr): %p\n", (void*)self->_deleteAllObjects );
/* Stg_ObjectList */
Journal_Printf( stream, "_size: %u\n", self->_size );
Journal_Printf( stream, "_delta: %u\n", self->_delta );
Journal_Printf( stream, "_noJournalingInCopy: %u\n", self->_noJournalingInCopy );
Journal_Printf( stream, "count: %u\n", self->count );
Journal_Printf( stream, "data[0-%d]:\n", self->count );
Stg_ObjectList_PrintAllObjects( self, stream );
Stream_UnIndent( stream );
}
void _ModulesManager_Print( void* modulesManager, Stream* stream ) {
ModulesManager* self = (ModulesManager*)modulesManager;
Index i;
/* General info */
Journal_Printf( (void*) stream, "%s (ptr): %p\n", ModulesManager_Type, self );
/* Print parent */
_Stg_Class_Print( self, stream );
if( moduleDirectories->count > 0 ) {
Journal_Printf( stream, "Search Path:\n" );
Stream_Indent( stream );
for( i = 0; i < moduleDirectories->count; ++i ) {
Journal_Printf( stream, "(path) %s\n", Stg_ObjectList_ObjectAt( moduleDirectories, i ) );
}
Stream_UnIndent( stream );
}
if( self->modules->count > 0 ) {
Journal_Printf( stream, "Loaded modules:\n" );
Stream_Indent( stream );
for( i = 0; i < self->modules->count; ++i ) {
Module* module = (Module*)Stg_ObjectList_At( self->modules, i );
Journal_Printf( stream, "%s\n", module->name );
}
Stream_UnIndent( stream );
}
}
void _UIntMap_Print( void* generator, Stream* stream ) {
UIntMap* self = (UIntMap*)generator;
/* Set the Journal for printing informations */
Stream* generatorStream;
generatorStream = Journal_Register( InfoStream_Type, "UIntMapStream" );
/* Print parent */
Journal_Printf( stream, "UIntMap (ptr): (%p)\n", self );
_Stg_Class_Print( self, stream );
}
void _Sync_Print( void* sync, Stream* stream ) {
Sync* self = (Sync*)sync;
/* Print parent */
_Stg_Class_Print( self, stream );
/* General info */
Journal_Printf( stream, "Sync (ptr): (%p)\n", self );
/* Virtual info */
/* Sync info */
}
void _LinkedListIterator_PrintFunc( void *self, Stream *myStream )
{
LinkedListIterator *iterator = NULL;
iterator = (LinkedListIterator*) self;
assert( iterator );
/* print parent */
_Stg_Class_Print( (void*) iterator, myStream );
/* general info */
Journal_Printf( myStream, "LinkedListIterator (ptr): (%p)\n", iterator );
Journal_Printf( myStream, "\tlist (ptr): (%p)\n", iterator->list );
}
void _LiveComponentRegister_Print( void* liveComponentRegister, Stream* stream ) {
LiveComponentRegister *self = (LiveComponentRegister *) liveComponentRegister;
assert( self );
/* General info */
Journal_Printf( (void*)stream, "LiveComponentRegister (ptr): %p\n", self );
/* Print parent class */
_Stg_Class_Print( self, stream );
Journal_Printf( (void*)stream, "componentList (ptr): %p\n", self->componentList );
Stg_Class_Print( self->componentList, stream );
}
void _Heap_PrintFunc ( void *heap, Stream* stream )
{
_Heap *self = (_Heap*)heap;
assert( self );
/* print parent */
_Stg_Class_Print( (void*) self, stream );
/* general info */
Journal_Printf( stream, "Heap (ptr): (%p)\n", self );
Journal_Printf( stream, "Heap Elements\t%d\n", self->numHeapElements );
Journal_Printf( stream, "Array Elements\t%d\n", self->numArrayElements );
Journal_Printf( stream, "Key Length \t%d\n", self->keyLength );
}
void _Stg_ComponentFactory_Print( void* cf, Stream* stream )
{
Stg_ComponentFactory *self = (Stg_ComponentFactory*) cf;
assert( self );
/* General info */
Journal_Printf( (void*) stream, "Stg_ComponentFactory (ptr): %p\n", self );
/* Print parent class */
_Stg_Class_Print( self, stream );
Journal_Printf( (void*) stream, "LiveComponentRegister (ptr): %p\n", self->LCRegister );
Stg_Class_Print( self->LCRegister, stream );
}
void _NamedObject_Register_Print( void* namedObjectRegister, struct Stream* stream ) {
NamedObject_Register* self = (NamedObject_Register*)namedObjectRegister;
/* General info */
Journal_Printf( stream, "NamedObject_Register (ptr): %p\n", self);
Stream_Indent( stream );
/* Use parent print */
_Stg_Class_Print( self, stream );
/* Print the list of registered objects */
Stg_Class_Print( self->objects, stream );
Stream_UnIndent( stream );
}
void _LineFormatter_Print( void* formatter, Stream* stream )
{
LineFormatter* self = (LineFormatter*) formatter;
#if DEBUG
assert( self );
assert (stream);
#endif
/* General info */
printf( "LineFormatter (ptr): %p\n", formatter );
/* Print parent */
_Stg_Class_Print( self, stream );
/* print _newLine and _tag */
}
void _StreamFormatter_Print( void* formatter, Stream* stream )
{
StreamFormatter* self = (StreamFormatter*) formatter;
#if DEBUG
assert( self );
assert( stream );
#endif
/* General info */
printf( "StreamFormatter (ptr): %p\n", formatter );
/* Print parent */
_Stg_Class_Print( self, stream );
/* Virtual info */
printf( "\t_format (func ptr): %p\n", (void*)self->_format );
printf( "\t_copy (func ptr): %p\n", (void*)self->_copy );
printf( "\t_stream (ptr): %p\n", (void*)self->_stream );
}
void _ConditionFunction_Print( void* conditionFunction, Stream* stream ) {
ConditionFunction* self = (ConditionFunction*)conditionFunction;
/* Set the Journal for printing informations */
Stream* conditionFunctionStream = stream;
/* General info */
Journal_Printf( conditionFunctionStream, "ConditionFunction (ptr): %p\n", self );
/* Virtual info */
/* Stg_Class info */
Journal_Printf( conditionFunctionStream, "\tapply (func ptr): %p\n", self->apply );
Journal_Printf( conditionFunctionStream, "\tname (ptr): %p\n", self->name );
if (self->name)
Journal_Printf( conditionFunctionStream, "\t\tname: %s\n", self->name );
/* Print parent class */
_Stg_Class_Print( self, conditionFunctionStream );
}
/*----------------------------------------------------------------------------------------------------------------------------------
** Virtual Functions
*/
void _MemoryPool_PrintFunc ( void *memPool, Stream *stream )
{
MemoryPool *self = NULL;
self = (MemoryPool*) memPool;
assert( self );
assert( stream );
/* print parent */
_Stg_Class_Print( (void*) self, stream );
/* general info */
Journal_Printf( stream, "MemoryPool (ptr): (%p)\n", self );
/* Virtual Info */
/* MemoryPool Info */
Journal_Printf( stream, "\tElementSize\t\t - %d\n", self->elementSize );
Journal_Printf( stream, "\tNumElememts\t\t - %d\n", self->numElements );
Journal_Printf( stream, "\tNumElememtsFree\t\t - %d\n", self->numElementsFree );
}
void _IndexMap_Print( void* indexMap, Stream* stream ) {
IndexMap* self = (IndexMap*)indexMap;
unsigned tuple_I;
/* Set the Journal for printing informations */
Stream* myStream;
myStream = Journal_Register( InfoStream_Type, "IndexMapStream" );
/* Print parent */
assert( self );
_Stg_Class_Print( self, stream );
/* General info */
Journal_Printf( myStream, "IndexMap (ptr): (%p)\n", self );
/* Virtual info */
/* IndexMap info */
for( tuple_I = 0; tuple_I < self->tupleCnt; tuple_I++ ) {
Journal_Printf( myStream, "\ttuple[%d]: %d -> %d\n", tuple_I, self->tupleTbl[tuple_I].key, self->tupleTbl[tuple_I].idx );
}
}
void _ParticleLayout_Print( void* particleLayout, Stream* stream ) {
ParticleLayout* self = (ParticleLayout*)particleLayout;
Journal_Printf( stream, "ParticleLayout (ptr): %p\n", self );
/* Parent class info */
_Stg_Class_Print( self, stream );
/* Virtual info */
Journal_Printf( stream, "\t_setInitialCounts (func ptr): %p\n", self->_setInitialCounts );
Journal_Printf( stream, "\t_initialiseParticles (func ptr): %p\n", self->_initialiseParticles );
/* ParticleLayout info */
Journal_Printf(
stream,
"\tcoordSystem: %s\n",
( self->coordSystem == LocalCoordSystem ) ? "LocalCoordSystem" : "GlobalCoordSystem" );
Journal_Printf(
stream,
"\tweightsInitialisedAtStartup : %s\n",
self->weightsInitialisedAtStartup ? "True" : "False" );
}
