public override void Execute() { if (Application.DisplayManual) { ForgeTool.DisplayManual(); } else { TaskGraph.SetEndPoints(Application.Profile.GetEndPoints()); AppDomain.CurrentDomain.GetAssemblies().ParallelFor((assembly) => { foreach (Type task in assembly.GetTypes <ITaskPrototype>()) { if (!task.IsAbstract) { try { TaskPrototypes.Add(task.CreateInstance <ITaskPrototype>()); } catch (Exception er) { if (Application.LogSeverity == SeverityFlags.Full) { Application.Error(SeverityFlags.None, "{0}{1}{2}", er.Message, Environment.NewLine, er.StackTrace); } else { Application.Error(SeverityFlags.None, er.Message); } } } } }); foreach (FileDescriptor file in Application.GetBuildFiles()) { outputPins.Add(new FlaggedPin(this, file, SystemTags.SealedSetup)); } UInt32 flag; if (outputPins.Count > 0) { flag = SystemTags.SealedSetup; } else { flag = SystemTags.ForgeSetup; } foreach (PathDescriptor path in Application.GetBuildPaths()) { outputPins.Add(new FlaggedPin(this, path, flag)); } if (outputPins.Count == 0) { Application.Error(SeverityFlags.None, "Build paths not valid"); } } }
public override void Execute() { LoadInput(); foreach (TaskPin inputPin in inputPins) { outputPins.Add(new FlaggedPin(this, inputPin.Data, SystemTags.ForgeSetup)); } TaskPrototypes.Remove(this); }
void GenerateInputTasks(List <Task> parentTasks) { List <Task> tasks = new List <Task>(); { ICollection <ICollection <Task> > tuple = parentTasks.ParallelGetCombinations(parentTasks.Count, 2); tuple.Reverse().ParallelFor((set) => { TaskPin[] outPins = set.SelectMany(x => x.OutputPins).ToArray(); if (outPins.Length <= 1) { return; } foreach (ITaskPrototype prototype in TaskPrototypes.Get(outPins.Length, TaskPriorityFlag.Primary)) { if (prototype.InputPins.IsEqual(outPins, comparer)) { Task result = prototype.CreateInstance(); Dictionary <TaskPin, TaskPin> inPins = result.InputPins.ToDictionary <TaskPin, TaskPin>(x => x, comparer); List <TaskPin> connectedPins = new List <TaskPin>(inPins.Count); foreach (TaskPin outPin in outPins) { TaskPin inPin; if (inPins.TryGetValue(outPin, out inPin)) { lock (outPin) { if (prototype.ExclusiveUse) { outPin.Locked = true; } } connectedPins.Add(outPin); } } List <Task> taskCache = new List <Task>(8); GetTasks(TaskPrototypes.Get(outPins.Length, TaskPriorityFlag.Before), connectedPins, taskCache); if (taskCache.Count > 0) { Task parent = tasks[tasks.Count - 1]; inPins = result.InputPins.ToDictionary <TaskPin, TaskPin>(x => x, comparer); foreach (TaskPin outPin in parent.OutputPins) { inPins[outPin].Parent = outPin; } AddChild(parent, result); } taskCache.Add(result); inPins = taskCache[0].InputPins.ToDictionary <TaskPin, TaskPin>(x => x, comparer); foreach (TaskPin outPin in connectedPins) { inPins[outPin].Parent = outPin; } GetTasks(TaskPrototypes.Get(outPins.Length, TaskPriorityFlag.After), result.OutputPins, taskCache); lock (tasks) { foreach (Task parent in set) { AddChild(parent, taskCache[0]); } tasks.Add(taskCache[taskCache.Count - 1]); } } } }); } { TaskPin[] outPins = parentTasks.SelectMany(x => x.OutputPins).ToArray(); TaskPrototypes.Get(0, TaskPriorityFlag.Primary).ParallelFor((prototype) => { List <TaskPin> pins = new List <TaskPin>(); foreach (TaskPin outPin in outPins) { if (!outPin.Locked) { if (prototype.VariadicAccepts(outPin)) { pins.Add(outPin); } } } if (pins.Count > 0) { IEnumerable <Task> parents = pins.Select(x => x.Owner).Distinct(); VariadicTask result = (prototype.CreateInstance() as VariadicTask); result.AddRange(pins); lock (tasks) { foreach (Task parent in parents) { AddChild(parent, result); } tasks.Add(result); } } }); } parentTasks.ParallelFor((task) => { foreach (TaskPin outPin in task.OutputPins) { if (!outPin.Locked) { foreach (ITaskPrototype prototype in TaskPrototypes.Get(1, TaskPriorityFlag.Primary)) { if (prototype.InputPins[0].Accepts(outPin)) { List <Task> taskCache = new List <Task>(8); Task result = prototype.CreateInstance(); GetTasks(TaskPrototypes.Get(1, TaskPriorityFlag.Before), new TaskPin[] { outPin }, taskCache); if (taskCache.Count > 0) { Task parent = tasks[tasks.Count - 1]; result.InputPins[0].Parent = parent.OutputPins[0]; AddChild(parent, result); } taskCache.Add(result); taskCache[0].InputPins[0].Parent = outPin; GetTasks(TaskPrototypes.Get(1, TaskPriorityFlag.After), new TaskPin[] { taskCache[0].OutputPins[0] }, taskCache); AddChild(task, taskCache[0]); lock (tasks) tasks.Add(taskCache[taskCache.Count - 1]); } } } } }); if (tasks.Count > 0) { GenerateInputTasks(tasks); } }