wx.Net.Build: wx.Build.Cxx.DynamicLibraryProject Class Reference

wx.Build.Cxx.DynamicLibraryProject.DynamicLibraryProject ( )

Creates an empty project without a name that will not be offered to the user. Use this only in conjunction with ReadXml() to create an isntance that afterwards reads its content from an XML stream.

wx.Build.Cxx.DynamicLibraryProject.DynamicLibraryProject ( DynamicLibraryProject src )

Copy CTor.

Parameters:

src

The source

wx.Build.Cxx.DynamicLibraryProject.DynamicLibraryProject	(	ProjectPreference	preference,
		string	name,
		string	outputDir,
		string	dllBaseName,
		string	description
	)

Creates a project to build a file of the provided basename dllBaseName. This CTor will derive a type depending on the current platform. On Windows, this project will produce an ContentType.WindowsGuiDll file on an empty type.

Parameters:

	name	is the name of the project and will be used whenever the build system asks the user for a decision.
	outputDir	is the directory where this project will put out its targets.
	dllBaseName	is the basename of the file that shall be created without extension or prefixes like "lib" etc. This name will be expanded to the name of the target referring to the desired content `type`.
	description	is a descriptive text that will be displayed to users of the system to explain the purpose of this project.

wx.Build.Cxx.DynamicLibraryProject.DynamicLibraryProject	(	ProjectPreference	preference,
		string	name,
		ContentType	type,
		string	outputDir,
		string	dllBaseName,
		string	description
	)

Creates a project to build a file of the provided basename dllBaseName.

Parameters:

name is the name of the project and will be used whenever the build system asks the user for a decision.

type is the content type of the desired target. This may be either ContentType.Elf, ContentType.WindowsDll. ContentType.WindowsGuiDll, or null. If this type is null, this CTor will derive a type depending on the current platform. On Windows, this project will produce an ContentType.WindowsGuiDll file on an empty type.

outputDir

is the directory where this project will put out its targets.</params>

Parameters:

dllBaseName is the basename of the file that shall be created without extension or prefixes like "lib" etc. This name will be expanded to the name of the target referring to the desired content type.

This may also be a filename of the form "wx-c.lib", "wx-c.dylib", or "libwx-c.so" that are used as platform specific filenames for dynamic libraries. In such cases, the basename will be extracted.

description is a descriptive text that will be displayed to users of the system to explain the purpose of this project.

void wx.Build.Cxx.DynamicLibraryProject.AddCPlusPlusSources ( IFileProducts src )

This will add the arguments to the collection of files that will be compiled in C++ mode. Please note, that exceptions will be raised on incompatible content types.

Parameters:

src

Collection of content files that shall be of ContentType.CPlusPlusCode.

void wx.Build.Cxx.DynamicLibraryProject.AddCSources ( IFileProducts src )

This will add the arguments to the collection of files that will be compiled in C mode. Please note, that exceptions will be raised on incompatible content types.

Parameters:

src

Collection of content files that shall be of ContentType.CCode.

delegate void wx.Build.BaseAction.AdderSerializable ( System.Xml.Serialization.IXmlSerializable arg ) [inherited]

Will be called in ReadCollection() if a new object has been found.

Parameters:

arg

The object that has been found.

void wx.Build.Cxx.DynamicLibraryProject.AddHeaderFiles ( IFileProducts src )

Thsi will add the arguments to the collections of files that will be distributed with all other sources of the project as C/C++ header files. You will have to set this in order to produce compilable project packages.

Parameters:

src

Collection of content files that shall be of ContentType.CCPlusPlusInclude.

static ICollection<BuildProject> wx.Build.BuildProject.AddIncludedProjects	(	IDictionary< BuildProject, BuildProject >	result,
		ICollection< IBuildProduct >	listOfBuildProducts
	)			`[static, inherited]`

Adds all build projects from listOfBuildProjects and their prerequisites to the result (a set: value equals key).

static void wx.Build.BuildProject.AddKnownProject ( BuildProject p ) [static, inherited]

This will add the provided project to the collection of known projects. This method will create a GUID for the added project if not yet known.

Parameters:

p

The project that shall be added.

void wx.Build.Cxx.DynamicLibraryProject.AddRCFile ( IFileProducts src )

Adds a ContentType.RCFile to the sources of this project. Please note, that these sources will only be used with Windows executables. So, users have to take care that either the content of this files is optional (like version information to be displayed in the Windows file explorer) or the mandatory input is replaced by other sources when compiling the code on other platforms.

