public ExecutionContext (IExecutionHandler executionHandler, IConsoleFactory consoleFactory, ExecutionTarget target) { var targetedHandler = executionHandler as ITargetedExecutionHandler; if (targetedHandler != null) target = targetedHandler.Target ?? target; this.executionHandler = executionHandler; this.consoleFactory = consoleFactory; this.executionTarget = target; }
public void SetExecutionTarget(SolutionItem project, ExecutionTarget target) { if (target == null) { list.Remove(project); } else { list [project] = target; } //id = string.Join ("/", list.Select (p => p.Value.Id).OrderBy (id => id)); }
/// <summary> /// Gets the full configuration name given a possibly merged configuration name and execution target /// </summary> /// <param name='currentConfig'> /// A configuration name (can be a merged configuration name) /// </param> /// <param name='currentTarget'> /// Selected execution target /// </param> /// <param name='resolvedConfig'> /// Resolved configuration /// </param> /// <param name='resolvedTarget'> /// If the provided target is not valid for the provided configuration, this returns a valid target /// </param> public void ResolveConfiguration (string currentConfig, ExecutionTarget currentTarget, out string resolvedConfig, out ExecutionTarget resolvedTarget) { resolvedConfig = null; resolvedTarget = currentTarget; if (!reducedConfigurations.Contains (currentConfig)) { // The selected configuration is not reduced, just use it as full config name resolvedConfig = currentConfig; var part = currentTargetPartitions.FirstOrDefault (p => p.SolutionConfigurations.Contains (currentConfig)); if (part != null) { if (!ExecutionTargetsContains (part.Targets, resolvedTarget)) resolvedTarget = FirstRealExecutionTarget (part.Targets); } else { resolvedTarget = null; } } else { // Reduced configuration. Find the partition and guess the implicit project configuration var part = currentTargetPartitions.FirstOrDefault (p => ExecutionTargetsContains (p.Targets, currentTarget ?? dummyExecutionTarget)); if (part != null) { resolvedConfig = part.SolutionConfigurations.FirstOrDefault (c => { string name, plat; ItemConfiguration.ParseConfigurationId (c, out name, out plat); return name == currentConfig; }); } if (resolvedConfig == null) { part = currentTargetPartitions.FirstOrDefault (p => p.ReducedConfigurations.Contains (currentConfig)); if (part == null) part = currentTargetPartitions.FirstOrDefault (p => p.SolutionConfigurations.Contains (currentConfig)); if (part != null) { resolvedTarget = FirstRealExecutionTarget (part.Targets); resolvedConfig = part.SolutionConfigurations.FirstOrDefault (c => { string name, plat; ItemConfiguration.ParseConfigurationId (c, out name, out plat); return name == currentConfig; }); if (resolvedConfig == null) resolvedConfig = currentConfig; } else { resolvedTarget = null; resolvedConfig = currentConfig; } } } if (resolvedTarget == dummyExecutionTarget) resolvedTarget = null; }
static bool ExecutionTargetsContains (IEnumerable<ExecutionTarget> targets, ExecutionTarget desired) { foreach (var target in targets) { if (target == desired) return true; if ((target is ExecutionTargetGroup) && ExecutionTargetsContains ((ExecutionTargetGroup) target, desired)) return true; } return false; }
public TargetedExecutionHandler (IExecutionHandler handler, ExecutionTarget target) { Target = target; Handler = handler; }
public RuntimeMutableModel (ExecutionTarget target, bool hasParent) { Enabled = !(target is ExecutionTargetGroup); Visible = true; if (target == null) DisplayString = FullDisplayString = string.Empty; else { FullDisplayString = target.FullName; DisplayString = !hasParent ? target.FullName : target.Name; } }
public RuntimeModel (MainToolbarController controller, ExecutionTarget target, RuntimeModel parent) : this (controller, target) { if (parent == null) HasParent = false; else { HasParent = true; parent.HasChildren = true; parent.AddChild (this); } }
public RuntimeModel (MainToolbarController controller, ExecutionTarget target) : this (controller) { ExecutionTarget = target; }
public RuntimeModel (MainToolbarController controller, ExecutionTarget target, bool fullText, SolutionItem project) : this (controller) { if (target == null) throw new ArgumentNullException (nameof (target)); ExecutionTarget = target; this.fullText = fullText; Project = project; }
bool CurrentExecutionTargetIsCoreClr(ExecutionTarget executionTarget) { var dnxExecutionTarget = executionTarget as DnxExecutionTarget; if (dnxExecutionTarget != null) { return dnxExecutionTarget.IsCoreClr (); } return false; }
public ExecutionContext (IExecutionMode executionMode, IConsoleFactory consoleFactory, ExecutionTarget target) : this (executionMode.ExecutionHandler, consoleFactory, target) { }
public RuntimeModel (MainToolbarController controller, ExecutionTarget target) : this (controller) { ExecutionTarget = target; Enabled = !(ExecutionTarget is ExecutionTargetGroup); Visible = true; }
bool SelectActiveRuntime (ref bool selected, ref ExecutionTarget defaultTarget, ref int defaultIter) { var runtimes = ToolbarView.RuntimeModel.Cast<RuntimeModel> ().ToList (); for (int iter = 0; iter < runtimes.Count; ++iter) { var item = runtimes [iter]; if (!item.Enabled) continue; var target = item.ExecutionTarget; if (target == null || !target.Enabled) continue; if (target is ExecutionTargetGroup) if (item.HasChildren) continue; if (defaultTarget == null) { defaultTarget = target; defaultIter = iter; } if (target.Id == IdeApp.Workspace.PreferredActiveExecutionTarget) { IdeApp.Workspace.ActiveExecutionTarget = target; ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter); UpdateBuildConfiguration (); selected = true; return true; } if (target.Equals (IdeApp.Workspace.ActiveExecutionTarget)) { ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter); UpdateBuildConfiguration (); selected = true; } } return false; }
public ExecutionContext (IExecutionHandler executionHandler, IConsoleFactory consoleFactory, ExecutionTarget target = null) { this.executionHandler = executionHandler; this.consoleFactory = consoleFactory; this.executionTarget = target; }
/// <summary> /// Load configuration information for a solution /// </summary> public void Load (Solution sol, SolutionItem project, SolutionItemRunConfiguration runConfig) { currentSolutionConfigurations.Clear (); currentTargetPartitions.Clear (); reducedConfigurations.Clear (); if (sol == null) return; // Create a set of configuration partitions. Each partition will contain configurations // which are implicitly selected when selecting an execution target. For example, in // an iOS project we would have two partitions: // 1) Debug|IPhoneSimulator, Release|IPhoneSimulator // targets: iPhone, iPad // 2) Debug|IPhone, Release|IPhone // targets: device List<TargetPartition> partitions = new List<TargetPartition> (); if (project != null) { foreach (var conf in project.Configurations) { var targets = project.GetExecutionTargets (conf.Selector, runConfig); if (!targets.Any ()) { targets = new ExecutionTarget[] { dummyExecutionTarget }; } var parts = partitions.Where (p => targets.Any (p.Targets.Contains)).ToArray(); if (parts.Length == 0) { // Create a new partition for this configuration var p = new TargetPartition (); p.Configurations.Add (conf.Id); p.Targets.UnionWith (targets); partitions.Add (p); } else if (parts.Length == 1) { // Register the configuration into an existing partition parts[0].Configurations.Add (conf.Id); parts[0].Targets.UnionWith (targets); } else { // The partitions have to be merged into a single one for (int n=1; n<parts.Length; n++) { parts[0].Configurations.UnionWith (parts[n].Configurations); parts[0].Targets.UnionWith (parts[n].Targets); partitions.Remove (parts[n]); } } } // The startup project configuration partitions are used to create solution configuration partitions foreach (var solConf in sol.Configurations) { var pconf = solConf.GetEntryForItem (project); if (pconf != null && pconf.Build) { var part = partitions.FirstOrDefault (p => p.Configurations.Contains (pconf.ItemConfiguration)); if (part != null) { part.SolutionConfigurations.Add (solConf.Id); continue; } } // The solution configuration is not bound to the startup project // Add it to all partitions so that it can still take part of // the solution configuration simplification process foreach (var p in partitions) p.SolutionConfigurations.Add (solConf.Id); } } if (partitions.Count == 0) { // There is no startup project, just use all solution configurations in this case var p = new TargetPartition (); p.SolutionConfigurations.AddRange (sol.GetConfigurations ()); partitions.Add (p); } // There can be several configurations with the same prefix and different platform but which build the same projects. // If all configurations with the same prefix are identical, all of them can be reduced into a single configuration // with no platform name. This loop detects such configurations var notReducibleConfigurations = new HashSet<string> (); foreach (var p in partitions) { var groupedConfigs = p.SolutionConfigurations.GroupBy (sc => { string name, plat; ItemConfiguration.ParseConfigurationId (sc, out name, out plat); return name; }).ToArray (); foreach (var confGroup in groupedConfigs) { var configs = confGroup.ToArray (); var baseConf = sol.Configurations[configs[0]]; if (configs.Skip (1).All (c => ConfigurationEquals (sol, baseConf, sol.Configurations[c]))) p.ReducedConfigurations.Add (confGroup.Key); else notReducibleConfigurations.Add (confGroup.Key); } } // To really be able to use reduced configuration names, all partitions must have that reduced configuration // Find the configurations that have been reduced in all partitions reducedConfigurations = new HashSet<string> (partitions.SelectMany (p => p.ReducedConfigurations)); reducedConfigurations.ExceptWith (notReducibleConfigurations); // Final merge of configurations var result = new HashSet<string> (); foreach (var p in partitions) result.UnionWith (p.SolutionConfigurations); // Replace reduced configurations foreach (var reducedConf in reducedConfigurations) { result.RemoveWhere (c => { string name, plat; ItemConfiguration.ParseConfigurationId (c, out name, out plat); return name == reducedConf; }); result.Add (reducedConf); } currentTargetPartitions = partitions; currentSolutionConfigurations.AddRange (result); currentSolutionConfigurations.Sort (); }
bool SelectActiveRuntime (ref bool selected, ref ExecutionTarget defaultTarget, ref int defaultIter) { var runtimes = ToolbarView.RuntimeModel.Cast<RuntimeModel> ().ToList (); string lastRuntimeForProject = currentStartupProject.UserProperties.GetValue<string> ("PreferredExecutionTarget", defaultValue: null); var activeTarget = IdeApp.Workspace.ActiveExecutionTarget; var activeTargetId = activeTarget != null ? activeTarget.Id : null; for (int iter = 0; iter < runtimes.Count; ++iter) { var item = runtimes [iter]; using (var model = item.GetMutableModel ()) { if (!model.Enabled) continue; } var target = item.ExecutionTarget; if (target == null || !target.Enabled) continue; if (target is ExecutionTargetGroup) if (item.HasChildren) continue; if (defaultTarget == null || lastRuntimeForProject == target.Id) { defaultTarget = target; defaultIter = iter; } if (target.Id == activeTargetId) { IdeApp.Workspace.ActiveExecutionTarget = target; ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter); UpdateBuildConfiguration (); selected = true; return true; } if (target.Equals (activeTarget)) { ToolbarView.ActiveRuntime = ToolbarView.RuntimeModel.ElementAt (iter); UpdateBuildConfiguration (); selected = true; } } return false; }
bool SelectActiveRuntime (TreeIter iter, ref bool selected, ref ExecutionTarget defaultTarget, ref TreeIter defaultIter) { do { var target = (ExecutionTarget) runtimeStore.GetValue (iter, RuntimeExecutionTarget); if (target == null) continue; if (target is ExecutionTargetGroup) { TreeIter child; if (runtimeStore.IterHasChild (iter) && runtimeStore.IterChildren (out child, iter)) { if (SelectActiveRuntime (child, ref selected, ref defaultTarget, ref defaultIter)) return true; } continue; } if (defaultTarget == null) { defaultTarget = target; defaultIter = iter; } if (target.Id == IdeApp.Workspace.PreferredActiveExecutionTarget) { IdeApp.Workspace.ActiveExecutionTarget = target; runtimeCombo.SetActiveIter (iter); UpdateBuildConfiguration (); selected = true; return true; } if (target.Equals (IdeApp.Workspace.ActiveExecutionTarget)) { runtimeCombo.SetActiveIter (iter); UpdateBuildConfiguration (); selected = true; } } while (runtimeStore.IterNext (ref iter)); return false; }
public ExecutionContext (IExecutionMode executionMode, IConsoleFactory consoleFactory, ExecutionTarget target) { this.executionHandler = executionMode.ExecutionHandler; this.consoleFactory = consoleFactory; this.executionTarget = target; }