wx.Net.Build: wx.Build.Release.MakeReleaseProject Class Reference

wx.Build.Release.MakeReleaseProject.MakeReleaseProject ( )

Creates an empty project. Use this only in conjunction with ReadXml() to create an instance whose properties will be loaded from an XML stream.

wx.Build.Release.MakeReleaseProject.MakeReleaseProject	(	string	name,
		params BuildProject[]	originalProjects
	)

Creates an instance of the provided name including the targets of the provided projects.

Note, that projects of this type always are optional since they require environment BUILD_VERSION to be set. Otherwise, all build programs providing this project will require users to define a build version in order to build anything.

Parameters:

	name	Name of the resulting project release. this will be used in user interfaces.
	originalProjects	Instances of wx.Build.Net.CSharpAssemblyProject and wx.Build.Cxx.DynamicLibraryProject or projects implementing wx.Build.IFileProducts.

wx.Build.Release.MakeReleaseProject.MakeReleaseProject ( MakeReleaseProject src )

Deep copy

Parameters:

src

The source

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

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.Release.MakeReleaseProject.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");

override int wx.Build.Release.MakeReleaseProject.CompareTo ( object obj ) [virtual]

This comparison relies on the projects that are contained if both - this and the argument - are of the same type. Otherwise, the result is the comparison of the full type name of this and the argument - as required by the specification of BuildProject.CompareTo().

Parameters:

obj

The object that will be compared to this instance.

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

Reimplemented from wx.Build.BuildProject.

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.

static string wx.Build.Release.MakeReleaseProject.ConversionFilenameToFilenameWithVersion	(	string	filename,
		Version	version
	)			`[static]`

Public helper that defines how to code version info into the filename of a native dll file.

Parameters:

	filename	The filename of a DLL like `wx-c.dll` or `libwx-c.so`.
	version	Version info like 1.0.0.1

Returns:: A filename depending on the arguments like wx-c-1-0-0-1.dll or libwx-c-1-0-0-1.so

static ContentFile wx.Build.Release.MakeReleaseProject.ConversionFullFilenameToFullFilenameWithVersion	(	ContentFile	originalTarget,
		Version	releaseVersion,
		bool	isTarget
	)			`[static]`

This will use ConversionPathToPathWithVersion() to return a full filename (containing info on the directory of the file) where a copy of originalTarget will be placed that is part of the releaseVersion.

Parameters:

isTarget indicates with true that the resulting file is a target. Usually, files will be created just like temporary files. In contrast, targets will be created in a subdir of the directory, where the original lies.

static string wx.Build.Release.MakeReleaseProject.ConversionPathToPathWithVersion	(	string	path,
		Version	version
	)			`[static]`

Creates the name of the directory name that will contain those parts of the release version that would originally be stored in directory path.

Parameters:

	path	Is the path to the original file
	version	Is the version information of the release to be built.

<return>Is a subdir of path that will be used to hold parts of release version.</return>

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

This will use actions of the classes CopyFileAction in order to copy files into the release directory. Actions of class ReplaceVersionInCSharpFile will be used to adopt C# sources, ReplaceVersionInRCFile will be used to change RC-files if they contain version information of a native Windoes DLL that is part of the project. Sources of contained Dll-Projects and managed executables will be adopted (using approrpiate actions). Sources of native DLLs will also be adopted as described above. Additionally, native DLLs will be renamed. All P-Invoke references to the renamed DLLs will be changed.

Implements wx.Build.BuildProject.

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

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

IDictionary<ContentFile, ContentFile> wx.Build.Release.MakeReleaseProject.GetDllConversionScheme ( Version version )

This will return a dictionary mapping content files with version info coded into the filename to the originals without filenames reflecting the release version. Conversion is according to AmendFilenameWithVersion(). The mapped / versioned filenames will be created using TempFilesParameters.

Parameters:

version

The version info that shall be coded into the mapped filenames.

Returns:: A mapping of unversioned filenames of included native DLLs to filenames reflecting the release.

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

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

Id

override int wx.Build.Release.MakeReleaseProject.GetHashCode ( )

Reimplemented from wx.Build.BuildProject.

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.Release.MakeReleaseProject.GetPrerequisites ( ) [virtual]

Returns:: The list of prerequisites that are required to build the release.

This project requires all sources of those projects on native and managed DLLs and executable programs that are part of the release. Additionally, this type of project also requires all targets of other contained project producing content files (implementing wx.Build.IFileProducts).

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 MakeReleaseProject wx.Build.Release.MakeReleaseProject.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.Release.MakeReleaseProject.GetTargets ( ) [virtual]

Returns:: A collection of the files that will be rebuild (with new version information), renamed, or copied from the original projects.

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

override void wx.Build.Release.MakeReleaseProject.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 from wx.Build.BuildProject.

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.Release.MakeReleaseProject.ReadXml ( System.Xml.XmlReader reader ) [virtual]

Reading a project from an XML stream. Please note, that this method requires all contained projects to be already part of the loaded projects.

