private IEnumerable <TargetRelativePath> GetDependencyResults(IBuildContext context, IBuilder node)
{
var referenceBuilder = node as IReferenceBuilder;
if (referenceBuilder != null)
{
foreach (var depSource in context.GetResults(referenceBuilder))
{
foreach (var project in slnBuilder.Projects)
{
if (project.References.Contains(referenceBuilder.Reference))
{
// We expect the msbuild compilation to copy these dependencies to the module target directory
yield return(new TargetRelativePath(project.RelativeTargetPath, Path.GetFileName(depSource.RelativePath)));
}
}
}
}
else
{
foreach (var result in context.GetDependencies(node).SelectMany(child => GetDependencyResults(context, child)))
{
yield return(result);
}
}
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var vcxprojPath = project.Name + ".vcxproj";
const string csversionPath = "version.cpp";
var csversion = project.GetVersionSupport() ? project.RootDirectory.CreateTextFile(csversionPath) : null;
using (var fsproj = project.RootDirectory.GetChildDirectory("cpp").CreateTextFile(vcxprojPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
generator.Generate(project, references, fsproj, csversion, csversionPath);
}
if (csversion != null)
{
csversion.Close();
csversion.Dispose();
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "cpp", vcxprojPath))),
}));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var fsprojPath = project.Name + ".fsproj";
const string fsversionPath = "version.fs";
using (var fsproj = project.RootDirectory.GetChildDirectory("fs").CreateTextFile(fsprojPath))
using (var fsversion = project.RootDirectory.CreateTextFile(fsversionPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
generator.Generate(project, references, fsproj, fsversion, fsversionPath);
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "fs", fsprojPath))),
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), fsversionPath)))
}));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var results = new HashSet <TargetRelativePath>();
foreach (var builder in builders)
{
results.UnionWith(context.GetResults(builder));
}
return(results);
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var result = new HashSet <TargetRelativePath>();
foreach (var builder in sourceBuilders)
{
log.DebugFormat("..merging {0}", builder);
result.UnionWith(context.GetResults(builder));
}
return(result);
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var result = new HashSet <TargetRelativePath>();
foreach (var subtask in subtasks)
{
var subResults = context.GetResults(subtask);
result.UnionWith(subResults);
}
// result contains the output of the full module - selecting only the referenced project's expected build output
string expectedFileName = referencedProject.Name.ToLower();
return(new HashSet <TargetRelativePath>(result.Where(
path => Path.GetFileNameWithoutExtension(path).ToLowerInvariant() == expectedFileName)));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public ISet <TargetRelativePath> Run(IBuildContext context)
{
var files = context.GetResults(sourceBuilder);
var result = new HashSet <TargetRelativePath>();
foreach (var sourcePath in files)
{
log.DebugFormat("Copying result {0}...", sourcePath);
var relativePath = sourcePath.RelativePath;
Copy(sourcePath, relativePath);
result.Add(new TargetRelativePath(targetRoot.GetRelativePath(targetDirectory), relativePath));
}
return(result);
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var csprojPath = project.Name + ".csproj";
const string csversionPath = "version.cs";
using (var csproj = project.RootDirectory.GetChildDirectory("cs").CreateTextFile(csprojPath))
using (var csversion = project.RootDirectory.CreateTextFile(csversionPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
try
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
catch (InvalidOperationException ex)
{
log.ErrorFormat("Failed to get results of reference {0}: {1}", refBuilder, ex.Message);
throw;
}
}
generator.Generate(project, references, csproj, csversion, csversionPath);
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "cs", csprojPath))),
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), csversionPath)))
}));
}
public ISet <TargetRelativePath> GetResults(IBuilder builder)
{
return(baseContext.GetResults(ResolveBuilder(builder)));
}