void wx.Build.Cxx.DynamicLibraryProject.AddStaticLibrary ( IFileProducts src )

Use this method to add all static library files that are required by this project. Please note, that you have to add files for all compilers that are supported. Otherwise, linker errors referring to undefined symbols will result, if the build system uses a compiler/linker where some of the required libraries are unknown.

The term "static library" here means files that are passed to the linker in order to link object files and libraries to an application program. In this sence, ELF libraries are also static libraries since they are passed directly to the linker that creates stubs for the functions provided by the ELF library.

Typically, classes of static libraries will be bundled as targets of project like wx.Build.Cxx.wxWidgets. Such projects typically supply all known formats of static libraries as targets.

virtual bool wx.Build.BuildProject.AdoptConfig ( BuildConfig config ) [virtual, inherited]

Change the provided configuration of necessary in order to produce the targets.

Returns:: is true iff changes have been necessary. This method will be called immediately before executing the project in order to create a fixed point of the configuration. Apply only sparse changes. Returning true on parameters that have been changed by another project will stop the build process because of inconsistent demands on the configuration.

This default implementation will always return false .

Reimplemented in wx.Build.Cxx.wxWidgets.

virtual void wx.Build.BaseAction.AppendBooCode	(	List< string >	booCodeLines,
		string	indention,
		BuildToolFamilyEnv	env
	)			`[virtual, inherited]`

This implementation will look for a program start info that implements this actions. If program start info is null, this implementation will raise an exception. Overload this if you have to create another implementation providing this feature.

Parameters:

	env	This is an environment that different tools of the same family may use to exchange information. This store is typically used to save information on configuration files or thinsgs of that kind that will be shared among all tools of the same family.
	booCodeLines	The code that will actually build something will be appended to this writer.
	indention	A string that shall preceed all created lines.

Exceptions:

NotSupportedException

Will be thrown if this feature is not supported.

See also:: GetProgrammStartInfo

Reimplemented in wx.Build.FileTestAction, wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, wx.Build.MS.Csc, wx.Build.Release.ReplaceVersionInRCFile, and wx.Build.Release.CopyFileAction.

virtual void wx.Build.BaseAction.AppendToBooPreamble	(	BuildToolFamilyEnv	env,
		List< string >	importModules,
		List< string >	booDeclarations,
		List< string >	booDefinitions
	)			`[virtual, inherited]`

This will be called for any action provider before IBuildAction.AppendBooCode() is called. This provides action providers with the opportunity to import modules and create variables for global options.

Parameters:

	importModules	List of modules that shall be imported. Add required modules here. Each module will be imported exactly once (even if it occurs more than once in the list).
	env	This is an environment that different tools of the same family may use to exchange information. This store is typically used to save information on configuration files or thinsgs of that kind that will be shared among all tools of the same family.

A typical use is the import of modules that will be used in the later BOO code that builds the project.

            void AppendToBooPreamble(System.IO.TextWriter booCodeLines)
            {
                booCodeLines.Add("import System.Diagnostics");
                booCodeLines.Add("Process=System.Diagnostics.Process");
            }

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, and wx.Build.MS.Csc.

bool wx.Build.BaseAction.AreAllMandatoryVarsDefined ( ) [inherited]

True iff all mandatory environment variables are defined. The project cannot be made if this is false.

static int wx.Build.BuildProject.Build	(	ErrorHandler	handler,
		System.Reflection.Assembly	projectSrc,
		string[]	programOpts
	)			`[static, inherited]`

Builds projects regarding the provided options.

Parameters:

	handler	will be set as configured error handler in the BuildConfig. Output of errors and warnings via `handler` .
	programOpts	programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/projects", "/actions", "/clean", "/disable:ACTION", "/disable:PROJECT", /set:VARNAME=VALUE, or /append:VARNAME=VALUE. Refer to class CommandLineOptions.
	projectSrc	The assembly containing the project definitions. This may be `null`.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

static int wx.Build.BuildProject.Build	(	ErrorHandler	handler,
		string[]	programOpts
	)			`[static, inherited]`

Builds projects regarding the provided options. Projects will be read from the Assembly.GetCallingAssembly.

Parameters:

	handler	Output of errors and warnings using this handler.
	programOpts	programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/targets", "/projects", "/clean", "/disable:ACTION", "/disable:PROJECT", `/set:VARNAME=VALUE`, or `/append:VARNAME=VALUE`. Refer to class CommandLineOptions.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

