wx.Net.Build: wx.Build.BuildProject Class Reference

Projects will be stored in a static DB of all projects. They cannot be removed. Projects will be identified by their name.

Projects shall be defined in static methods of the core assembly e.g. like the following:

        public static wx.Build.Net.CSharpAssemblyProject WxNetProject
        {
            get
            {
                Net.CSharpAssemblyProject wxNetProject = new wx.Build.Net.CSharpAssemblyProject(ProjectPreference.Default,
                    "wx.NET",
                    "wx.NET.dll", "The managed part of the wx.NET implementation.");
                wxNetProject.CSharpSources = new FileSelector(ContentType.CSharpCode, "..\\Src\\wx.NET", "*.cs", "wx.NET C# source files.");
                wxNetProject.ReferencesAssemblies = new ContentFiles(ContentType.DotNetDll, ContentFileLocation.GlobalAssemblyCache,
                    "System.dll", "System.Drawing.dll", "System.Xml.dll");
                wxNetProject.Signature = new ContentFile(ContentType.SnKeys, "..\\Src\\wx.NET\\keys.snk");

                wxNetProject.Features.Add(new FeatureEntry("Styled Text Control", "Enables namespace wx.StyledText", "WXNET_STYLEDTEXTCTRL"), true);
                wxNetProject.Features.Add(new FeatureEntry("Display Access", "Enables class wx.Display", "WXNET_DISPLAY"), true);

                return wxNetProject.GetSingleton();
            }
        }

Please also note, that projects may have a strong relation to the build configuration (refer to class BuildConfig). Many projects require certain options to be enabled or disabled. Additionally, projects often share certain configuration. All project relying to configurations from a particular subclass of BuildParameters refer to the same instance of this class, since the build configuration is a singleton. This is to ensure that all options are used in a consistent manner. So, for instance, all project using a C++ compiler will use the same options referring to exception handling, packing structures and all those definitions that often produce link error if applied inconsistently.

Immediately before starting the build process (calling BuildProject.Execute()) the build system will ask all project with BuildProject.AdoptConfig() to change the parameters in order to fit the own needs.

Instance of BuildProject are te core of the build system. They are used to define the desired build targets and their implementations of method BuildProject.CreateActionPlan() produce the action plans that are actually used to create the build targets.

Constructor & Destructor Documentation

wx.Build.BuildProject.BuildProject	(	System.Reflection.Assembly	definingAssembly,
		ProjectPreference	preference,
		string	projectName
	)			`[protected]`

This will add the project to the DB using the provided name. This will raise an exception, if a project of this name is already known.

Parameters:

	preference	Preference of the project - is this mandatory or not. Refer to `Preference` .
	projectName	Refer to `Name` . The name of the project shall exclusively consist of alpha-numerical characters, the underscore '_', the dash '-', blanks ' ', '&', '', or the fullstop character '.'.
	definingAssembly	Is the assembly defining the project. This will be used to compute a validity of the project definition. This may be `null`.

Member Function Documentation

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.

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

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]

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:

The project that shall be added.

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

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]`

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]`

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]

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]

Clear the loaded projects.

abstract object wx.Build.BuildProject.Clone ( ) [pure virtual]

Deep copy of this instance.

Implemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Release.MakeReleaseProject, and wx.Build.Cxx.wxWidgets.

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]

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.

abstract ICollection<IBuildAction> wx.Build.BuildProject.CreateActionPlan ( BuildToolFamilyEnv env ) [pure virtual]

Creates a plan to achieve the GetTargets().

Returns:: Return actions to achieve the targets of this projects. The method shall return at most one action to achieve the same target. However, a returned action might achieve more than one target. Thus, this returns as most as many action plans as targets are defined. Each returned plan must be executable independently. The result is null if this encounters errors that shall stop the build process.

The resulting actions may consist of instances of AlternativeBuildActions or SequenceOfBuildActions that represent alternative build actions or sequence of actions.

The result of this method will be considered as a collection of actions that all have to run to build all targets of the project. However, if this project is optional or hidden, the build process control will consider only those actions for execution that produce an actually required target.

This will start a build procedure either reusing results of previous builds (rebuild) or making everything from scratch. So, is the desired mode (refer to BuildConfig) is rebuild, this simply does nothing if this action already has been executed with the same prerequisites.

Implemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Release.MakeReleaseProject, and wx.Build.Cxx.wxWidgets.

virtual RefToProject wx.Build.BuildProject.CreateRef ( ) [virtual]

This returns an instance of RefToProject encapsulating this. However, projects may return an instance of a more specific class here if appropriate.

