/// <summary>
/// Build resource files for the given configuration.
/// </summary>
/// <param name="fileNames">The resource files to build.</param>
/// <param name="projectConfig">The project configuration.</param>
/// <param name="fileConfig">The build configuration.</param>
/// <remarks>
/// TODO: refactor this as we should always get only one element in the
/// <paramref name="fileNames" /> list. Each res file should be built
/// with its own file configuration.
/// </remarks>
private void BuildResourceFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig)
{
// create instance of RC task
RcTask rcTask = new RcTask();
// inherit project from solution task
rcTask.Project = SolutionTask.Project;
// Set the base directory
rcTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
rcTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
rcTask.Parent = SolutionTask;
// inherit verbose setting from solution task
rcTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
rcTask.InitializeTaskConfiguration();
// set parent of child elements
rcTask.IncludeDirs.Parent = rcTask;
// inherit project from solution task for child elements
rcTask.IncludeDirs.Project = rcTask.Project;
// set namespace manager of child elements
rcTask.IncludeDirs.NamespaceManager = rcTask.NamespaceManager;
// set base directories
rcTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// Store the options to pass to the resource compiler in the options variable
StringBuilder options = new StringBuilder();
// Collect options
string ignoreStandardIncludePath = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "IgnoreStandardIncludePath");
if (ignoreStandardIncludePath != null && string.Compare(ignoreStandardIncludePath, "true", true, CultureInfo.InvariantCulture) == 0) {
options.Append("/X ");
}
string culture = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "Culture");
if (!String.IsNullOrEmpty(culture)) {
int cultureId = Convert.ToInt32(culture);
rcTask.LangId = cultureId;
}
string preprocessorDefs = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
rcTask.Defines.Add(op);
}
}
string showProgress = fileConfig.GetToolSetting(VcConfigurationBase.ResourceCompilerTool, "ShowProgress");
if (showProgress != null && string.Compare(showProgress, "true", true, CultureInfo.InvariantCulture) == 0) {
rcTask.Verbose = true;
}
string addIncludeDirs = MergeToolSetting(projectConfig, fileConfig, VcConfigurationBase.ResourceCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(addIncludeDirs)) {
foreach (string includeDir in addIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
rcTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
options.AppendFormat("/d \"_AFXDLL\"");
}
if (options.Length > 0) {
rcTask.Options = options.ToString();
}
// Compile each resource file
foreach (string rcFile in fileNames) {
rcTask.OutputFile = new FileInfo(GetResourceOutputFile(rcFile, fileConfig));
rcTask.RcFile = new FileInfo(FileUtils.CombinePaths(ProjectDirectory.FullName, rcFile));
// execute the task
ExecuteInProjectDirectory(rcTask);
}
}
private void BuildCPPFiles(ArrayList fileNames, Configuration solutionConfiguration, VcConfigurationBase fileConfig)
{
// obtain project configuration (corresponding with solution configuration)
VcProjectConfiguration projectConfig = (VcProjectConfiguration) BuildConfigurations[solutionConfiguration];
string intermediateDir = FileUtils.CombinePaths(ProjectDirectory.FullName,
projectConfig.IntermediateDir);
// create instance of Cl task
ClTask clTask = new ClTask();
// inherit project from solution task
clTask.Project = SolutionTask.Project;
// inherit namespace manager from solution task
clTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
clTask.Parent = SolutionTask;
// inherit verbose setting from solution task
clTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
clTask.InitializeTaskConfiguration();
// set parent of child elements
clTask.IncludeDirs.Parent = clTask;
clTask.Sources.Parent = clTask;
clTask.MetaDataIncludeDirs.Parent = clTask;
clTask.ForcedUsingFiles.Parent = clTask;
// inherit project from solution task for child elements
clTask.IncludeDirs.Project = clTask.Project;
clTask.Sources.Project = clTask.Project;
clTask.MetaDataIncludeDirs.Project = clTask.Project;
clTask.ForcedUsingFiles.Project = clTask.Project;
// set namespace manager of child elements
clTask.IncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.Sources.NamespaceManager = clTask.NamespaceManager;
clTask.MetaDataIncludeDirs.NamespaceManager = clTask.NamespaceManager;
clTask.ForcedUsingFiles.NamespaceManager = clTask.NamespaceManager;
// set base directories
clTask.IncludeDirs.BaseDirectory = ProjectDirectory;
clTask.Sources.BaseDirectory = ProjectDirectory;
clTask.MetaDataIncludeDirs.BaseDirectory = ProjectDirectory;
clTask.ForcedUsingFiles.BaseDirectory = ProjectDirectory;
// set task properties
clTask.OutputDir = new DirectoryInfo(intermediateDir);
// TODO: add support for disabling specific warnings !!!
// check if precompiled headers are used
if (fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.No && fileConfig.UsePrecompiledHeader != UsePrecompiledHeader.Unspecified) {
// get location of precompiled header file
string pchFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderFile", "$(IntDir)/$(TargetName).pch");
// we must set an absolute path for the PCH location file,
// otherwise <cl> assumes a location relative to the output
// directory - not the project directory.
if (!String.IsNullOrEmpty(pchFile)) {
clTask.PchFile = FileUtils.CombinePaths(ProjectDirectory.FullName, pchFile);
}
// check if a header file is specified for the precompiled header
// file, use "StdAfx.h" as default value
string headerThrough = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"PrecompiledHeaderThrough", "StdAfx.h");
if (!String.IsNullOrEmpty(headerThrough)) {
clTask.PchThroughFile = headerThrough;
}
switch (fileConfig.UsePrecompiledHeader) {
case UsePrecompiledHeader.Use:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Use;
break;
case UsePrecompiledHeader.AutoCreate:
clTask.PchMode = ClTask.PrecompiledHeaderMode.AutoCreate;
break;
case UsePrecompiledHeader.Create:
clTask.PchMode = ClTask.PrecompiledHeaderMode.Create;
break;
}
}
clTask.CharacterSet = projectConfig.CharacterSet;
// ensure output directory exists
if (!clTask.OutputDir.Exists) {
clTask.OutputDir.Create();
clTask.OutputDir.Refresh();
}
string includeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(includeDirs)) {
foreach (string includeDir in includeDirs.Split(',', ';')) {
if (includeDir.Length == 0) {
continue;
}
clTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string metadataDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "AdditionalUsingDirectories");
if (!String.IsNullOrEmpty(metadataDirs)) {
foreach (string metadataDir in metadataDirs.Split(';')) {
if (metadataDir.Length == 0) {
continue;
}
clTask.MetaDataIncludeDirs.DirectoryNames.Add(
CleanPath(fileConfig.ExpandMacros(metadataDir)));
}
}
string forcedUsingFiles = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "ForcedUsingFiles");
if (!String.IsNullOrEmpty(forcedUsingFiles)) {
foreach (string forcedUsingFile in forcedUsingFiles.Split(';')) {
if (forcedUsingFile.Length == 0) {
continue;
}
clTask.ForcedUsingFiles.Includes.Add(
CleanPath(fileConfig.ExpandMacros(forcedUsingFile)));
}
}
// add project and assembly references
foreach (ReferenceBase reference in References) {
if (!reference.IsManaged(solutionConfiguration)) {
continue;
}
StringCollection assemblyReferences = reference.GetAssemblyReferences(
solutionConfiguration);
foreach (string assemblyFile in assemblyReferences) {
clTask.ForcedUsingFiles.Includes.Add(assemblyFile);
}
}
// Since the name of the pdb file is based on the VS version, we need to see
// which version we are targeting to make sure the right pdb file is used.
string pdbTargetFileName;
switch (ProductVersion) {
case ProductVersion.Rosario:
pdbTargetFileName = "$(IntDir)/vc100.pdb";
break;
case ProductVersion.Orcas:
pdbTargetFileName = "$(IntDir)/vc90.pdb";
break;
case ProductVersion.Whidbey:
pdbTargetFileName = "$(IntDir)/vc80.pdb";
break;
default:
pdbTargetFileName = "$(IntDir)/vc70.pdb";
break;
}
// set name of program database file
//
// we must set an absolute path for the program database file,
// otherwise <cl> assumes a location relative to the output
// directory - not the project directory.
string pdbFile = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool,
"ProgramDataBaseFileName", pdbTargetFileName);
if (!String.IsNullOrEmpty(pdbFile)) {
clTask.ProgramDatabaseFile = FileUtils.CombinePaths(ProjectDirectory.FullName,
pdbFile);
}
// set path of object file or directory (can be null)
clTask.ObjectFile = GetObjectFile(fileConfig);
string asmOutput = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerOutput");
string asmListingLocation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AssemblerListingLocation");
if (!String.IsNullOrEmpty(asmOutput) && asmOutput != "0" && !String.IsNullOrEmpty(asmListingLocation)) {
// parameter for AssemblerOutput itself will be handled by the map
clTask.Arguments.Add(new Argument("/Fa\"" + asmListingLocation + "\""));
}
foreach (string fileName in fileNames) {
clTask.Sources.FileNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, fileName));
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string def in preprocessorDefs.Split(';', ',')) {
if (def.Length != 0) {
Option op = new Option();
op.OptionName = def;
clTask.Defines.Add(op);
}
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.CLCompilerTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string def in undefinePreprocessorDefs.Split(';', ',')) {
Option op = new Option();
op.OptionName = def;
clTask.Undefines.Add(op);
}
}
string addOptions = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "AdditionalOptions");
if (!String.IsNullOrEmpty(addOptions)) {
using (StringReader reader = new StringReader(addOptions)) {
string addOptionsLine = reader.ReadLine();
while (addOptionsLine != null) {
foreach (string addOption in addOptionsLine.Split(' ')) {
clTask.Arguments.Add(new Argument(addOption));
}
addOptionsLine = reader.ReadLine();
}
}
}
//exception handling stuff
string exceptionHandling = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "ExceptionHandling");
if (exceptionHandling == null) {
if (ProductVersion >= ProductVersion.Whidbey) {
exceptionHandling = "2";
} else {
exceptionHandling = "false";
}
} else {
exceptionHandling = exceptionHandling.ToLower();
}
switch(exceptionHandling) {
case "0":
case "false":
break;
case "1":
case "true":
clTask.Arguments.Add(new Argument("/EHsc"));
break;
case "2":
clTask.Arguments.Add(new Argument("/EHa"));
break;
}
string browseInformation = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "BrowseInformation");
if (!String.IsNullOrEmpty(browseInformation) && browseInformation != "0") {
// determine file name of browse information file
string browseInformationFile = fileConfig.GetToolSetting(
VcConfigurationBase.CLCompilerTool, "BrowseInformationFile",
"$(IntDir)/");
if (!String.IsNullOrEmpty(browseInformationFile)) {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR\""
+ browseInformationFile + "\""));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr\""
+ browseInformationFile + "\""));
break;
}
} else {
switch (browseInformation) {
case "1": // Include All Browse Information
clTask.Arguments.Add(new Argument("/FR"));
break;
case "2": // No Local Symbols
clTask.Arguments.Add(new Argument("/Fr"));
break;
}
}
}
if (projectConfig.Type == VcProjectConfiguration.ConfigurationType.DynamicLibrary) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_WINDLL"));
}
if (projectConfig.WholeProgramOptimization) {
clTask.Arguments.Add(new Argument("/GL"));
}
// used to ignore some arguments
VcArgumentMap.ArgGroup vcArgIgnoreGroup = VcArgumentMap.ArgGroup.Unassigned;
// if optimzation level is Minimum Size (1) or Maximum size (2), we
// need to ignore all the arguments of the group "OptiIgnoreGroup"
string optimization = fileConfig.GetToolSetting(VcConfigurationBase.CLCompilerTool, "Optimization");
if (!String.IsNullOrEmpty(optimization)) {
int optimizationLevel = int.Parse(optimization);
if (optimizationLevel == 1 || optimizationLevel == 2) {
vcArgIgnoreGroup |= VcArgumentMap.ArgGroup.OptiIgnoreGroup;
}
}
Hashtable compilerArgs = fileConfig.GetToolArguments(VcConfigurationBase.CLCompilerTool,
_clArgMap, vcArgIgnoreGroup);
foreach (string arg in compilerArgs.Values) {
Argument compilerArg = new Argument();
compilerArg.Line = arg;
clTask.Arguments.Add(compilerArg);
}
// check for shared MFC
if (projectConfig.UseOfMFC == UseOfMFC.Shared) {
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_AFXDLL"));
}
// check for shared ATL
switch (projectConfig.UseOfATL) {
case UseOfATL.Shared:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_DLL"));
break;
case UseOfATL.Static:
clTask.Arguments.Add(new Argument("/D"));
clTask.Arguments.Add(new Argument("_ATL_STATIC_REGISTRY"));
break;
}
// enable/disable Managed Extensions for C++
clTask.ManagedExtensions = projectConfig.ManagedExtensions;
// execute the task
ExecuteInProjectDirectory(clTask);
}
/// <summary>
/// Adds a <see cref="Option"/> to the end of the collection.
/// </summary>
/// <param name="item">The <see cref="Option"/> to be added to the end of the collection.</param>
/// <returns>The position into which the new element was inserted.</returns>
public int Add(Option item) {
return base.List.Add(item);
}
/// <summary>
/// Build Interface Definition Language files for the given
/// configuration.
/// </summary>
/// <param name="fileNames">The IDL files to build.</param>
/// <param name="projectConfig">The project configuration.</param>
/// <param name="fileConfig">The build configuration.</param>
/// <remarks>
/// TODO: refactor this as we should always get only one element in the
/// <paramref name="fileNames" /> list. Each IDL file should be built
/// with its own file configuration.
/// </remarks>
private void BuildIDLFiles(ArrayList fileNames, VcProjectConfiguration projectConfig, VcConfigurationBase fileConfig)
{
// create instance of MIDL task
MidlTask midlTask = new MidlTask();
// inherit project from solution task
midlTask.Project = SolutionTask.Project;
// Set the base directory
midlTask.BaseDirectory = ProjectDirectory;
// inherit namespace manager from solution task
midlTask.NamespaceManager = SolutionTask.NamespaceManager;
// parent is solution task
midlTask.Parent = SolutionTask;
// inherit verbose setting from solution task
midlTask.Verbose = SolutionTask.Verbose;
// make sure framework specific information is set
midlTask.InitializeTaskConfiguration();
// set parent of child elements
midlTask.IncludeDirs.Parent = midlTask;
// inherit project from solution task for child elements
midlTask.IncludeDirs.Project = midlTask.Project;
// set namespace manager of child elements
midlTask.IncludeDirs.NamespaceManager = midlTask.NamespaceManager;
// set base directories
midlTask.IncludeDirs.BaseDirectory = ProjectDirectory;
// If outputDirectory is not supplied in the configuration, assume
// it's the project directory
string outputDirectory = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "OutputDirectory");
if (String.IsNullOrEmpty(outputDirectory)) {
outputDirectory = ProjectDirectory.FullName;
} else {
outputDirectory = FileUtils.CombinePaths(ProjectDirectory.FullName,
outputDirectory);
}
// ensure output directory exists
if (!LongPathDirectory.Exists(outputDirectory)) {
LongPathDirectory.Create(outputDirectory);
}
midlTask.Arguments.Add(new Argument("/out"));
midlTask.Arguments.Add(new Argument(outputDirectory));
string typeLibraryName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool,
"TypeLibraryName", "$(IntDir)/$(ProjectName).tlb");
if (!String.IsNullOrEmpty(typeLibraryName)) {
midlTask.Tlb = new FileInfo(FileUtils.CombinePaths(outputDirectory,
typeLibraryName));
// ensure tlb directory exists
if (!midlTask.Tlb.Directory.Exists) {
midlTask.Tlb.Directory.Create();
midlTask.Tlb.Directory.Refresh();
}
}
string proxyFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "ProxyFileName");
if (!String.IsNullOrEmpty(proxyFileName)) {
midlTask.Proxy = new FileInfo(FileUtils.CombinePaths(outputDirectory,
proxyFileName));
// ensure proxy directory exists
if (!midlTask.Proxy.Directory.Exists) {
midlTask.Proxy.Directory.Create();
midlTask.Proxy.Directory.Refresh();
}
}
string interfaceIdentifierFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "InterfaceIdentifierFileName");
if (!String.IsNullOrEmpty(interfaceIdentifierFileName)) {
midlTask.Iid = new FileInfo(FileUtils.CombinePaths(outputDirectory,
interfaceIdentifierFileName));
// ensure IID directory exists
if (!midlTask.Iid.Directory.Exists) {
midlTask.Iid.Directory.Create();
midlTask.Iid.Directory.Refresh();
}
}
string dllDataFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "DLLDataFileName");
if (!String.IsNullOrEmpty(dllDataFileName)) {
midlTask.DllData = new FileInfo(FileUtils.CombinePaths(outputDirectory,
dllDataFileName));
// ensure DllData directory exists
if (!midlTask.DllData.Directory.Exists) {
midlTask.DllData.Directory.Create();
midlTask.DllData.Directory.Refresh();
}
}
string headerFileName = fileConfig.GetToolSetting(VcConfigurationBase.MIDLTool, "HeaderFileName");
if (!String.IsNullOrEmpty(headerFileName)) {
midlTask.Header = new FileInfo(FileUtils.CombinePaths(outputDirectory,
headerFileName));
// ensure Header directory exists
if (!midlTask.Header.Directory.Exists) {
midlTask.Header.Directory.Create();
midlTask.Header.Directory.Refresh();
}
}
string preprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "PreprocessorDefinitions");
if (!String.IsNullOrEmpty(preprocessorDefs)) {
foreach (string preprocessorDef in preprocessorDefs.Split(';')) {
if (preprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = preprocessorDef;
midlTask.Defines.Add(op);
}
}
string undefinePreprocessorDefs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "UndefinePreprocessorDefinitions");
if (!String.IsNullOrEmpty(undefinePreprocessorDefs)) {
foreach (string undefinePreprocessorDef in undefinePreprocessorDefs.Split(';')) {
if (undefinePreprocessorDef.Length == 0) {
continue;
}
Option op = new Option();
op.OptionName = undefinePreprocessorDef;
midlTask.Undefines.Add(op);
}
}
string additionalIncludeDirs = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "AdditionalIncludeDirectories");
if (!String.IsNullOrEmpty(additionalIncludeDirs)) {
foreach (string includeDir in additionalIncludeDirs.Split(';')) {
if (includeDir.Length == 0) {
continue;
}
midlTask.IncludeDirs.DirectoryNames.Add(FileUtils.CombinePaths(
ProjectDirectory.FullName, CleanPath(includeDir)));
}
}
string cPreprocessOptions = MergeToolSetting(projectConfig, fileConfig,
VcConfigurationBase.MIDLTool, "CPreprocessOptions");
if (!String.IsNullOrEmpty(cPreprocessOptions)) {
foreach (string cPreprocessOption in cPreprocessOptions.Split(';')) {
if (cPreprocessOption.Length == 0) {
continue;
}
midlTask.Arguments.Add(new Argument(string.Format("/cpp_opt\"{0}\"", cPreprocessOption)));
}
}
Hashtable midlArgs = fileConfig.GetToolArguments(VcConfigurationBase.MIDLTool, _midlArgMap);
foreach (string key in midlArgs.Keys) {
switch (key) {
case "TargetEnvironment":
midlTask.Env = (string) midlArgs[key];
break;
case "DefaultCharType":
midlTask.Char = (string) midlArgs[key];
break;
default:
Argument midlArg = new Argument();
midlArg.Line = (string) midlArgs[key];
midlTask.Arguments.Add(midlArg);
break;
}
}
// Compile each idl file
foreach (string idlFile in fileNames) {
midlTask.Filename = new FileInfo(FileUtils.CombinePaths(
ProjectDirectory.FullName, idlFile));
// execute the task
ExecuteInProjectDirectory(midlTask);
}
}
/// <summary>
/// Removes a member from the collection.
/// </summary>
/// <param name="item">The <see cref="Option"/> to remove from the collection.</param>
public void Remove(Option item) {
base.List.Remove(item);
}
/// <summary>
/// Initializes a new instance of the <see cref="OptionCollection"/> class
/// with the specified array of <see cref="Option"/> instances.
/// </summary>
public OptionCollection(Option[] value) {
AddRange(value);
}
/// <summary>
/// Retrieves the index of a specified <see cref="Option"/> object in the collection.
/// </summary>
/// <param name="item">The <see cref="Option"/> object for which the index is returned.</param>
/// <returns>
/// The index of the specified <see cref="Option"/>. If the <see cref="Option"/> is not currently a member of the collection, it returns -1.
/// </returns>
public int IndexOf(Option item) {
return base.List.IndexOf(item);
}
/// <summary>
/// Inserts a <see cref="Option"/> into the collection at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The <see cref="Option"/> to insert.</param>
public void Insert(int index, Option item) {
base.List.Insert(index, item);
}
/// <summary>
/// Copies the entire collection to a compatible one-dimensional array, starting at the specified index of the target array.
/// </summary>
/// <param name="array">The one-dimensional array that is the destination of the elements copied from the collection. The array must have zero-based indexing.</param>
/// <param name="index">The zero-based index in <paramref name="array"/> at which copying begins.</param>
public void CopyTo(Option[] array, int index) {
base.List.CopyTo(array, index);
}
/// <summary>
/// Determines whether a <see cref="Option"/> is in the collection.
/// </summary>
/// <param name="item">The <see cref="Option"/> to locate in the collection.</param>
/// <returns>
/// <see langword="true" /> if <paramref name="item"/> is found in the
/// collection; otherwise, <see langword="false" />.
/// </returns>
public bool Contains(Option item) {
return base.List.Contains(item);
}
/// <summary>
/// Adds the elements of a <see cref="Option"/> array to the end of the collection.
/// </summary>
/// <param name="items">The array of <see cref="Option"/> elements to be added to the end of the collection.</param>
public void AddRange(Option[] items) {
for (int i = 0; (i < items.Length); i = (i + 1)) {
Add(items[i]);
}
}
/// <summary>
/// Adds a new global option if none exists. If one does exist then
/// the use switch is toggled on or of.
/// </summary>
/// <param name="name">The common name of the option.</param>
/// <param name="value">The option value or command line switch
/// of the option.</param>
/// <param name="on"><code>true</code> if the option should be
/// appended to the commandline, otherwise <code>false</code>.</param>
protected void SetGlobalOption(String name, String value, bool on)
{
Option option;
Log(Level.Debug, "Name: {0}", name);
Log(Level.Debug, "Value: {0}",value);
Log(Level.Debug, "On: {0}", on);
if (GlobalOptions.Contains(name)) {
option = (Option)GlobalOptions[name];
} else {
option = new Option();
option.OptionName = name;
option.Value = value;
GlobalOptions.Add(option.OptionName, option);
}
option.IfDefined = on;
}
/// <summary>
/// Adds a new command option if none exists. If one does exist then
/// the use switch is toggled on or of.
/// </summary>
/// <param name="name">The common name of the option.</param>
/// <param name="value">The option value or command line switch
/// of the option.</param>
/// <param name="on"><code>true</code> if the option should be
/// appended to the commandline, otherwise <code>false</code>.</param>
protected void SetCommandOption(String name, String value, bool on)
{
Option option;
if (CommandOptions.Contains(name)) {
option = (Option)CommandOptions[name];
} else {
option = new Option();
option.OptionName = name;
option.Value = value;
CommandOptions.Add(name, option);
}
option.IfDefined = on;
}