Refer to the remarks on class BuildProject for an example of a project definition.

static int wx.Build.BuildProject.Build ( string[] programOpts ) [static, inherited]

Builds projects regarding the provided options. Projects will be read from the Assembly.GetCallingAssembly. Output of errors and warnings on System.Console.

Parameters:

programOpts programOpts may be the name of tools/build actions or projects, or you may use one or more of the options "/help", "/vars", "/targets", "/projects", "/clean", "/disable:ACTION", "/disable:PROJECT", /set:VARNAME=VALUE, or /append:VARNAME=VALUE. Refer to class CommandLineOptions.

Returns:: 0 on success and 1 on failure, that should however also be reported to the error handler.

See also:: CommandLineOptions

static void wx.Build.BuildProject.ClearKnownProjects ( ) [static, inherited]

Clear the loaded projects.

override object wx.Build.Cxx.DynamicLibraryProject.Clone ( ) [virtual]

Deep copy of this instance.

Implements wx.Build.BuildProject.

void wx.Build.BaseAction.CollectChoicePoints ( IDictionary< string, ICollection< string >> collectionOfChoicePoints ) [inherited]

This method collects all choice points within this action. Choice points are represented by a name and a collection of alternatives.

Parameters:

collectionOfChoicePoints

The collection that will be extended by the choice points of this action.

The current implementation provides a choice point for the compilation and linking of C/C++ programs, "CppDevelopmentSystem" of the alternatives "GCC" and "MS VC". Thus, actions on C/C++ compilation will add the following choice point:

            if (!collectionOfChoicePoints.ContainsKey("CppDevelopmentSystem"))
                collectionOfChoicePoints.Add("CppDevelopmentSystem", new List&lt;string&gt;());
            collectionOfChoicePoints["CppDevelopmentSystem"].Add("GCC");
            collectionOfChoicePoints["CppDevelopmentSystem"].Add("MS VC");

virtual int wx.Build.BuildProject.CompareTo ( object obj ) [virtual, inherited]

Compares all properties, targets, and dependencies of this and the obj if the argument is a project of the same class. If the argument is of another class, this compares the full class names.

