void* _IndexMap_Copy( void* indexMap, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
IndexMap* self = (IndexMap*)indexMap;
IndexMap* newIndexMap;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newIndexMap = _Stg_Class_Copy( self, dest, deep, nameExt, map );
newIndexMap->dictionary = self->dictionary;
newIndexMap->delta = self->delta;
newIndexMap->maxTuples = self->maxTuples;
newIndexMap->tupleCnt = self->tupleCnt;
if( deep ) {
if( (newIndexMap->tupleTbl = PtrMap_Find( map, self->tupleTbl )) == NULL && self->tupleTbl ) {
newIndexMap->tupleTbl = Memory_Alloc_Array( IndexMapTuple, self->maxTuples, "IndexMap->tupleTbl" );
memcpy( newIndexMap->tupleTbl, self->tupleTbl, sizeof(IndexMapTuple) * self->maxTuples );
PtrMap_Append( map, self->tupleTbl, newIndexMap->tupleTbl );
}
}
else {
newIndexMap->tupleTbl = self->tupleTbl;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newIndexMap;
}
void* _LinearRegression_Copy( void* linearRegression, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
LinearRegression* self = (LinearRegression*)linearRegression;
LinearRegression* newLinearRegression;
newLinearRegression = _Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
return (void*)newLinearRegression;
}
void* _StreamFormatter_Copy( void* streamFormatter, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
StreamFormatter* self = (StreamFormatter*)streamFormatter;
StreamFormatter* newStreamFormatter;
newStreamFormatter = (StreamFormatter*)_Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
newStreamFormatter->_format = self->_format;
newStreamFormatter->_stream = NULL;
return newStreamFormatter;
}
void* _ParticleLayout_Copy( void* particleLayout, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
ParticleLayout* self = (ParticleLayout*)particleLayout;
ParticleLayout* newParticleLayout;
newParticleLayout = _Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
/* Virtual methods */
newParticleLayout->_setInitialCounts = self->_setInitialCounts;
newParticleLayout->_initialiseParticles = self->_initialiseParticles;
newParticleLayout->coordSystem = self->coordSystem;
newParticleLayout->weightsInitialisedAtStartup = self->weightsInitialisedAtStartup;
return (void*)newParticleLayout;
}
void* _Stg_ObjectList_Copy( void* namedObjectList, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
Stg_ObjectList* self = (Stg_ObjectList*) namedObjectList;
Stg_ObjectList* newObjectList;
newObjectList = (Stg_ObjectList*)_Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
newObjectList->_append = self->_append;
newObjectList->_prepend = self->_prepend;
newObjectList->_append = self->_append;
newObjectList->_replaceAll = self->_replaceAll;
newObjectList->_replace = self->_replace;
newObjectList->_insertBefore = self->_insertBefore;
newObjectList->_insertAfter = self->_insertAfter;
newObjectList->_remove = self->_remove;
newObjectList->_getIndex = self->_getIndex;
newObjectList->_get = self->_get;
newObjectList->_allocMoreMemory = self->_allocMoreMemory;
newObjectList->_insertAtIndex = self->_insertAtIndex;
newObjectList->_removeByIndex = self->_removeByIndex;
newObjectList->_deleteAllObjects = self->_deleteAllObjects;
newObjectList->count = self->count;
newObjectList->_size = self->_size;
newObjectList->_delta = self->_delta;
newObjectList->_noJournalingInCopy = self->_noJournalingInCopy;
/*
* As this class is used by the Journal backend, making Journal calls when used in the Journal backend,
* is problematic... in this case work around it. It seems to only be an issue for copying.
*/
if( self->_noJournalingInCopy ) {
assert( deep );
}
else {
Journal_Firewall( deep, Journal_Register( Error_Type, Stg_ObjectList_Type ), "Shallow copy not yet implemented\n");
}
if( deep ) {
unsigned obj_I;
newObjectList->data = (Stg_ObjectPtr*)Memory_Alloc_Array(
Stg_ObjectPtr,
newObjectList->_size,
"ObjectList->data" );
for( obj_I = 0; obj_I < newObjectList->count; obj_I++ ) {
newObjectList->data[obj_I] = (Stg_ObjectPtr)Stg_Class_Copy( self->data[obj_I], NULL, deep, nameExt, ptrMap );
}
}
return newObjectList;
}
void* _NamedObject_Register_Copy( void* namedObjectRegister, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
NamedObject_Register* self = (NamedObject_Register*)namedObjectRegister;
NamedObject_Register* newNamedObjectRegister;
newNamedObjectRegister = _Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
Journal_Firewall(
deep,
Journal_Register( Error_Type, NamedObject_Register_Type ),
"Shallow copy not yet implemented\n" );
if( deep ) {
newNamedObjectRegister->objects = Stg_Class_Copy( self->objects, NULL, deep, nameExt, ptrMap );
}
return newNamedObjectRegister;
}
void* _Variable_Register_Copy( void* vr, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
Variable_Register* self = (Variable_Register*)vr;
Variable_Register* newVariableRegister;
int ii;
newVariableRegister = (Variable_Register*)_Stg_Class_Copy( self, dest, deep, nameExt, ptrMap );
PtrMap_Append( ptrMap, self, newVariableRegister );
newVariableRegister->count = self->count;
newVariableRegister->_size = self->_size;
newVariableRegister->_variable = Memory_Alloc_Array( Variable*, self->_size, "Variable_Register->_variable" );
memset(newVariableRegister->_variable, 0, sizeof(Variable*)*self->_size);
for ( ii = 0; ii < self->count; ++ii ) {
if ( (newVariableRegister->_variable[ii] = (Variable*)PtrMap_Find( ptrMap, self->_variable[ii] )) == NULL ) {
newVariableRegister->_variable[ii] = (Variable*)Stg_Class_Copy( self->_variable[ii], NULL, deep, nameExt, ptrMap );
}
}
return newVariableRegister;
}
void* _LinkedDofInfo_Copy( void* linkedDofInfo, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
LinkedDofInfo* self = (LinkedDofInfo*)linkedDofInfo;
LinkedDofInfo* newLinkedDofInfo;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newLinkedDofInfo = _Stg_Class_Copy( self, dest, deep, nameExt, map );
/* Virtual methods */
newLinkedDofInfo->linkedDofSetsCount = self->linkedDofSetsCount;
newLinkedDofInfo->linkedDofSetsSize = self->linkedDofSetsSize;
newLinkedDofInfo->linkedDofSetsDelta = self->linkedDofSetsDelta;
if ( deep ) {
newLinkedDofInfo->dofLayout = (DofLayout*)Stg_Class_Copy( self->dofLayout, NULL, deep, nameExt, map );
newLinkedDofInfo->mesh = (Mesh*)Stg_Class_Copy( self->mesh, NULL, deep, nameExt, map );
if ( (newLinkedDofInfo->linkedDofTbl = PtrMap_Find( map, self->linkedDofTbl )) == NULL && self->linkedDofTbl ) {
Node_Index node_I;
Dof_Index dof_I;
newLinkedDofInfo->linkedDofTbl = Memory_Alloc_2DComplex( int, self->dofLayout->_numItemsInLayout, self->dofLayout->dofCounts, "linkedDofInfo->linkedDofTbl" );
for ( node_I = 0; node_I < self->dofLayout->_numItemsInLayout; node_I++ ) {
for ( dof_I = 0; dof_I < self->dofLayout->dofCounts[node_I]; dof_I++ ) {
newLinkedDofInfo->linkedDofTbl[node_I][dof_I] =
self->linkedDofTbl[node_I][dof_I];
}
}
PtrMap_Append( map, self->linkedDofTbl, newLinkedDofInfo->linkedDofTbl );
}
if ( (newLinkedDofInfo->eqNumsOfLinkedDofs = PtrMap_Find( map, self->eqNumsOfLinkedDofs )) == NULL && self->eqNumsOfLinkedDofs ) {
newLinkedDofInfo->eqNumsOfLinkedDofs = Memory_Alloc_Array( int, self->linkedDofSetsCount, "linkedDofInfo->eqNumsOfLinkedDofs" );
memcpy( newLinkedDofInfo->eqNumsOfLinkedDofs, self->eqNumsOfLinkedDofs, self->linkedDofSetsCount * sizeof(int) );
PtrMap_Append( map, self->eqNumsOfLinkedDofs, newLinkedDofInfo->eqNumsOfLinkedDofs );
}
void* _PeriodicBoundariesManager_Copy( void* periodicBCsManager, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
PeriodicBoundariesManager* self = (PeriodicBoundariesManager*)periodicBCsManager;
PeriodicBoundariesManager* newPeriodicBCsManager;
PtrMap* map = ptrMap;
Bool ownMap = False;
if( !map ) {
map = PtrMap_New( 10 );
ownMap = True;
}
newPeriodicBCsManager = _Stg_Class_Copy( self, dest, deep, nameExt, map );
newPeriodicBCsManager->count = self->count;
newPeriodicBCsManager->size = self->size;
newPeriodicBCsManager->delta = self->delta;
if ( deep ) {
newPeriodicBCsManager->dictionary = (Dictionary*)Stg_Class_Copy( self->dictionary, NULL, deep, nameExt, map );
newPeriodicBCsManager->mesh = (Mesh*)Stg_Class_Copy( self->mesh, NULL, deep, nameExt, map );
newPeriodicBCsManager->swarm = (Swarm*)Stg_Class_Copy( self->swarm, NULL, deep, nameExt, map );
newPeriodicBCsManager->debug = self->debug;
newPeriodicBCsManager->boundaries = Memory_Alloc_Array( PeriodicBoundary, self->size, "PeriodicBoundaries" );
memcpy( newPeriodicBCsManager->boundaries, self->boundaries, sizeof(PeriodicBoundary)*self->count );
}
else {
newPeriodicBCsManager->dictionary = self->dictionary;
newPeriodicBCsManager->mesh = self->mesh;
newPeriodicBCsManager->swarm = self->swarm;
newPeriodicBCsManager->boundaries = self->boundaries;
newPeriodicBCsManager->debug = self->debug;
}
if( ownMap ) {
Stg_Class_Delete( map );
}
return (void*)newPeriodicBCsManager;
}