Parameters:

reader

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.Release.MakeReleaseProject.WriteXml ( System.Xml.XmlWriter writer ) [virtual]

Serializes all properties of this project. Please note, that this will only write references of the contained projects. So, make sure that this runs after serializing all contained projects.

Parameters:

writer

Implements wx.Build.BuildProject.

IDictionary<ContentFile, ICollection<ReplaceVersionInCSharpFile> > wx.Build.Release.MakeReleaseProject.ActionsToProduceSourcesForCSharpShadowProjects [get]

A dictionary containing collections of actions that are necessary to prepare the sources of a contained C# assembly project. Assume, that p is a project to produce managed assembly wx.NET. Then the result of this method contains a collection for key content file "wx.NET" comprising a number of actions of class ReplaceVersionInCSharpFile that have to run to adopt the original sources of "wx.NET" to the new release.

EnvironmentVarInfo wx.Build.Release.MakeReleaseProject.BuildVersionVariable [get]

The variable info for variable BUILD_VERSION.

override string wx.Build.Release.MakeReleaseProject.Description [get]

Description of the project. Currently: "A release composed of the projects ..."

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.

ICollection<KeyValuePair<Net.CSharpAssemblyProject, Net.CSharpAssemblyProject> > wx.Build.Release.MakeReleaseProject.ShadowCSharpProjects [get]

All projects building managed Dlls and executables from C# sources that will be part of the release will be transformed: Occasionally, contained version info will be changed. Additionally, included P-Invoke references to native DLLs that are also part of the release will change.

This collection will contain pairs of the original project as key value and the transformed project as value.

Do not change the result. Consider the result to be read-only.

ICollection<KeyValuePair<Cxx.DynamicLibraryProject,Cxx.DynamicLibraryProject> > wx.Build.Release.MakeReleaseProject.ShadowDllProjects [get]

All projects building native Dlls that will be part of the release will be transformed: Occasionally, contained version info will be changed. Additionally, the resulting DLL will be changed. This collection contains the transformations of the original native DLL projects reflecting these changes.

This collection will contain pairs of the original project as key value and the transformed project as value.

Do not change the result. Consider the result to be read-only.

override IDictionary<string, EnvironmentVarInfo> wx.Build.Release.MakeReleaseProject.UsedVars [get]

This project requires variable BUILD_VERSION to be set. Variable BUILD_VERSION must have a System.Version string as value.

Reimplemented from wx.Build.BaseAction.

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
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 ()
override object	Clone ()
void	CollectChoicePoints (IDictionary< string, ICollection< string >> collectionOfChoicePoints)
override int	CompareTo (object obj)
virtual bool	ContainsPrerequisite (IBuildProduct prereq)
override ICollection < IBuildAction >	CreateActionPlan (BuildToolFamilyEnv env)
virtual RefToProject	CreateRef ()
override bool	Equals (object obj)
IDictionary < ContentFile, ContentFile >	GetDllConversionScheme (Version version)
Guid	GetGuid ()
override int	GetHashCode ()
override ICollection < IBuildProduct >	GetPrerequisites ()
	Returns: The list of prerequisites that are required to build the release.
virtual System.Diagnostics.ProcessStartInfo	GetProgramStartInfo (BuildToolFamilyEnv env)
System.Xml.Schema.XmlSchema	GetSchema ()
new MakeReleaseProject	GetSingleton ()
override ICollection < IBuildProduct >	GetTargets ()
	Returns: A collection of the files that will be rebuild (with new version information), renamed, or copied from the original projects.
override DateTime	GetValidity ()
override DateTime	GetValidityDemand ()
DateTime	GetValidityTargets ()
	MakeReleaseProject (MakeReleaseProject src)
	MakeReleaseProject (string name, params BuildProject[] originalProjects)
	MakeReleaseProject ()
override 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 string	ConversionFilenameToFilenameWithVersion (string filename, Version version)
static ContentFile	ConversionFullFilenameToFullFilenameWithVersion (ContentFile originalTarget, Version releaseVersion, bool isTarget)
static string	ConversionPathToPathWithVersion (string path, Version version)
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
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
IDictionary < ContentFile, ICollection < ReplaceVersionInCSharpFile > >	ActionsToProduceSourcesForCSharpShadowProjects `[get]`
EnvironmentVarInfo	BuildVersionVariable `[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]`
ICollection < KeyValuePair < Net.CSharpAssemblyProject, Net.CSharpAssemblyProject > >	ShadowCSharpProjects `[get]`
ICollection < KeyValuePair < Cxx.DynamicLibraryProject, Cxx.DynamicLibraryProject > >	ShadowDllProjects `[get]`
override IDictionary < string, EnvironmentVarInfo >	UsedVars `[get]`
DateTime	ValidityOfDefiningAssemblies `[get]`
static DateTime	ValidityOfExecutingAssembly `[get]`

wx.Build.Release.MakeReleaseProject 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