This is virtual since inheritors may overload this. However, inheritors MUST take care, that their implementation is symmetric to this one, i.e. must be of the form

            if (obj.GetType().Equals(this.GetType())
            {
                ...
            }
            else return this.GetType().FullName.CompareTo(obj.GetType().FullName);

Parameters:

obj

Object that will be compared with this.

Returns:: -1, 0, or 1 like in all the other implementations of this method.

Reimplemented in wx.Build.Release.MakeReleaseProject.

virtual bool wx.Build.BaseAction.ContainsPrerequisite ( IBuildProduct prereq ) [virtual, inherited]

True iff prereq is among the GetPrerequisites().

Reimplemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Net.CSharpCodeProvider, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, wx.Build.MS.Csc, and wx.Build.Cxx.wxWidgets.

override ICollection<IBuildAction> wx.Build.Cxx.DynamicLibraryProject.CreateActionPlan ( BuildToolFamilyEnv env ) [virtual]

Creates an action plan (a collection of alternative actions) that can be taken to create the targets of this project.

Parameters:

env

Parameters that are shared between tools of the same family.

Returns:

Please note, that this project creates alternative plans for each content type with ContentFileProperties.NativeCodeObject.

Implements wx.Build.BuildProject.

override RefToProject wx.Build.SingleFileProject.CreateRef ( ) [virtual, inherited]

Returns an instance of RefToFileProject.

Returns:

Reimplemented from wx.Build.FileProject.

override RefToFileProject wx.Build.SingleFileProject.CreateRefToFileProject ( ) [virtual, inherited]

Returns an instance of RefToFileProject.

Returns:

Reimplemented from wx.Build.FileProject.

RefToSingleFileProject wx.Build.SingleFileProject.CreateRefToSingleFileProject ( ) [inherited]

override bool wx.Build.BuildProject.Equals ( object obj ) [inherited]

Comparison refers to the implementation of IComparable.CompareTo().

static ICollection<BuildProject> wx.Build.BuildProject.GetAllProjectsDeclaredInAssembly	(	System.Reflection.Assembly	assembly,
		ICollection< ErrorObject >	errors
	)			`[static, inherited]`

Returns a collection of all projects declared in the provided assembly. Projects are declared using the attributes BuildProjectAttribute.

Parameters:

	assembly	The assembly that contains the project definitions. This method will also accept `null`. In that case, this will return the GetLoadedProjects()
	errors	This method will add encountered errors to this argument if it is not `null`.

static string wx.Build.Cxx.DynamicLibraryProject.GetDllBasename ( string filename ) [static]

Reads the platform independent basename of a DLL from a dll filename.

Examples:

Argument Result

wx-c.dll wx-c

wx-c.dylib wx-c

libwx-c.so wx-c

wx-c wx-c

Parameters:

filename

Either a filename denoting a DLL or ELF library or already platform independent basename.

Returns:: The platform independent basename that may be used e.g. in DllImport statements.

Guid wx.Build.BuildProject.GetGuid ( ) [inherited]

This will return the Id but create one if not yet known.

Id

override int wx.Build.BuildProject.GetHashCode ( ) [inherited]

Reimplemented in wx.Build.Release.MakeReleaseProject.

static BuildProject wx.Build.BuildProject.GetKnownProject ( Guid id ) [static, inherited]

Returns the project of the provided ID.

Parameters:

id

The ID of the desired project

Returns:: The project of the desired name or null if this project is unknown.

static ICollection<BuildProject> wx.Build.BuildProject.GetKnownProjects ( ) [static, inherited]

Returns the collection of projects that have been loaded from file.

override ICollection<IBuildProduct> wx.Build.Cxx.DynamicLibraryProject.GetPrerequisites ( ) [virtual]

Collection of the prerequisites of this action.

Implements wx.Build.BaseAction.

virtual System.Diagnostics.ProcessStartInfo wx.Build.BaseAction.GetProgramStartInfo ( BuildToolFamilyEnv env ) [virtual, inherited]

This simply returns null and may serve as standard implementation of those actions that do not use System.Diagnostics.Process.

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.GccAsLinker, wx.Build.Cxx.GCC.WindRes, wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, and wx.Build.MS.Csc.

System.Xml.Schema.XmlSchema wx.Build.BuildProject.GetSchema ( ) [inherited]

Returns null as suggested by the .NET framework documentation.

new DynamicLibraryProject wx.Build.Cxx.DynamicLibraryProject.GetSingleton ( )

This will make the project instance ready to be solved. The build system will only use one project instance per target. Thus, projects will be registered. This will try to register this instance. If the database of registered project already contains a project instance for the targets of this instance, this will return this instance.

Returns:

Reimplemented from wx.Build.BuildProject.

override ICollection<IBuildProduct> wx.Build.Cxx.DynamicLibraryProject.GetTargets ( ) [virtual]

Collection of the targets or products of this action.

Implements wx.Build.BaseAction.

static ICollection<EnvironmentVarInfo> wx.Build.BuildProject.GetUsedVariables ( System.Reflection.Assembly projectSrc ) [static, inherited]

Creates a collection of all environment variables that are used either by project or actions.

Parameters:

projectSrc

An assembly that contains project definitions. This may be null. In that case, this will use all loaded problems.

Returns:

override DateTime wx.Build.BuildProject.GetValidity ( ) [virtual, inherited]

This is the timestamp representing how current the prerequisites are. The standard implementation will use be the latest validity of a prerequisite.

Reimplemented from wx.Build.BaseAction.

Reimplemented in wx.Build.Cxx.wxWidgets.

override DateTime wx.Build.BuildProject.GetValidityDemand ( ) [virtual, inherited]

This is the timestamp representing the latest change of a prerequisite. The standard implementation will use be the latest validity of a prerequisite.

Reimplemented from wx.Build.BaseAction.

Reimplemented in wx.Build.Cxx.wxWidgets.

DateTime wx.Build.BaseAction.GetValidityTargets ( ) [inherited]

This is the earliest validiy of a target.

static BuildProject wx.Build.BuildProject.LoadRefFrom ( System.Xml.XmlReader reader ) [static, inherited]

Reads a project whose properties are available by GetLoadedProject().

Parameters:

reader

The source.

Exceptions:

KeyNotFoundException

Raised if the read project cannot be found in the GetLoadedProject().

virtual void wx.Build.BuildProject.NormalizeOriginalFileName ( string nameOfAValidDirOrFile ) [virtual, inherited]

You may use this method to control the form of the file name that will be used to serialize this (the original filename). The argument is a path to an existing file or directory. This will strip a directory information from this path. After that, the original file name will change to something equivalent to the absolute filename (referring to the same file) but now relative to the directory as specified by the argument.

Use this method to prepare content file instance for serialization in such a way that all file names become relative to the same directory.

Parameters:

nameOfAValidDirOrFile The name of an existing file or directory. This name will - if relative - be expanded using the BuildConfig. If this is null, this method will return without any effect. This may also be the name of a not yet existing file. In that case, however, the directory name shall exist.

See also:: OriginalFileName

Exceptions:

System.ArgumentException

Will be raised if the argument is neither the path to an existing file nor directory.

Reimplemented in wx.Build.Release.MakeReleaseProject.

static implicit wx.Build.FileProject.operator FileProject ( RefToFileProject refToProject ) [static, inherited]

static implicit wx.Build.SingleFileProject.operator SingleFileProject ( RefToSingleFileProject refToProject ) [static, inherited]

static bool wx.Build.BaseAction.ReadCollection	(	System.Xml.XmlReader	reader,
		AdderSerializable	collectorForResults,
		string	outerElementName,
		string	innerElementName
	)			`[static, inherited]`

Reads a collection of serializable objects from the provided XML source.

Parameters:

	reader	XML source
	collectorForResults	This will add the created results to this collection.
	outerElementName	name of the XML element that will embrace all elements.
	innerElementName	Name of the XML element that contains the information of a single serialized object.

Returns:: True if the outer element name has been found. False if this has not been able to parse a term complying with the expected content.

void wx.Build.BaseAction.ReadProject ( System.Xml.XmlReader reader ) [protected, inherited]

Reads the features as serialized by WriteFeatures().

Parameters:

reader

The source of serialized data

static System.Xml.Serialization.IXmlSerializable wx.Build.BaseAction.ReadSerializable	(	System.Xml.XmlReader	reader,
		string	elementName
	)			`[static, inherited]`

This reads a serilization that has been created by WriteSerializable(). This only works if an instance of the serialized obejct can be created without arguments.

Parameters:

	reader	The serialization will be read from this source.
	elementName	Name of the XML element that encapsulates the serialization.

Returns:: The object instance that has been created from the serialized information.

WriteSerializable

void wx.Build.BuildProject.ReadStdAttributes ( System.Xml.XmlReader reader ) [protected, inherited]

Helper for XML serialization of projects. Call this immediately after reading the root element of a serialized project to read the attributes stored by WriteStdAttributes().

Parameters:

reader

The source where to read the serialization from.

override void wx.Build.Cxx.DynamicLibraryProject.ReadXml ( System.Xml.XmlReader reader ) [virtual]

Serialization of full data. This mus be written by each subclass of a project whereas the standard serialization is generic.

All Implementations of this project shall not forget to read the ReadStdAttributes() and add this instance to the loaded projects using

            System.Guid oldGuid=this.Id;
            wx.Build.BuildProject.ReadStdAttributes();
            this.SetAsLoadedProject(oldGuid);

Parameters:

reader

The source

Implements wx.Build.BuildProject.

static Guid wx.Build.BuildProject.RegisterProjectTargets ( BuildProject p ) [static, protected, inherited]

Static factory methods creating projects will use this method to decide whether a new instance of the project is justified or probably a doublette.

Parameters:

p

The project instance that shall be tested.

Returns:: The Guid of a preexisting project producing at least on of p's targets and that is of the same type. The result will be the GUID of p if p can be used.

static IList<BuildProject> wx.Build.BuildProject.ScheduleProjects ( ICollection< BuildProject > projects ) [static, inherited]

Put projects in such an order that they occur before all their prerequisites that are also projects. This will put the project into a certain order that allows later steps of processing to concatenate actions plans.

Parameters:

projects

projects to schedule.

Returns:: a list containig all projects and their prerequisites or null in case that no appropriate order exists.

void wx.Build.BuildProject.SetAsKnownProject ( Guid oldGuid ) [protected, inherited]

Register this as a loaded project. The argument is the old Id of this project that it might have had before reading from a stream or System.Guid.Empty if the project instance did not have an Id before.

Parameters:

oldGuid The old Id of this instance or System.Guid.Empty if this did not have an Id before.

This will remove this project from the collection of loaded projects if it has been registered before with Id oldGuid.

static string wx.Build.BuildProject.StringAsSymbol ( string aName ) [static, inherited]

Returns a version of the argument that may serve as a C/C++ or C# symbol.

Parameters:

aName

Returns:

virtual bool wx.Build.BaseAction.TargetsAreConsistent ( DateTime validityOfBuildSystem ) [virtual, inherited]

This simply tests whether the oldest validity of the targets is equal to or more current than the validity of the prerequisites.

Parameters:

validityOfBuildSystem

indicates the last change of either this DLL or the assembly defining the project. changes to the build system or the project definition affect of course the validity of the produced targets. Use System.DateTime.MinValue if you do not know or want this to be neglected.

Reimplemented in wx.Build.Cxx.wxWidgets.

override string wx.Build.BuildProject.ToString ( ) [inherited]

static void wx.Build.BaseAction.WriteCollectionOfSerializables	(	System.Xml.XmlWriter	writer,
		System.Collections.IEnumerable	serializables,
		string	outerElementName,
		string	innerElementName
	)			`[static, inherited]`

Serializes a collection of serializable objects.

Parameters:

	writer	This method will write the serialization to this destination.
	serializables	The collection of object to serialize. All objects must implement System.Xml.Serialization.IXmlSerializable.
	outerElementName	name of the XML element that will embrace all elements.
	innerElementName	Name of the XML element that contains the information of a single serialized object.

void wx.Build.BaseAction.WriteProject ( System.Xml.XmlWriter writer ) [protected, inherited]

This will serialize the feature list in an XML element "feature-list".

Parameters:

writer

Destination of serialized data.

void wx.Build.BuildProject.WriteRefXml ( System.Xml.XmlWriter writer ) [inherited]

Serializing only the name of the project. Read this using LoadRefFrom().

Parameters:

writer

The destinaton

static void wx.Build.BaseAction.WriteSerializable	(	System.Xml.XmlWriter	writer,
		System.Xml.Serialization.IXmlSerializable	obj,
		string	elementName
	)			`[static, inherited]`

Helper to serialize objects of unknown class. This will create an element of the provided element name and attach attributes "assembly" and "type" to this element. These elements will describe the type of the object to serialize. Then, embedded into this new element, the object will be asked to place its serialization.

Parameters:

	obj	The object that shall be serialized. May be `null`
	elementName	Name of the XML element that will be created.
	writer	The information will be written to this destination.

Use this method to serialize member variables of unknown type like e.g. wx.Build.IFileProducts. Often, projects refer to members where the only known information is: This implements wx.Build.IFileProducts. The project does not need to know more facts with one exception: When deserializing a XML serialization, the project needs to know the exact class because an object instance has to be created. This method will serialize the corresponding information in such a form, that ReadSerializable() can be used to read the written instance.

void wx.Build.BuildProject.WriteStdAttributes ( System.Xml.XmlWriter writer ) [protected, inherited]

Helper for XML serialization of projects. This will use System.Xml.XmlWriter.WriteAttributeString to write the attributes "name" and "preference". Call this immediately after starting the root element of the serialized project.

Parameters:

writer

Destination

override void wx.Build.Cxx.DynamicLibraryProject.WriteXml ( System.Xml.XmlWriter writer ) [virtual]

Serialization of full data. This mus be written by each subclass of a project whereas the standard serialization is generic.

Do not forget to use WriteStdAttributes().

Parameters:

writer

The destination

Implements wx.Build.BuildProject.

ContentFiles wx.Build.Cxx.DynamicLibraryProject.CCPlusPlusHeaders [get]

Collection of C/C++ header files that will be distributed together with the other sources of this project.

ContentFiles wx.Build.Cxx.DynamicLibraryProject.CPlusPlusSources [get]

Returns the collection of C++ source files.

ContentFiles wx.Build.Cxx.DynamicLibraryProject.CSources [get]

Returns the collection of C source files.

override string wx.Build.Cxx.DynamicLibraryProject.Description [get]

Projects always have a descriptive text. This description will be used in dialogs or menus to explain available targets.

Reimplemented from wx.Build.BuildProject.

override FeatureList wx.Build.BuildProject.Features [get, inherited]

The features of the project.

Reimplemented from wx.Build.BaseAction.

Guid wx.Build.BuildProject.Id [get, inherited]

A unique identifier of the project. This will be used on serialization/deserialization to identify the project. This ID will be set on serialization. Not yet serialized projects will return an empty Guid.

See also:: GetGuild

bool wx.Build.BuildProject.IsSingleton [get, inherited]

This is true iff the project can be built. Run GetSingleton() to make this true.

string wx.Build.BuildProject.Name [get, inherited]

Projects always have a name. This name will be used in dialogs or menus to explain available targets.

string wx.Build.BuildProject.NameAsSymbol [get, inherited]

This is the Name but only consisting of letters, digits, and the underscore. Blancs will be replaced by underscores.

virtual ICollection<Type> wx.Build.BaseAction.ParameterTypes [get, inherited]

Returns a collection (typically an array) of relevant parameter types in the BuildConfig. This may be empty or null if instances of this class do not refer to parameter types. The return value of this implementation is null .

Reimplemented in wx.Build.Mono.Gmcs, wx.Build.MS.Cl, wx.Build.MS.Csc, and wx.Build.Cxx.wxWidgets.

ProjectPreference wx.Build.BuildProject.Preference [get, inherited]

Returns the preference of this project. This controls whether the targets of this project will be achieved or not. Some projects will be accomplished only on user input. Some project may be hidden to the end user since they will be achieved only during the build process if reuiqred by other projects or actions.

BuildProject wx.Build.BaseAction.Project [get, set, inherited]

The project that requested this action.

ContentFiles wx.Build.Cxx.DynamicLibraryProject.RCFiles [get]

A collection of RC files that have been provided to this project to define Windows version information or Windows binary resources. Please note, that these sources will only be used with Windows. Those parts of the system that are built of these sources shall either be optional or must be replaced by other (conditionally compiled) sources when compiling for other platforms.

ContentFiles wx.Build.Cxx.DynamicLibraryProject.StaticLibraries [get]

Returns required static libraries. Please note, that this will return all static libraries built for all known compilers if they are required by this project. Refer to the content type to analyze the format of the returned file designators.

ContentFile wx.Build.Cxx.DynamicLibraryProject.Target [get]

The target of this project. This is a content file of type wx.BuildSystem.ContentType.WindowsDll or related types.

virtual IDictionary<string, EnvironmentVarInfo> wx.Build.BaseAction.UsedVars [get, inherited]

This returns null since useually shell variables are not used by actions.

Reimplemented in wx.Build.Cxx.GCC.GccAsCompiler, wx.Build.Cxx.GCC.WindRes, wx.Build.MS.Cl, wx.Build.MS.Link, wx.Build.MS.RC, wx.Build.Release.MakeReleaseProject, wx.Build.Release.ReplaceVersionInRCFile, wx.Build.Release.ReplaceVersionInCSharpFile, and wx.Build.Cxx.wxWidgets.

DateTime wx.Build.BuildProject.ValidityOfDefiningAssemblies [get, inherited]

Validity of the assemblies defining the project and implementing execution. The assemblies defining the project and implementing tools and projects are standard prerequisites of the target. Whenever we change one of these assemblies, we want all targets to be rebuilt. This property returns a timestamp representing the validity of these prerequisites.

DateTime wx.Build.BuildProject.ValidityOfExecutingAssembly [static, get, inherited]

The validity (timestamp) of the assembly file containing this code (if this exists).


Public Member Functions
void	AddCPlusPlusSources (IFileProducts src)
void	AddCSources (IFileProducts src)
delegate void	AdderSerializable (System.Xml.Serialization.IXmlSerializable arg)
void	AddHeaderFiles (IFileProducts src)
void	AddRCFile (IFileProducts src)
void	AddStaticLibrary (IFileProducts src)
virtual bool	AdoptConfig (BuildConfig config)
virtual void	AppendBooCode (List< string > booCodeLines, string indention, BuildToolFamilyEnv env)
virtual void	AppendToBooPreamble (BuildToolFamilyEnv env, List< string > importModules, List< string > booDeclarations, List< string > booDefinitions)
bool	AreAllMandatoryVarsDefined ()
override object	Clone ()
void	CollectChoicePoints (IDictionary< string, ICollection< string >> collectionOfChoicePoints)
virtual int	CompareTo (object obj)
virtual bool	ContainsPrerequisite (IBuildProduct prereq)
override ICollection < IBuildAction >	CreateActionPlan (BuildToolFamilyEnv env)
override RefToProject	CreateRef ()
override RefToFileProject	CreateRefToFileProject ()
RefToSingleFileProject	CreateRefToSingleFileProject ()
	DynamicLibraryProject (ProjectPreference preference, string name, ContentType type, string outputDir, string dllBaseName, string description)
	DynamicLibraryProject (ProjectPreference preference, string name, string outputDir, string dllBaseName, string description)
	DynamicLibraryProject (DynamicLibraryProject src)
	DynamicLibraryProject ()
override bool	Equals (object obj)
Guid	GetGuid ()
override int	GetHashCode ()
override ICollection < IBuildProduct >	GetPrerequisites ()
virtual System.Diagnostics.ProcessStartInfo	GetProgramStartInfo (BuildToolFamilyEnv env)
System.Xml.Schema.XmlSchema	GetSchema ()
new DynamicLibraryProject	GetSingleton ()
override ICollection < IBuildProduct >	GetTargets ()
override DateTime	GetValidity ()
override DateTime	GetValidityDemand ()
DateTime	GetValidityTargets ()
virtual void	NormalizeOriginalFileName (string nameOfAValidDirOrFile)
override void	ReadXml (System.Xml.XmlReader reader)
virtual bool	TargetsAreConsistent (DateTime validityOfBuildSystem)
override string	ToString ()
void	WriteRefXml (System.Xml.XmlWriter writer)
override void	WriteXml (System.Xml.XmlWriter writer)
Static Public Member Functions
static ICollection < BuildProject >	AddIncludedProjects (IDictionary< BuildProject, BuildProject > result, ICollection< IBuildProduct > listOfBuildProducts)
static void	AddKnownProject (BuildProject p)
static int	Build (ErrorHandler handler, System.Reflection.Assembly projectSrc, string[] programOpts)
static int	Build (ErrorHandler handler, string[] programOpts)
static int	Build (string[] programOpts)
static void	ClearKnownProjects ()
static ICollection < BuildProject >	GetAllProjectsDeclaredInAssembly (System.Reflection.Assembly assembly, ICollection< ErrorObject > errors)
static string	GetDllBasename (string filename)
static BuildProject	GetKnownProject (Guid id)
static ICollection < BuildProject >	GetKnownProjects ()
static ICollection < EnvironmentVarInfo >	GetUsedVariables (System.Reflection.Assembly projectSrc)
static BuildProject	LoadRefFrom (System.Xml.XmlReader reader)
static implicit	operator FileProject (RefToFileProject refToProject)
static implicit	operator SingleFileProject (RefToSingleFileProject refToProject)
static bool	ReadCollection (System.Xml.XmlReader reader, AdderSerializable collectorForResults, string outerElementName, string innerElementName)
static System.Xml.Serialization.IXmlSerializable	ReadSerializable (System.Xml.XmlReader reader, string elementName)
static IList < BuildProject >	ScheduleProjects (ICollection< BuildProject > projects)
static string	StringAsSymbol (string aName)
static void	WriteCollectionOfSerializables (System.Xml.XmlWriter writer, System.Collections.IEnumerable serializables, string outerElementName, string innerElementName)
static void	WriteSerializable (System.Xml.XmlWriter writer, System.Xml.Serialization.IXmlSerializable obj, string elementName)
Protected Member Functions
void	ReadProject (System.Xml.XmlReader reader)
void	ReadStdAttributes (System.Xml.XmlReader reader)
void	SetAsKnownProject (Guid oldGuid)
void	WriteProject (System.Xml.XmlWriter writer)
void	WriteStdAttributes (System.Xml.XmlWriter writer)
Static Protected Member Functions
static Guid	RegisterProjectTargets (BuildProject p)
Properties
ContentFiles	CCPlusPlusHeaders `[get]`
ContentFiles	CPlusPlusSources `[get]`
ContentFiles	CSources `[get]`
override string	Description `[get]`
override FeatureList	Features `[get]`
Guid	Id `[get]`
bool	IsSingleton `[get]`
string	Name `[get]`
string	NameAsSymbol `[get]`
virtual ICollection < Type >	ParameterTypes `[get]`
ProjectPreference	Preference `[get]`
BuildProject	Project `[get, set]`
ContentFiles	RCFiles `[get]`
ContentFiles	StaticLibraries `[get]`
ContentFile	Target `[get]`
virtual IDictionary < string, EnvironmentVarInfo >	UsedVars `[get]`
DateTime	ValidityOfDefiningAssemblies `[get]`
static DateTime	ValidityOfExecutingAssembly `[get]`

wx.Build.Cxx.DynamicLibraryProject Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Property Documentation