예제 #1
0
char* stgParseListAllCmdLineArg( int* argc, char** argv[] ) {
	Index                   arg_I;

	/* Loop over all the arguments from command line and reads all arguments of form "--help topic" */
	for( arg_I = 1 ; arg_I < *argc; arg_I++ ) {
		char*                   valueString = 0;
		char*                   argumentString = (*argv)[arg_I];
		const char*             preceedingString = "--list-all";
		unsigned int            preceedingStringLength = strlen( preceedingString );

		/* Check is string has preceeding string is "--list" if not then continue in loop */
		if( strncmp( preceedingString, argumentString , preceedingStringLength ) != 0 ) {
			continue;
		}
		if( strlen( argumentString ) != strlen( preceedingString ) ) {
			continue;
		}
		if( arg_I >= (*argc - 1) ) { /* "--list" is the last commandline argument */
			valueString = StG_Strdup( "" );
			stgRemoveCmdLineArg( argc, argv, arg_I ); /* first argument: --list */
			return valueString;
		}

		valueString = StG_Strdup( (*argv)[arg_I+1] );
		stgRemoveCmdLineArg( argc, argv, arg_I ); /* first argument: --list */
		stgRemoveCmdLineArg( argc, argv, arg_I ); /* second argument: topic */
		return valueString;		
	}

	return 0;
}
예제 #2
0
void _lucAxis_Init(
   lucAxis*                            self,
   Coord                               origin,
   float                               length,
   char*                               axes,
   char*                               labelX,
   char*                               labelY,
   char*                               labelZ,
   lucColour                           colourX,
   lucColour                           colourY,
   lucColour                           colourZ)
{
   int i;
   for (i=0; i<3; i++)
      self->axes[i] = False;
   if (strchr(axes, 'x')) self->axes[I_AXIS] = True;
   if (strchr(axes, 'y')) self->axes[J_AXIS] = True;
   if (strchr(axes, 'z')) self->axes[K_AXIS] = True;
   if (strchr(axes, 'X')) self->axes[I_AXIS] = True;
   if (strchr(axes, 'Y')) self->axes[J_AXIS] = True;
   if (strchr(axes, 'Z')) self->axes[K_AXIS] = True;

   self->length = length;

   self->labels[0] = StG_Strdup(labelX);
   self->labels[1] = StG_Strdup(labelY);
   self->labels[2] = StG_Strdup(labelZ);

   memcpy( self->origin, origin, sizeof(Coord) );
   memcpy( &(self->colours[0]), &colourX, sizeof(lucColour) );
   memcpy( &(self->colours[1]), &colourY, sizeof(lucColour) );
   memcpy( &(self->colours[2]), &colourZ, sizeof(lucColour) );
}
예제 #3
0
Stg_ObjectList* stgParseInputPathCmdLineArg( int* argc, char** argv[] ) {
	Index                   arg_I;
	Stg_ObjectList*		allInputPaths = Stg_ObjectList_New();

	/* Loop over all the arguments from command line and reads all arguments of form "--help topic" */
	for( arg_I = 1 ; arg_I < *argc; arg_I++ ) {
		char*                   valueString = 0;
		char*                   argumentString = (*argv)[arg_I];
		const char*             preceedingString = "--inputPath";
		unsigned int            preceedingStringLength = strlen( preceedingString );

		/* Check is string has preceeding string is "--inputPath" if not then continue in loop */
		if( strncmp( preceedingString, argumentString , preceedingStringLength ) != 0 ) {
			continue;
		}
		if( strlen( argumentString ) <= (strlen( preceedingString ) + 1) ) {
			/* i.e. it has = sign (maybe) but not an input path itself */
			continue;
		}
		if( strncmp( "=", &argumentString[preceedingStringLength], 1 ) != 0 ) {
			/* i.e. no = sign */
			continue;
		}

		valueString = StG_Strdup( &(*argv)[arg_I][preceedingStringLength+1] );
		stgRemoveCmdLineArg( argc, argv, arg_I ); /* name=value: --inputPath=??? */
		Stg_ObjectList_Append( allInputPaths, Stg_ObjectAdaptor_NewOfPointer( valueString, 0, True, False, deleteInputPathItem, 0, 0 ) );
	}

	return allInputPaths;
}
예제 #4
0
/** add a path to the search paths */
void File_AddPath( char* directory ) {
	Bool found;
	Index dir_i;

	/* Check if it is a valid path */
	if( !directory ) {
		return;
	}

	/* Check if dictionary already exists */
	if( _stgFilePaths == NULL ) {
		_stgFilePaths = Stg_ObjectList_New();
	}
	
	/* Add path to global list */
	found = False;
	for( dir_i =  0; dir_i < _stgFilePaths->count; dir_i++ ){
		if( strcmp( directory, (char*)Stg_ObjectList_ObjectAt( _stgFilePaths, dir_i ) ) == 0 ) {
			found = True;
		}
	}
	
	if( !found ) {
		Stg_ObjectList_PointerAppend( _stgFilePaths, StG_Strdup( directory ), directory, deleteInputPathItem, 0, 0 ); 
	}
}
예제 #5
0
void _FileParticleLayout_Init( void* particleLayout, Name filename )
{
	FileParticleLayout* self = (FileParticleLayout*) particleLayout;

	self->filename = StG_Strdup( filename );
	self->file        = NULL;
	self->errorStream = Journal_MyStream( Error_Type, self );
	_GlobalParticleLayout_Init( self, GlobalCoordSystem, False, 0, 0.0 );
}
void FieldVariable_SetUnits( void* fieldVariable, char* o_units ) {
   FieldVariable* self = (FieldVariable*)fieldVariable;

   /* Override any previously defined o_units */
   if(self->o_units) { 
      Memory_Free( self->o_units ); 
      self->o_units = NULL;
   }

   self->o_units = StG_Strdup( o_units );
}
예제 #7
0
Stg_Component* _Stg_ComponentFactory_PluginConstructByKey( 
   void*                  cf, 
   void*                  codelet, 
   Dictionary_Entry_Key   componentKey,
   Type                  type, 
   Bool                  isEssential,
   void*                  data ) 
{
   Stg_ComponentFactory*   self = (Stg_ComponentFactory*)cf;
   Stg_Component*            plugin = (Stg_Component*)codelet;
   Dictionary*               thisPluginDict = NULL;
   Dictionary*               pluginDict = (Dictionary*)Dictionary_Get( self->rootDict, "plugins" );
   Name                     componentName, redirect, pluginType;
   Dictionary_Entry_Value*   componentEntryVal;
   Index                     pluginIndex;
   Stream*                  errorStream = Journal_Register( Error_Type, self->type );

   Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_Component is NULL.\n", __func__ );

   /* Get this plugins Dictionary */
   for( pluginIndex = 0; pluginIndex < Dictionary_Entry_Value_GetCount( (Dictionary_Entry_Value*)pluginDict ); pluginIndex++ ) {
      thisPluginDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Entry_Value_GetElement( (Dictionary_Entry_Value*)pluginDict, pluginIndex ) );
      pluginType = StG_Strdup( Dictionary_GetString( thisPluginDict, "Type" ) );

      if( !strcmp( plugin->type, pluginType ) ){
         Memory_Free( pluginType );
         break;
      }
      Memory_Free( pluginType );
   }
   
   /* Get Dependency's Name */
   componentEntryVal = Dictionary_Get( thisPluginDict, componentKey );
   if ( componentEntryVal == NULL ) {
      Journal_Firewall( !isEssential, errorStream,
            "plugin '%s' cannot find essential component with key '%s'.\n", plugin->type, componentKey );
      Journal_PrintfL( self->infoStream, 2, "plugin '%s' cannot find non-essential component with key '%s'.\n", plugin->type, componentKey );
      return NULL;
   }
      
   componentName = Dictionary_Entry_Value_AsString( componentEntryVal );

   /* If we can find the component's name in the root dictionary, use that value instead. */
   if( self->rootDict ) {
      redirect = Dictionary_GetString_WithDefault( self->rootDict, componentName, "" );
      if( strcmp( redirect, "" ) )
         componentName = redirect;
   }

   return self->constructByName( self, componentName, type, isEssential, data );
}
예제 #8
0
int main( int argc, char* argv[] ) {
	MPI_Comm CommWorld;
	int rank;
	int numProcessors;
	Stream* stream;

	Stg_ObjectList* directories;
	PluginLoader* plugin;

	/* Initialise MPI, get world info */
	MPI_Init( &argc, &argv );
	MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
	MPI_Comm_size( CommWorld, &numProcessors );
	MPI_Comm_rank( CommWorld, &rank );

	BaseFoundation_Init( &argc, &argv );
	BaseIO_Init( &argc, &argv );
	BaseContainer_Init( &argc, &argv );
	BaseAutomation_Init( &argc, &argv );
	BaseExtensibility_Init( &argc, &argv );

	/* creating a stream */
	stream =  Journal_Register( Info_Type, __FILE__ );

	directories = Stg_ObjectList_New();
	Stg_ObjectList_PointerAppend( directories, StG_Strdup(LIB_DIR), "default dir", 0, 0, 0 );
	
	plugin = PluginLoader_NewLocal( "LocalPlugin", directories );

	Journal_Firewall( plugin != NULL, stream, "Failed!\n" );

	Journal_Printf( stream, "PluginLoader_GetName(): %s\n", PluginLoader_GetName( plugin ) );
	Print( plugin, stream );

	Stg_Class_Delete( plugin );
	Stg_Class_Delete( directories );
	
	BaseExtensibility_Finalise();
	BaseAutomation_Finalise();
	BaseContainer_Finalise();
	BaseIO_Finalise();
	BaseFoundation_Finalise();

	/* Close off MPI */
	MPI_Finalize();
                                                                                                                                    

	return 0;
}
void* _ForceVector_Copy( void* forceVector, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {
	ForceVector*	self = (ForceVector*)forceVector;
	ForceVector*	newForceVector;
	PtrMap*		map = ptrMap;
	Bool		ownMap = False;
	
	if( !map ) {
		map = PtrMap_New( 10 );
		ownMap = True;
	}
	
	newForceVector = _SolutionVector_Copy( self, dest, deep, nameExt, map );
	
	/* TODO: copy vector? */
	newForceVector->entryPoint_Register = self->entryPoint_Register;
	newForceVector->localSize = self->localSize;
	
	if( deep ) {
		newForceVector->assembleForceVector = (FeEntryPoint*)Stg_Class_Copy( self->assembleForceVector, NULL, deep, nameExt, map );
		if( self->_assembleForceVectorEPName ) {
			if( nameExt ) {
				unsigned	nameLen = strlen( self->_assembleForceVectorEPName );
				
				newForceVector->_assembleForceVectorEPName = Memory_Alloc_Bytes_Unnamed( nameLen + strlen( nameExt ) + 1, "FV->vecEPName" );
				memcpy( newForceVector->_assembleForceVectorEPName, self->_assembleForceVectorEPName, nameLen );
				strcpy( newForceVector->_assembleForceVectorEPName + nameLen, nameExt );
			}
			else {
				newForceVector->_assembleForceVectorEPName = StG_Strdup( self->_assembleForceVectorEPName );
			}
		}
		else {
			newForceVector->_assembleForceVectorEPName = NULL;
		}

	}
	else {
		newForceVector->debug = self->debug;
		newForceVector->_assembleForceVectorEPName = self->_assembleForceVectorEPName;
		newForceVector->assembleForceVector = self->assembleForceVector;
	}
	
	if( ownMap ) {
		Stg_Class_Delete( map );
	}
	
	return (void*)newForceVector;
}
Dictionary_Entry_Value* _DictionaryUtils_GetRecursive( Dictionary* dict, char* str ){
   char* strPoint = strchr( str, '.' );
   if(strPoint){
      Dictionary_Entry_Value* entryVal=NULL;
      /* Create the struct and member strings from the source. */
      char* structString = StG_Strdup( str );
      char* strPointNew = strchr( structString, '.' );
      *strPointNew = 0;
      char* memberString = strPointNew + 1;
      Dictionary_Entry_Value* subDict = Dictionary_Get( dict, structString );
      if( subDict ) entryVal = _DictionaryUtils_GetRecursive( Dictionary_Entry_Value_AsDictionary(subDict), memberString );
      Memory_Free( structString );
      return entryVal;
   } else {
      return Dictionary_Get( dict, str );
   }
}
예제 #11
0
void _lucViewport_Init(
   lucViewport*                  self,
   lucCamera*                    camera,
   lucDrawingObject**            drawingObjectList,
   DrawingObject_Index           drawingObjectCount,
   char*                         title,
   Bool                          axis,
   double                        axisLength,
   Bool                          antialias,
   Bool                          rulers,
   Bool                          timestep,
   int                           border,
   Name                          borderColourName,
   Bool                          disabled,
   Pixel_Index                   margin,
   double                        nearClipPlane,
   double                        farClipPlane,
   double                        scaleX,
   double                        scaleY,
   double                        scaleZ)
{
   DrawingObject_Index object_I;

   self->camera                   = camera;
   self->title                    = StG_Strdup( title );
   self->axis                     = axis;
   self->axisLength               = axisLength;
   self->antialias                = antialias;
   self->rulers                   = rulers;
   self->timestep                 = timestep;
   self->border                   = border;
   self->margin                   = margin;
   self->nearClipPlane            = nearClipPlane;
   self->farClipPlane             = farClipPlane;
   self->scaleX                   = scaleX;
   self->scaleY                   = scaleY;
   self->scaleZ                   = scaleZ;
   self->disabled = disabled || !self->context->vis;

   lucColour_FromString( &self->borderColour, borderColourName );

   self->drawingObject_Register = lucDrawingObject_Register_New();

   for ( object_I = 0 ; object_I < drawingObjectCount ; object_I++ )
      lucDrawingObject_Register_Add( self->drawingObject_Register, drawingObjectList[ object_I ] );
}
예제 #12
0
void* _LineFormatter_Copy( void* lineFormatter, void* dest, Bool deep, Name nameExt, struct PtrMap* ptrMap ) {
	LineFormatter*	self = (LineFormatter*)lineFormatter;
	LineFormatter*	newLineFormatter;
	
	/* Create new instance. Copy virtual info */
	newLineFormatter = (LineFormatter*)_StreamFormatter_Copy( self, dest, deep, nameExt, ptrMap );
	
	/* Copy member info. */
	newLineFormatter->_newLine = self->_newLine;
	if ( self->_tag != NULL ) {
		newLineFormatter->_tag = StG_Strdup( self->_tag );
	}
	else {
		newLineFormatter->_tag = NULL;
	}
	
	return newLineFormatter;
}
void _FieldVariable_Init( 
   FieldVariable*          self, 
   DomainContext*          context,
   Index                   fieldComponentCount, 
   Dimension_Index         dim,
   Bool                    isCheckpointedAndReloaded,
   char*                   o_units,
   MPI_Comm                communicator, 
   FieldVariable_Register* fV_Register,
   Bool                    useCacheMaxMin ) {
   /* Add ourselves to the register for later retrieval by clients */
   
   self->context                   = context;
   self->fieldComponentCount       = fieldComponentCount;
   self->dim                       = dim;
   self->communicator              = communicator;
   self->fieldVariable_Register    = fV_Register;
   self->isCheckpointedAndReloaded = isCheckpointedAndReloaded;
   self->useCacheMaxMin            = useCacheMaxMin;

   if( o_units ) { 
      /* test if units string is valid */
      Scaling_Parse( o_units );
      /* copy units string */
      self->o_units = StG_Strdup( o_units );
   }

   if( self != NULL && fV_Register != NULL ) {   
      /* Prevent the same field from being added more than once */
      if( NamedObject_Register_GetIndex( fV_Register, self->name ) == -1 )
         FieldVariable_Register_Add( fV_Register, self );
   }   

   self->extensionMgr = ExtensionManager_New_OfExistingObject( self->name, self );
   self->cachedTimestep = -1;
}
예제 #14
0
static void Dictionary_Entry_Value_SetValueString( Dictionary_Entry_Value* self, const char* const value ) {
	self->as.typeString = StG_Strdup( value );
	self->type = Dictionary_Entry_Value_Type_String;
}
예제 #15
0
Dictionary_Entry_Value* _Stg_ComponentFactory_PluginGetDictionaryValue( void* cf, void *codelet, Dictionary_Entry_Key key, Dictionary_Entry_Value* defaultVal ) {
   Stg_ComponentFactory*       self              = (Stg_ComponentFactory*) cf;
   Stg_Component*             plugin          = (Stg_Component*)codelet;
   Dictionary*                thisPluginDict = NULL;
   Dictionary*                pluginDict     = (Dictionary*)Dictionary_Get( self->rootDict, "plugins" );
   Name                      pluginType;
   Index      pluginIndex;
   Dictionary_Entry_Value* returnVal;
   Bool                    usedDefault       = False;
   Stream*                 errorStream       = Journal_Register( Error_Type, Stg_Component_Type );
   Stream*                 stream            = self->infoStream;

   Journal_Firewall( self != NULL, errorStream, "In func %s: Stg_ComponentFactory is NULL.\n", __func__ );

   Journal_PrintfL( stream, 2, "Getting parameter '%s': ", key );

   Journal_Firewall( pluginDict != NULL, errorStream, 
         "In func %s: Stg_Component Factory's dictionary is NULL.\n", __func__ );

   /* Get this plugins Dictionary */
   for( pluginIndex = 0; pluginIndex < Dictionary_Entry_Value_GetCount( (Dictionary_Entry_Value*)pluginDict ); pluginIndex++ ) {
      thisPluginDict = Dictionary_Entry_Value_AsDictionary( Dictionary_Entry_Value_GetElement( (Dictionary_Entry_Value*)pluginDict, pluginIndex ) );
      pluginType = StG_Strdup( Dictionary_GetString( thisPluginDict, "Type" ) );
      if( !strcmp( plugin->type, pluginType ) ){
         Memory_Free( pluginType );
         break;
      }
                Memory_Free( pluginType );
   }

   /* Get this Stg_Component's Dictionary */
   Journal_Firewall( thisPluginDict != NULL, errorStream,
         "In func %s: Can't find sub-dictionary for component '%s'.\n", __func__, plugin->name );

   /* Get Value from dictionary */
   returnVal = Dictionary_Get( thisPluginDict, key );
   if ( !returnVal && defaultVal ) {
      returnVal = Dictionary_GetDefault( thisPluginDict, key, defaultVal );
      usedDefault = True;
   }

   /* Print Stuff */
   if ( usedDefault ) {
      Journal_PrintfL( stream, 2, "Using default value = " );
      if ( Stream_IsPrintableLevel( stream, 2 ) ) 
         Dictionary_Entry_Value_Print( returnVal, stream );
      Journal_PrintfL( stream, 2, "\n" );

      return returnVal;
   }
   else if ( returnVal ) {
      Journal_PrintfL( stream, 2, "Found - Value = " );
      if ( Stream_IsPrintableLevel( stream, 2 ) ) 
         Dictionary_Entry_Value_Print( returnVal, stream );
      Journal_PrintfL( stream, 2, "\n" );
   }
   else 
      Journal_PrintfL( stream, 2, "Not found.\n" );

   return returnVal;
}
예제 #16
0
char* Stg_ComponentFactory_GetString( void* cf, Name componentName, Dictionary_Entry_Key key, const char* const defaultVal ) {
   Stg_ComponentFactory* self = (Stg_ComponentFactory*)cf;
   /* return a copy to this string.  this is safer, but will create potential memory leaks at times, but should only be minor */
   return StG_Strdup( self->getString( cf, componentName, key, defaultVal ) );
}
예제 #17
0
void stgGenerateFlattenedXML( Dictionary* dictionary, Dictionary* sources, char* timeStamp ) {
   XML_IO_Handler* ioHandler;
   char*           outputPath;
   char*           flatFilename;
   char*           flatFilenameStamped;
   char*           slimFilename;
   Stream*         s;
   Bool            isEnabled;
   Bool            ret;
   Bool            outputSlim;

   s = Journal_Register( Info_Type, (Name)XML_IO_Handler_Type );

   /* Avoid confusing messages from XML_IO_Handler. Turn it off temporarily. */
   isEnabled = Stream_IsEnable( s );
   Stream_EnableSelfOnly( s, False );

   ioHandler = XML_IO_Handler_New();
   if( sources == NULL )
      ioHandler->writeSources = False;
   outputPath = StG_Strdup( Dictionary_Entry_Value_AsString( Dictionary_GetDefault( dictionary,
      (Dictionary_Entry_Key)"outputPath", Dictionary_Entry_Value_FromString( "./" ) ) ) );
   outputSlim = Dictionary_Entry_Value_AsBool( Dictionary_GetDefault( dictionary,
      (Dictionary_Entry_Key)"outputSlimmedXML", Dictionary_Entry_Value_FromBool( True ) ) );

   if( ! Stg_DirectoryExists( outputPath ) ) {
      if( Stg_FileExists( outputPath ) )
         Journal_Firewall( 0, s, "outputPath '%s' is a file an not a directory! Exiting...\n", outputPath );

      Journal_Printf( s, "outputPath '%s' does not exist, attempting to create...\n", outputPath );
      ret = Stg_CreateDirectory( outputPath );
      Journal_Firewall( ret, s, "Unable to create non-existing outputPath to '%s'\n", outputPath );
      Journal_Printf( s, "outputPath '%s' successfully created!\n", outputPath );
   }

   /* Set file names. */
   Stg_asprintf( &flatFilename, "%s/%s", outputPath, "input.xml" );

   IO_Handler_WriteAllToFile( ioHandler, flatFilename, dictionary, sources );

   /* Format; path/input-YYYY.MM.DD-HH.MM.SS.xml. */
   if (timeStamp) {
      Stg_asprintf( &flatFilenameStamped, "%s/%s-%s.%s",
                   outputPath, "input", timeStamp, "xml" );
      IO_Handler_WriteAllToFile( ioHandler, flatFilenameStamped, dictionary, sources );
      Memory_Free( flatFilenameStamped );
   }

   
   if( outputSlim && timeStamp ) {
      ioHandler->writeSources = False;
      Stg_asprintf( &slimFilename, "%s/%s-%s.%s",
         outputPath, "input-basic", timeStamp, "xml" );
      IO_Handler_WriteAllToFile( ioHandler, slimFilename, dictionary, NULL);
   }

   Stream_EnableSelfOnly( s, isEnabled );
   Stg_Class_Delete( ioHandler );

   Memory_Free( flatFilename );
}