Returns:

Reimplemented in wx.Build.FileProject, and wx.Build.SingleFileProject.

override bool wx.Build.BuildProject.Equals ( object obj )

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

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

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`.

Guid wx.Build.BuildProject.GetGuid ( )

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

override int wx.Build.BuildProject.GetHashCode ( )

Reimplemented in wx.Build.Release.MakeReleaseProject.

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

Returns the project of the provided ID.

Parameters:

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]

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

abstract ICollection<IBuildProduct> wx.Build.BaseAction.GetPrerequisites ( ) [pure virtual, inherited]

Collection of the prerequisites of this action.

Implemented in wx.Build.FileTestAction, wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Net.CSharpCodeProvider, 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.MS.Al, wx.Build.Release.MakeReleaseProject, wx.Build.Release.ReplaceVersionInRCFile, wx.Build.Release.ReplaceVersionInCSharpFile, wx.Build.Release.CopyFileAction, and wx.Build.Cxx.wxWidgets.

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 ( )

Returns null as suggested by the .NET framework documentation.

BuildProject wx.Build.BuildProject.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 in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, and wx.Build.Release.MakeReleaseProject.

abstract ICollection<IBuildProduct> wx.Build.BaseAction.GetTargets ( ) [pure virtual, inherited]

Collection of the targets or products of this action.

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

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]

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]

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]

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]

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 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]

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.

abstract void wx.Build.BuildProject.ReadXml ( System.Xml.XmlReader reader ) [pure 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

Implemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Release.MakeReleaseProject, and wx.Build.Cxx.wxWidgets.

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

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:

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]

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]

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]

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 ( )

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 )

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]

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

abstract void wx.Build.BuildProject.WriteXml ( System.Xml.XmlWriter writer ) [pure 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

Implemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Release.MakeReleaseProject, and wx.Build.Cxx.wxWidgets.

Property Documentation

abstract string wx.Build.BuildProject.Description [get]

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

Reimplemented in wx.Build.Net.CSharpAssemblyProject, wx.Build.Cxx.DynamicLibraryProject, wx.Build.Release.MakeReleaseProject, and wx.Build.Cxx.wxWidgets.

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

The features of the project.

Reimplemented from wx.Build.BaseAction.

Guid wx.Build.BuildProject.Id [get]

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]

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

string wx.Build.BuildProject.Name [get]

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

string wx.Build.BuildProject.NameAsSymbol [get]

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]

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.

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]

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.


Public Member Functions
delegate void	AdderSerializable (System.Xml.Serialization.IXmlSerializable arg)
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 ()
abstract object	Clone ()
void	CollectChoicePoints (IDictionary< string, ICollection< string >> collectionOfChoicePoints)
virtual int	CompareTo (object obj)
virtual bool	ContainsPrerequisite (IBuildProduct prereq)
abstract ICollection < IBuildAction >	CreateActionPlan (BuildToolFamilyEnv env)
virtual RefToProject	CreateRef ()
override bool	Equals (object obj)
Guid	GetGuid ()
override int	GetHashCode ()
abstract ICollection < IBuildProduct >	GetPrerequisites ()
virtual System.Diagnostics.ProcessStartInfo	GetProgramStartInfo (BuildToolFamilyEnv env)
System.Xml.Schema.XmlSchema	GetSchema ()
BuildProject	GetSingleton ()
abstract ICollection < IBuildProduct >	GetTargets ()
override DateTime	GetValidity ()
override DateTime	GetValidityDemand ()
DateTime	GetValidityTargets ()
virtual void	NormalizeOriginalFileName (string nameOfAValidDirOrFile)
abstract void	ReadXml (System.Xml.XmlReader reader)
virtual bool	TargetsAreConsistent (DateTime validityOfBuildSystem)
override string	ToString ()
void	WriteRefXml (System.Xml.XmlWriter writer)
abstract 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 BuildProject	GetKnownProject (Guid id)
static ICollection < BuildProject >	GetKnownProjects ()
static ICollection < EnvironmentVarInfo >	GetUsedVariables (System.Reflection.Assembly projectSrc)
static BuildProject	LoadRefFrom (System.Xml.XmlReader reader)
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
	BuildProject (System.Reflection.Assembly definingAssembly, ProjectPreference preference, string projectName)
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
abstract 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]`
virtual IDictionary < string, EnvironmentVarInfo >	UsedVars `[get]`
DateTime	ValidityOfDefiningAssemblies `[get]`
static DateTime	ValidityOfExecutingAssembly `[get]`

wx.Build.BuildProject 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