public static void PrintArgument(List <string> lines, ICommandLineArgument arg, string indent)
{
lines.Add(indent + "--" + arg.Name + " (" + arg.Typename + "): " + arg.ShortDescription);
if (arg.Deprecated)
{
lines.Add(indent + " " + Strings.CommandLineArgument.DeprecationMarker + ": " + arg.DeprecationMessage);
}
lines.Add(indent + " " + arg.LongDescription);
if (arg.Aliases != null && arg.Aliases.Length > 0)
{
lines.Add(indent + " * " + Strings.CommandLineArgument.AliasesHeader + ": --" + string.Join(", --", arg.Aliases));
}
if (arg.ValidValues != null && arg.ValidValues.Length > 0)
{
lines.Add(indent + " * " + Strings.CommandLineArgument.ValuesHeader + ": " + string.Join(", ", arg.ValidValues));
}
if (!string.IsNullOrEmpty(arg.DefaultValue))
{
lines.Add(indent + " * " + Strings.CommandLineArgument.DefaultValueHeader + ": " + arg.DefaultValue);
}
}
/// <summary>
/// Returns a collection of values starting at <paramref name="argument"/>, and ending at the next value that begins
/// with the first character of <paramref name="argument"/>.
/// </summary>
/// <param name="argument">The argument to search for.</param>
/// <param name="comparer">The comparer to use when determining if a match was found.</param>
/// <param name="argumentsToParse">
/// The collection to search.
/// Specifying null will default to <see cref="CommandLine.Arguments"/>.
/// </param>
/// <returns>
/// Returns all child <see cref="ICommandLineArgument.Command"/> and parameters based upon the
/// <see cref="ICommandLineSpecification"/> if <paramref name="argument"/> is found.
/// Returns an empty collection if <paramref name="argument"/> is not found.
/// </returns>
/// <remarks>
/// This method searches <paramref name="argumentsToParse"/> for a value that matches <paramref name="argument"/>
/// using the <see cref="Comparer"/> value.
/// Once found, that value and all proceeding values are returned until a value whose first character matches that
/// of the <paramref name="argument"/>'s delimiter.
///
/// If <paramref name="argumentsToParse"/> is null, <see cref="Arguments"/> is used.
///
/// If no matches to <paramref name="argument"/> are found, an empty collection is returned.
/// </remarks>
public static IEnumerable <string> GetSegment(this ICommandLineArgument argument, StringComparison?comparer = null, IEnumerable <string> argumentsToParse = null)
{
var workingSegment = argumentsToParse ?? Arguments;
var workingComparer = comparer ?? Comparer;
bool didFindFirst = false;
if (workingSegment.Any(str => argument.Command.Equals(str, workingComparer)))
{
foreach (var arg in workingSegment)
{
if (!didFindFirst)
{
if (argument.Command.Equals(arg, workingComparer))
{
yield return(arg);
didFindFirst = true;
}
}
else
{
if (arg.StartsWith(argument.Specification.Delimiter))
{
break;
}
else
{
yield return(arg);
}
}
}
}
}
UsesName(
ICommandLineArgument arg,
string[] splitArgs)
{
var uses = ((splitArgs[0].StartsWith("--") && splitArgs[0].EndsWith(arg.LongName)) ||
((arg.ShortName != null) && (splitArgs[0].StartsWith("-") && splitArgs[0].EndsWith(arg.ShortName))));
return uses;
}
UsesName(
ICommandLineArgument arg,
string[] splitArgs)
{
var uses = ((splitArgs[0].StartsWith("--") && splitArgs[0].EndsWith(arg.LongName)) ||
((arg.ShortName != null) && (splitArgs[0].StartsWith("-") && splitArgs[0].EndsWith(arg.ShortName))));
return(uses);
}
public override void Run(ICommandLineArgument[] args) {
core = new HeuristicLab.Clients.Hive.SlaveCore.Core();
Thread coreThread = new Thread(core.Start);
coreThread.IsBackground = true;
coreThread.Start();
MainWindow window = new MainWindow();
window.Content = new SlaveItem();
Application.ApplicationExit += new System.EventHandler(Application_ApplicationExit);
Application.Run(window);
}
public override void Run(ICommandLineArgument[] args) {
HeuristicLab.MainForm.WindowsForms.MainForm mainForm = null;
if (Settings.Default.MainFormType == OptimizerMainFormTypes.DockingMainForm) {
mainForm = new OptimizerDockingMainForm(typeof(IOptimizerUserInterfaceItemProvider));
} else if (Settings.Default.MainFormType == OptimizerMainFormTypes.MultipleDocumentMainForm) {
mainForm = new OptimizerMultipleDocumentMainForm(typeof(IOptimizerUserInterfaceItemProvider));
} else if (Settings.Default.MainFormType == OptimizerMainFormTypes.SingleDocumentMainForm) {
mainForm = new OptimizerSingleDocumentMainForm(typeof(IOptimizerUserInterfaceItemProvider));
}
if (mainForm != null) {
if (CheckSavedMainFormSettings()) {
mainForm.Location = Settings.Default.MainFormLocation;
mainForm.Size = Settings.Default.MainFormSize;
mainForm.WindowState = Settings.Default.MainFormWindowState;
}
mainForm.FormClosing += (sender, eventArgs) => {
if (mainForm.WindowState != FormWindowState.Minimized)
Settings.Default.MainFormWindowState = mainForm.WindowState;
if (mainForm.WindowState != FormWindowState.Normal) {
Settings.Default.MainFormLocation = mainForm.RestoreBounds.Location;
Settings.Default.MainFormSize = mainForm.RestoreBounds.Size;
} else if (mainForm.WindowState == FormWindowState.Normal) {
Settings.Default.MainFormLocation = mainForm.Location;
Settings.Default.MainFormSize = mainForm.Size;
}
};
ClientInformation.InitializeAsync();
UserInformation.InitializeAsync();
mainForm.ShowContentInViewHost = true;
var filesToOpen = args.OfType<OpenArgument>().Select(x => x.Value);
mainForm.Load += (sender, eventArgs) => FileManager.OpenFiles(filesToOpen);
Application.Run(mainForm);
} else {
MessageBox.Show("Error loading setting for the MainForm Type. Please check your configuration file!", "HeuristicLab", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void AddArgument(ICommandLineArgument argument)
{
// Ensure the argument already has a parser registered.
if (!argumentTypeParsers.ContainsKey(argument.ArgumentType))
{
throw new ArgumentException($"ArgumentParser for type {argument.ArgumentType} is not registered.", nameof(argument));
}
// Ensure the argument isn't already registered.
if (arguments.ContainsKey(argument.Name))
{
throw new ArgumentException($"Argument {argument.Name} is already registered.", nameof(argument));
}
arguments[argument.Name] = argument;
if (argument.IsRequired)
{
requiredArguments.Add(argument.Name);
}
}
/// <summary> /// Runs the application. /// </summary> public abstract void Run(ICommandLineArgument[] args);
/// <summary>
/// Creates new instance of <see cref="CommandLineGrouping"/>.
/// <para>
/// *See remarks for further details and correct implementation.
/// </para>
/// </summary>
/// <param name="parentCallChain">The parent call-chain.</param>
/// <param name="children">The associated children in relation to <paramref name="parentCallChain"/>.</param>
/// <param name="description">A description of what this grouping represents or does within the scope of the application.</param>
/// <exception cref="System.ArgumentNullException">
/// Throws when <paramref name="parentCallChain"/> is null or contains not elements.
/// </exception>
/// <remarks>
/// The <see cref="ICommandLineGrouping.ParentCallChain"/> property represents the full parent hierarchy chain.
///
/// The <see cref="ICommandLineGrouping.Children"/> property represents associated child pairings.
/// It is important to note this property is not an "all inclusive" listing", but rather an individual grouping.
/// This means that if you have one "main argument", which has three "child arguments", then specifying a grouping
/// with "main" and "childOne" would transpose to the command line as "$ main childOne".
///
/// If you wanted to specify a grouping that states "main" must run with "childOne" and "childTwo", but leave "childThree" as optional,
/// then you would create two groupings; one with "childOne" and "childTwo"; the other, with "childOne", "childTwo", and "childThree".
/// </remarks>
public CommandLineGrouping(ICommandLineArgument parentCallChain, ICommandLineArgument[] children, string description = null) : base(parentCallChain, children, description)
{
}
public static void PrintArgument(List<string> lines, ICommandLineArgument arg, string indent)
{
lines.Add(indent + "--" + arg.Name + " (" + arg.Typename + "): " + arg.ShortDescription);
if (arg.Deprecated)
lines.Add(indent + " " + Strings.CommandLineArgument.DeprecationMarker + ": " + arg.DeprecationMessage);
lines.Add(indent + " " + arg.LongDescription);
if (arg.Aliases != null && arg.Aliases.Length > 0)
lines.Add(indent + " * " + Strings.CommandLineArgument.AliasesHeader + ": --" + string.Join(", --", arg.Aliases));
if (arg.ValidValues != null && arg.ValidValues.Length > 0)
lines.Add(indent + " * " + Strings.CommandLineArgument.ValuesHeader + ": " + string.Join(", ", arg.ValidValues));
if (!string.IsNullOrEmpty(arg.DefaultValue))
lines.Add(indent + " * " + Strings.CommandLineArgument.DefaultValueHeader + ": " + arg.DefaultValue);
}
private void StartApplication(ApplicationDescription app, ICommandLineArgument[] args) {
splashScreen.Show("Loading " + app.Name);
Thread t = new Thread(delegate() {
bool stopped = false;
do {
try {
if (!abortRequested) {
pluginManager.Run(app, args);
}
stopped = true;
}
catch (Exception ex) {
stopped = false;
ThreadPool.QueueUserWorkItem(delegate(object exception) { ErrorHandling.ShowErrorDialog(this, (Exception)exception); }, ex);
Thread.Sleep(5000); // sleep 5 seconds before autorestart
}
} while (!abortRequested && !stopped && app.AutoRestart);
});
t.SetApartmentState(ApartmentState.STA); // needed for the AdvancedOptimizationFrontent
t.Start();
}
internal static CommandLineArgument ToCommandLineArgument(this ICommandLineArgument commandLineArgument)
{
return((CommandLineArgument)commandLineArgument);
}
public static void PrintArgument(List<string> lines, ICommandLineArgument arg)
{
PrintArgument(lines, arg, " ");
}
/// <summary>
/// Starts an application in a separate AppDomain.
/// Loads all enabled plugins and starts the application via an ApplicationManager instance activated in the new AppDomain.
/// </summary>
/// <param name="appInfo">application to run</param>
public void Run(ApplicationDescription appInfo, ICommandLineArgument[] args) {
if (!initialized) throw new InvalidOperationException("PluginManager is not initialized. DiscoverAndCheckPlugins() must be called before Run()");
// create a separate AppDomain for the application
// initialize the static ApplicationManager in the AppDomain
// and remotely tell it to start the application
OnApplicationStarting(new PluginInfrastructureEventArgs(appInfo));
AppDomain applicationDomain = null;
try {
AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;
setup.PrivateBinPath = pluginDir;
applicationDomain = AppDomain.CreateDomain(AppDomain.CurrentDomain.FriendlyName, null, setup);
Type applicationManagerType = typeof(DefaultApplicationManager);
DefaultApplicationManager applicationManager =
(DefaultApplicationManager)applicationDomain.CreateInstanceAndUnwrap(applicationManagerType.Assembly.FullName, applicationManagerType.FullName, true, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null, null);
applicationManager.PluginLoaded += applicationManager_PluginLoaded;
applicationManager.PluginUnloaded += applicationManager_PluginUnloaded;
applicationManager.PrepareApplicationDomain(applications, plugins);
OnApplicationStarted(new PluginInfrastructureEventArgs(appInfo));
applicationManager.Run(appInfo, args);
}
finally {
// make sure domain is unloaded in all cases
AppDomain.Unload(applicationDomain);
}
}
public static void PrintArgument(List <string> lines, ICommandLineArgument arg)
{
PrintArgument(lines, arg, " ");
}
/// <summary>
/// Creates new instance of <see cref="CommandLineGroupingBase"/>.
/// <para>
/// *See remarks for further details and correct implementation.
/// </para>
/// </summary>
/// <param name="parentCallChain">The parent call-chain.</param>
/// <param name="children">The associated children in relation to <paramref name="parentCallChain"/>.</param>
/// <param name="description">A description of what this grouping represents or does within the scope of the application.</param>
/// <exception cref="System.ArgumentNullException">
/// Throws when <paramref name="parentCallChain"/> is null or contains not elements.
/// </exception>
/// <remarks>
/// The <see cref="ICommandLineGrouping.ParentCallChain"/> property represents the full parent hierarchy chain.
///
/// The <see cref="ICommandLineGrouping.Children"/> property represents associated child pairings.
/// It is important to note this property is not an "all inclusive" listing", but rather an individual grouping.
/// This means that if you have one "main argument", which has three "child arguments", then specifying a grouping
/// with "main" and "childOne" would transpose to the command line as "$ main childOne".
///
/// If you wanted to specify a grouping that states "main" must run with "childOne" and "childTwo", but leave "childThree" as optional,
/// then you would create two groupings; one with "childOne" and "childTwo"; the other, with "childOne", "childTwo", and "childThree".
/// </remarks>
protected CommandLineGroupingBase(ICommandLineArgument parentCallChain, ICommandLineArgument[] children, string description = null)
: this(new ICommandLineArgument[] { parentCallChain }, children, description)
{
}
/// <summary>
/// Determines if the specified argument is present.
/// </summary>
/// <param name="rootArgument">The <see cref="ICommandLineArgument"/> to check.</param>
/// <param name="options">The flags which dictate what determines an argument as found.</param>
/// <param name="comparer">The comparer to use when determining if a match was found.</param>
/// <param name="argumentsToParse">
/// The collection to search.
/// Specifying null will default to <see cref="Arguments"/>.
/// </param>
/// <returns>
/// Returns true if the apecified argument was found using the supplied flags; otherwise, returns false.
/// </returns>
/// <exception cref="System.ArgumentException">
/// Throws when an invalid flag combination is given.
/// </exception>
public static bool Found(this ICommandLineArgument rootArgument, CmdLineSearchOptions options, StringComparison?comparer = null, IEnumerable <string> argumentsToParse = null)
{
if (options.HasFlag(CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithoutChildren))
{
throw new ArgumentException($"Invalid flag combination. {options}", nameof(options));
}
if (options.HasFlag(CmdLineSearchOptions.WithSiblings | CmdLineSearchOptions.WithoutSiblings))
{
throw new ArgumentException($"Invalid flag combination. {options}", nameof(options));
}
if (options.HasFlag(CmdLineSearchOptions.WithParams | CmdLineSearchOptions.WithoutParams))
{
throw new ArgumentException($"Invalid flag combination. {options}", nameof(options));
}
var segment = rootArgument.GetSegment(comparer, argumentsToParse);
if (options == CmdLineSearchOptions.None)
{
return(segment.Any());
}
if (!segment.Any())
{
return(false);
}
if (options == CmdLineSearchOptions.WithChildren)
{
return(segment.Count() > 1);
}
if (options == CmdLineSearchOptions.WithoutChildren)
{
return(segment.Count() == 1);
}
if (options == CmdLineSearchOptions.WithParams)
{
return(segment.Any() && rootArgument.GetParams().Any());
}
if (options == CmdLineSearchOptions.WithoutParams)
{
return(segment.Any() && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithParams))
{
return(segment.Count() > 1 && rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() > 1 && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithParams))
{
return(segment.Count() == 1 && rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() == 1 && !rootArgument.GetParams().Any());
}
var hasSiblings = (argumentsToParse ?? Arguments).Any(str =>
str.StartsWith(rootArgument.Specification.Delimiter) && !rootArgument.Command.Equals(str, (comparer ?? Comparer)));
if (options == CmdLineSearchOptions.WithSiblings)
{
return(segment.Any() && hasSiblings);
}
if (options == CmdLineSearchOptions.WithoutSiblings)
{
return(segment.Any() && !hasSiblings);
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithoutSiblings))
{
return(segment.Count() == 1 && !hasSiblings);
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithoutSiblings))
{
return(segment.Count() > 1 && !hasSiblings);
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithSiblings))
{
return(segment.Count() == 1 && hasSiblings);
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithSiblings))
{
return(segment.Count() > 1 && hasSiblings);
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithoutSiblings | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() == 1 && !hasSiblings && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithoutSiblings | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() > 1 && !hasSiblings && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithSiblings | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() == 1 && hasSiblings && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithSiblings | CmdLineSearchOptions.WithoutParams))
{
return(segment.Count() > 1 && hasSiblings && !rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithoutSiblings | CmdLineSearchOptions.WithParams))
{
return(segment.Count() == 1 && !hasSiblings && rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithoutSiblings | CmdLineSearchOptions.WithParams))
{
return(segment.Count() > 1 && !hasSiblings && rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithoutChildren | CmdLineSearchOptions.WithSiblings | CmdLineSearchOptions.WithParams))
{
return(segment.Count() == 1 && hasSiblings && rootArgument.GetParams().Any());
}
if (options == (CmdLineSearchOptions.WithChildren | CmdLineSearchOptions.WithSiblings | CmdLineSearchOptions.WithParams))
{
return(segment.Count() > 1 && hasSiblings && rootArgument.GetParams().Any());
}
throw new ArgumentException("Could not find a search match pattern using the supplied search options.", nameof(options));
}
/// <summary> /// Returns all parameters associated with the specified <see cref="ICommandLineArgument"/>. /// </summary> /// <param name="argument">The argument to retrieve the parameters of.</param> /// <param name="comparer">The comparer to use when determining if a match was found.</param> /// <param name="argumentsToParse"> /// The collection to search. /// Specifying null will default to <see cref="Arguments"/>. /// </param> /// <returns> /// Searches <paramref name="argumentsToParse"/> for <paramref name="argument"/>. /// Once found, proceeding values are returned until a value begins with a known <see cref="ICommandLineSpecification.Delimiter"/>. /// /// If <paramref name="argument"/> is not found, or no parameters are found, an empty collection is returned. /// </returns> public static IEnumerable <string> GetParams(this ICommandLineArgument argument, StringComparison?comparer = null, IEnumerable <string> argumentsToParse = null) => argument.GetSegment(comparer, argumentsToParse ?? Arguments) .Skip(1) .TakeWhile(arg => !CommandLineSetManager.KnownSpecifications.Any(ks => arg.StartsWith(ks.Delimiter)));
