static void Main(string[] args) { Console.WriteLine("Stitch Command Line Compiler {0}", Assembly.GetExecutingAssembly().GetName().Version.ToString()); Console.WriteLine("Copyright (C) 2011 Nathan Palmer"); Console.WriteLine("http://github.com/nathanpalmer/stitch-aspnet"); Console.WriteLine(); try { var options = new Options(); var configuration = new Settings(); options.Add("r=|root=", "Root path (default is working directory)", v => configuration.Root = v); options.Add("p=|paths=", "Comma delimited list of paths that should be compiled", v => configuration.Paths = v.Split(',')); options.Add("d=|dep=", "Comma delimited list of dependencies that should be included", v => configuration.Dependencies = v.Split(',')); options.Add("i=|identifier=", "Identifier to use for including other files (default is require)", v => configuration.Identifier = v); options.Add("c=|compilers=", "Comma delimited list of compilers to use (default is CoffeeScriptCompiler, JavaScriptCompiler)", v => configuration.Compilers = v.Split(',').Select(compiler => (ICompile) Activator.CreateInstance(Type.GetType("Stitch.Compilers." + compiler + ", Stitch.Core"))).ToArray()); if (args.Length == 0) { ShowHelp(options, "No arguments specified."); } else { var extra = options.Parse(args).ToArray(); if (extra.Length > 1) { Console.WriteLine("The following arguments did not parse.\r\n\r\n" + string.Join(",", extra)); } else if (extra.Length == 1) { var file = new FileInfo(extra[0]); if (file.Exists) { file.Delete(); } Console.WriteLine("Generating {0}", file.Name); var package = new Package( configuration.Root, configuration.Paths, configuration.Dependencies, configuration.Identifier ?? "require", configuration.Compilers); File.WriteAllText(file.FullName, package.Compile()); } else { ShowHelp(options, "You must specify a destination."); return; } } } catch (Exception ex) { Console.WriteLine("Fatal Exception: " + ex.ToString()); } }
public static Dictionary<int, Changelist> GetPendingChangelists() { var repo = GetRepository(); var options = new Options(); options.Add("-s", "pending"); options.Add("-u", AutoDetectP4Setting(P4Setting.P4USER)); options.Add("-l", ""); // full text description return repo.GetChangelists(options).ToDictionary(changelist => changelist.Id); }
public void AddValue() { var options = new Options(); options.Add("MyTest", "result"); Assert.AreEqual(1, options.Count); Assert.AreEqual("result", options["MyTest"]); }
public void ShouldAllowLookupOfAllAddedValuesForEachKey() { var lookup = new Options(); lookup.Add("A", "A1"); lookup.Add("B", "B1"); lookup.Add("A", "A2"); lookup.Add("A", "A3"); lookup.Count.ShouldEqual(2); lookup.Keys.ShouldEqual("A", "B"); lookup.Contains("A").ShouldBeTrue(); lookup.Contains("B").ShouldBeTrue(); lookup.Contains("C").ShouldBeFalse(); lookup["A"].ShouldEqual("A1", "A2", "A3"); lookup["B"].ShouldEqual("B1"); }
public CommandLineParser(params string[] args) { var queue = new Queue<string>(args); var assemblyPaths = new List<string>(); var options = new Options(); var errors = new List<string>(); while (queue.Any()) { var item = queue.Dequeue(); if (IsKey(item)) { if (!queue.Any() || IsKey(queue.Peek())) { errors.Add($"Option {item} is missing its required value."); break; } var key = KeyName(item); var value = queue.Dequeue(); options.Add(key, value); } else { assemblyPaths.Add(item); } } if (!errors.Any() && !assemblyPaths.Any()) errors.Add("Missing required test assembly path(s)."); foreach (var assemblyPath in assemblyPaths) { if (!File.Exists(assemblyPath)) errors.Add("Specified test assembly does not exist: " + assemblyPath); else if (!AssemblyDirectoryContainsFixie(assemblyPath)) errors.Add($"Specified assembly {assemblyPath} does not appear to be a test assembly. Ensure that it references Fixie.dll and try again."); } AssemblyPaths = assemblyPaths.ToArray(); Options = options; Errors = errors.ToArray(); }
public CommandLineParser(params string[] args) { var queue = new Queue<string>(args); var assemblyPaths = new List<string>(); var options = new Options(); var errors = new List<string>(); while (queue.Any()) { var item = queue.Dequeue(); if (IsKey(item)) { if (!queue.Any() || IsKey(queue.Peek())) { errors.Add($"Option {item} is missing its required value."); break; } var key = KeyName(item); var value = queue.Dequeue(); options.Add(key, value); } else { assemblyPaths.Add(item); } } if (!errors.Any() && !assemblyPaths.Any()) errors.Add("Missing required test assembly path(s)."); foreach (var assemblyPath in assemblyPaths) if (!File.Exists(assemblyPath)) errors.Add("Specified test assembly does not exist: " + assemblyPath); AssemblyPaths = assemblyPaths.ToArray(); Options = options; Errors = errors.ToArray(); }
public CommandLineParser(params string[] args) { var queue = new Queue<string>(args); var assemblyPaths = new List<string>(); var optionList = new Options(); var errors = new List<string>(); while (queue.Any()) { var item = queue.Dequeue(); if (IsKey(item)) { if (!queue.Any() || IsKey(queue.Peek())) { errors.Add(string.Format("Option {0} is missing its required value.", item)); break; } var key = KeyName(item); var value = queue.Dequeue(); optionList.Add(key, value); } else { assemblyPaths.Add(item); } } if (!errors.Any() && !assemblyPaths.Any()) errors.Add("Missing required test assembly path(s)."); AssemblyPaths = assemblyPaths.ToArray(); Options = optionList; Errors = errors.ToArray(); }
/// <summary> /// Submit all in the default changelist /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void submitAllToolStripMenuItem_Click(object sender, EventArgs e) { if (CheckConnect()) { using (Connection P4Connection = P4Repository.Connection) { try { //revert unchanged files. List<FileSpec> FileSpecsToRevert = new List<FileSpec>(); foreach (string File in FilesCheckedOut) { FileSpecsToRevert.Add(new FileSpec(new DepotPath(File), null, null, null)); } Options RevertOptions = new Options(); //Only files that are open for edit or integrate and are unchanged or missing RevertOptions.Add("-a", null); P4Connection.Client.RevertFiles(RevertOptions, FileSpecsToRevert.ToArray()); // Submit remaining changelist Options SubmitOptions = new Options(); //Add a description SubmitOptions.Add("-d", String.Format(Settings.Default.SubmitChangelistDescription, _connectionDetails.UserSavedStatePreferredLanguage)); SubmitResults UpdatesInsertsSubmitResults = P4Connection.Client.SubmitFiles(SubmitOptions, null); log.Info(String.Format("Updated and New files submitted in CL# {0}, Files affected:", UpdatesInsertsSubmitResults.ChangeIdAfterSubmit)); foreach (var SubmittedFile in UpdatesInsertsSubmitResults.Files) { log.Info(String.Format("\t{0}:\t{1}({2})", SubmittedFile.Action, SubmittedFile.File.DepotPath, SubmittedFile.File.Version)); } //Clear checked out files. FilesCheckedOut.Clear(); //Mark lines black text foreach (ListViewItem line in FileListView.Items) { line.ForeColor = Color.Black; } } catch (P4Exception ex) { //Swallow No files to submit error if (ex.ErrorCode != 806427698) { log.Error("Error in submitting changelist:"); log.Error(ex.Message); } } } } }
/// <inheritdoc/> public Central([NotNull] ICommandHandler handler) : base(handler) { Options.Add("m|machine", () => Resources.OptionMachine, _ => _machineWide = true); }
/// <summary> /// Get the FileSpec for a depot file given a changelist /// </summary> /// <param name="depotFileName">The file name in current depot location</param> /// <param name="changelist">The language file's changelist to be used to find an older version of the int file</param> /// <param name="checkForRenameMove">Check if the file has changed names due to a move/rename</param> /// <returns>FileSpec which may have a different depotfilename than that passed into function if the file has been moved since changelist</returns> private FileSpec GetIntFileSpecForFileChangelist(string depotFileName, int changelist, bool checkForRenameMove) { if (!CheckConnect()) { return null; } if (checkForRenameMove) { PathSpec HistoryPathSpec = new DepotPath(depotFileName) as PathSpec; FileSpec[] HistoryFiles = new FileSpec[1]; HistoryFiles[0] = new FileSpec(HistoryPathSpec, VersionSpec.Head); Options Opts = new Options(); Opts.Add("-i", ""); IList<FileHistory> History = P4Repository.GetFileHistory(Opts, HistoryFiles); // walk through history until we find the first changelist older than the specified changelist foreach (FileHistory Item in History) { if (Item.ChangelistId > changelist) { continue; } // use the depot filename at this revision HistoryPathSpec = Item.DepotPath; break; } return new FileSpec(HistoryPathSpec, new ChangelistIdVersion(changelist)); } else { return new FileSpec(new DepotPath(depotFileName) as PathSpec, new ChangelistIdVersion(changelist)); } }
public CommandSet Add(string prototype, string description, OptionAction <string, string> action, bool hidden) { Options.Add(prototype, description, action, hidden); return(this); }
public CommandSet Add <T>(string prototype, string description, Action <T> action) { Options.Add(prototype, description, action); return(this); }
public CommandSet Add(ArgumentSource source) { Options.Add(source); return(this); }
public bool Unpack(MemoryStream stream) { { TDSPreLoginOptionToken option; do { option = new TDSPreLoginOptionToken(); option.Unpack(stream); Options.Add(option); }while (option.Type != TDSPreLoginOptionTokenType.Terminator); } foreach (var option in Options) { switch (option.Type) { case TDSPreLoginOptionTokenType.Encryption: { Encryption = (TDSEncryptionOption)stream.ReadByte(); break; } case TDSPreLoginOptionTokenType.FedAuthRequired: { FedAuthRequired = stream.ReadByte() == 1; break; } case TDSPreLoginOptionTokenType.InstOpt: { throw new NotSupportedException(); } case TDSPreLoginOptionTokenType.MARS: { MARS = stream.ReadByte() == 1; break; } case TDSPreLoginOptionTokenType.NonceOpt: { Nonce = BigEndianUtilities.ReadByteArray(stream, 32); break; } case TDSPreLoginOptionTokenType.ThreadID: { ThreadID = BigEndianUtilities.ReadULong(stream); break; } case TDSPreLoginOptionTokenType.TraceID: { TraceID = new TDSClientTraceID(); TraceID.Unpack(stream); break; } case TDSPreLoginOptionTokenType.Version: { ClientVersion = new TDSClientVersion(); ClientVersion.Unpack(stream); break; } case TDSPreLoginOptionTokenType.Terminator: { break; } } } Terminated = true; return(true); }
public int Run(IEnumerable <string> arguments) { if (arguments == null) { throw new ArgumentNullException(nameof(arguments)); } showHelp = false; if (help == null) { help = new HelpCommand(); addCommand(help); } void setHelp(string v) => showHelp = v != null; if (!Options.Contains("help")) { Options.Add("help", "", setHelp, true); } if (!Options.Contains("?")) { Options.Add("?", "", setHelp, true); } List <string> extra = Options.Parse(arguments); if (!extra.Any()) { if (showHelp) { return(help.Invoke(extra)); } Out.WriteLine(Options.MessageLocalizer($"Use `{Suite} help` for usage.")); return(1); } Command command = GetCommand(extra); if (command == null) { help.WriteUnknownCommand(extra[0]); return(1); } if (showHelp) { if (command.Options?.Contains("help") ?? true) { extra.Add("--help"); return(command.Invoke(extra)); } command.Options.WriteOptionDescriptions(Out); return(0); } return(command.Invoke(extra)); }
public void AddOption(MenuOption option) { Options.Add(option); }
public GridScenario() : base("grid") { Options.Add(_gridTypeOption); }
static MySqlConnectionStringBuilder() { // Server options Options.Add(new MySqlConnectionStringOption("pipe", "pipe name,pipename", typeof(string), "MYSQL", false, (msb, sender, value) => { #if NETSTANDARD1_6 || NETSTANDARD2_0 || NETCOREAPP2_0 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(PipeName))); #else msb.SetValue("pipe", value); #endif }, (msb, sender) => msb.PipeName)); Options.Add(new MySqlConnectionStringOption("compress", "use compression,usecompression", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("compress", value); }, (msb, sender) => msb.UseCompression)); Options.Add(new MySqlConnectionStringOption("allowbatch", "allow batch", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("allowbatch", value); }, (msb, sender) => msb.AllowBatch)); Options.Add(new MySqlConnectionStringOption("logging", null, typeof(bool), false, false, (msb, sender, value) => { #if NETSTANDARD1_6 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(Logging))); #else msb.SetValue("logging", value); #endif }, (msb, sender) => msb.Logging)); Options.Add(new MySqlConnectionStringOption("sharedmemoryname", "shared memory name", typeof(string), "MYSQL", false, (msb, sender, value) => { #if NETSTANDARD1_6 || NETSTANDARD2_0 || NETCOREAPP2_0 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(SharedMemoryName))); #else msb.SetValue("sharedmemoryname", value); #endif }, (msb, sender) => msb.SharedMemoryName)); Options.Add(new MySqlConnectionStringOption("defaultcommandtimeout", "command timeout,default command timeout", typeof(uint), (uint)30, false, (msb, sender, value) => { msb.SetValue("defaultcommandtimeout", value); }, (msb, sender) => msb.DefaultCommandTimeout)); Options.Add(new MySqlConnectionStringOption("usedefaultcommandtimeoutforef", "use default command timeout for ef", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("usedefaultcommandtimeoutforef", value); }, (msb, sender) => msb.UseDefaultCommandTimeoutForEF)); Options.Add(new MySqlConnectionStringOption("connectiontimeout", "connection timeout,connect timeout", typeof(uint), (uint)15, false, delegate(MySqlConnectionStringBuilder msb, MySqlConnectionStringOption sender, object Value) { uint value = (uint)Convert.ChangeType(Value, sender.BaseType); // Timeout in milliseconds should not exceed maximum for 32 bit // signed integer (~24 days). We truncate the value if it exceeds // maximum (MySqlCommand.CommandTimeout uses the same technique uint timeout = Math.Min(value, Int32.MaxValue / 1000); if (timeout != value) { MySqlTrace.LogWarning(-1, "Connection timeout value too large (" + value + " seconds). Changed to max. possible value" + +timeout + " seconds)"); } msb.SetValue("connectiontimeout", timeout); }, (msb, sender) => (uint)msb.values["connectiontimeout"] )); Options.Add(new MySqlConnectionStringOption("allowloadlocalinfile", "allow load local infile", typeof(bool), false, false)); // Authentication options. Options.Add(new MySqlConnectionStringOption("persistsecurityinfo", "persist security info", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("persistsecurityinfo", value); }, (msb, sender) => msb.PersistSecurityInfo)); Options.Add(new MySqlConnectionStringOption("integratedsecurity", "integrated security", typeof(bool), false, false, delegate(MySqlConnectionStringBuilder msb, MySqlConnectionStringOption sender, object value) { if (!Platform.IsWindows()) { throw new MySqlException("IntegratedSecurity is supported on Windows only"); } #if NETSTANDARD1_6 || NETSTANDARD2_0 || NETCOREAPP2_0 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(IntegratedSecurity))); #else msb.SetValue("Integrated Security", value.ToString().Equals("SSPI", StringComparison.OrdinalIgnoreCase) ? true : value); #endif }, delegate(MySqlConnectionStringBuilder msb, MySqlConnectionStringOption sender) { object val = msb.values["integratedsecurity"]; return((bool)val); } )); Options.Add(new MySqlConnectionStringOption("allowpublickeyretrieval", null, typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("allowpublickeyretrieval", value); }, (msb, sender) => msb.AllowPublicKeyRetrieval)); // Other properties. #if !NETSTANDARD1_6 Options.Add(new MySqlConnectionStringOption("autoenlist", "auto enlist", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("autoenlist", value); }, (msb, sender) => msb.AutoEnlist)); Options.Add(new MySqlConnectionStringOption("includesecurityasserts", "include security asserts", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("includesecurityasserts", value); }, (msb, sender) => msb.IncludeSecurityAsserts)); #endif Options.Add(new MySqlConnectionStringOption("allowzerodatetime", "allow zero datetime", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("allowzerodatetime", value); }, (msb, sender) => msb.AllowZeroDateTime)); Options.Add(new MySqlConnectionStringOption("convertzerodatetime", "convert zero datetime", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("convertzerodatetime", value); }, (msb, sender) => msb.ConvertZeroDateTime)); Options.Add(new MySqlConnectionStringOption("useusageadvisor", "use usage advisor,usage advisor", typeof(bool), false, false, (msb, sender, value) => { #if NETSTANDARD1_6 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(UseUsageAdvisor))); #else msb.SetValue("useusageadvisor", value); #endif }, (msb, sender) => msb.UseUsageAdvisor)); Options.Add(new MySqlConnectionStringOption("procedurecachesize", "procedure cache size,procedure cache,procedurecache", typeof(uint), (uint)25, false, (msb, sender, value) => { msb.SetValue("procedurecachesize", value); }, (msb, sender) => msb.ProcedureCacheSize)); Options.Add(new MySqlConnectionStringOption("useperformancemonitor", "use performance monitor,useperfmon,perfmon", typeof(bool), false, false, (msb, sender, value) => { #if NETSTANDARD1_6 || NETSTANDARD2_0 || NETCOREAPP2_0 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(UsePerformanceMonitor))); #else msb.SetValue("useperformancemonitor", value); #endif }, (msb, sender) => msb.UsePerformanceMonitor)); Options.Add(new MySqlConnectionStringOption("ignoreprepare", "ignore prepare", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("ignoreprepare", value); }, (msb, sender) => msb.IgnorePrepare)); Options.Add(new MySqlConnectionStringOption("respectbinaryflags", "respect binary flags", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("respectbinaryflags", value); }, (msb, sender) => msb.RespectBinaryFlags)); Options.Add(new MySqlConnectionStringOption("treattinyasboolean", "treat tiny as boolean", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("treattinyasboolean", value); }, (msb, sender) => msb.TreatTinyAsBoolean)); Options.Add(new MySqlConnectionStringOption("allowuservariables", "allow user variables", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("allowuservariables", value); }, (msb, sender) => msb.AllowUserVariables)); Options.Add(new MySqlConnectionStringOption("interactivesession", "interactive session,interactive", typeof(bool), false, false, (msb, sender, value) => { #if NETSTANDARD1_6 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(InteractiveSession))); #else msb.SetValue("interactivesession", value); #endif }, (msb, sender) => msb.InteractiveSession)); Options.Add(new MySqlConnectionStringOption("functionsreturnstring", "functions return string", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("functionsreturnstring", value); }, (msb, sender) => msb.FunctionsReturnString)); Options.Add(new MySqlConnectionStringOption("useaffectedrows", "use affected rows", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("useaffectedrows", value); }, (msb, sender) => msb.UseAffectedRows)); Options.Add(new MySqlConnectionStringOption("oldguids", "old guids", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("oldguids", value); }, (msb, sender) => msb.OldGuids)); Options.Add(new MySqlConnectionStringOption("sqlservermode", "sql server mode", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("sqlservermode", value); }, (msb, sender) => msb.SqlServerMode)); Options.Add(new MySqlConnectionStringOption("tablecaching", "table cache,tablecache", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("tablecaching", value); }, (msb, sender) => msb.TableCaching)); Options.Add(new MySqlConnectionStringOption("defaulttablecacheage", "default table cache age", typeof(int), (int)60, false, (msb, sender, value) => { msb.SetValue("defaulttablecacheage", value); }, (msb, sender) => msb.DefaultTableCacheAge)); Options.Add(new MySqlConnectionStringOption("checkparameters", "check parameters", typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("checkparameters", value); }, (msb, sender) => msb.CheckParameters)); Options.Add(new MySqlConnectionStringOption("replication", null, typeof(bool), false, false, (msb, sender, value) => { #if NETSTANDARD1_6 throw new PlatformNotSupportedException(string.Format(Resources.OptionNotCurrentlySupported, nameof(Replication))); #else msb.SetValue("replication", value); #endif }, (msb, sender) => msb.Replication)); Options.Add(new MySqlConnectionStringOption("exceptioninterceptors", "exception interceptors", typeof(string), null, false, (msb, sender, value) => { msb.SetValue("exceptioninterceptors", value); }, (msb, sender) => msb.ExceptionInterceptors)); Options.Add(new MySqlConnectionStringOption("commandinterceptors", "command interceptors", typeof(string), null, false, (msb, sender, value) => { msb.SetValue("commandinterceptors", value); }, (msb, sender) => msb.CommandInterceptors)); // Pooling options. Options.Add(new MySqlConnectionStringOption("connectionlifetime", "connection lifetime", typeof(uint), (uint)0, false, (msb, sender, value) => { msb.SetValue("connectionlifetime", value); }, (msb, sender) => msb.ConnectionLifeTime)); Options.Add(new MySqlConnectionStringOption("pooling", null, typeof(bool), true, false, (msb, sender, value) => { msb.SetValue("pooling", value); }, (msb, sender) => msb.Pooling)); Options.Add(new MySqlConnectionStringOption("minpoolsize", "minimumpoolsize,min pool size,minimum pool size", typeof(uint), (uint)0, false, (msb, sender, value) => { msb.SetValue("minpoolsize", value); }, (msb, sender) => msb.MinimumPoolSize)); Options.Add(new MySqlConnectionStringOption("maxpoolsize", "maximumpoolsize,max pool size,maximum pool size", typeof(uint), (uint)100, false, (msb, sender, value) => { msb.SetValue("maxpoolsize", value); }, (msb, sender) => msb.MaximumPoolSize)); Options.Add(new MySqlConnectionStringOption("connectionreset", "connection reset", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("connectionreset", value); }, (msb, sender) => msb.ConnectionReset)); Options.Add(new MySqlConnectionStringOption("cacheserverproperties", "cache server properties", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("cacheserverproperties", value); }, (msb, sender) => msb.CacheServerProperties)); // Language and charset options. Options.Add(new MySqlConnectionStringOption("treatblobsasutf8", "treat blobs as utf8", typeof(bool), false, false, (msb, sender, value) => { msb.SetValue("treatblobsasutf8", value); }, (msb, sender) => msb.TreatBlobsAsUTF8)); Options.Add(new MySqlConnectionStringOption("blobasutf8includepattern", null, typeof(string), "", false, (msb, sender, value) => { msb.SetValue("blobasutf8includepattern", value); }, (msb, sender) => msb.BlobAsUTF8IncludePattern)); Options.Add(new MySqlConnectionStringOption("blobasutf8excludepattern", null, typeof(string), "", false, (msb, sender, value) => { msb.SetValue("blobasutf8excludepattern", value); }, (msb, sender) => msb.BlobAsUTF8ExcludePattern)); }
/// <inheritdoc/> public AddApp([NotNull] ICommandHandler handler) : base(handler) { Options.Add("no-download", () => Resources.OptionNoDownload, _ => NoDownload = true); }
/// <summary> /// Adds the element to the options collection. /// </summary> /// <param name="element">The group element to add.</param> /// <param name="before">The following element.</param> public void AddOption(IHtmlOptionsGroupElement element, IHtmlElement before = null) { Options.Add(element, before); }
public void AddOption(TDSPreLoginOptionTokenType type, Object data) { if (Terminated) { throw new InvalidOperationException(); } switch (type) { case TDSPreLoginOptionTokenType.Version: { if (data is TDSClientVersion && ClientVersion == null) { ClientVersion = (TDSClientVersion)data; LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()}."); } else { throw new ArgumentException(); } break; } case TDSPreLoginOptionTokenType.Encryption: { if (data is TDSEncryptionOption) { Encryption = (TDSEncryptionOption)data; LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()} [{Encryption.ToString()}]."); } else { throw new ArgumentException(); } break; } case TDSPreLoginOptionTokenType.FedAuthRequired | TDSPreLoginOptionTokenType.MARS: { if (data is bool) { if (type == TDSPreLoginOptionTokenType.FedAuthRequired) { FedAuthRequired = (bool)data; } else { MARS = (bool)data; } LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()} [{(bool)data}]."); } else { throw new ArgumentException(); } break; } case TDSPreLoginOptionTokenType.ThreadID: { if (data is ulong) { ThreadID = (ulong)data; LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()} [{ThreadID}]."); } else { throw new ArgumentException(); } break; } case TDSPreLoginOptionTokenType.TraceID: { if (data is TDSClientTraceID) { TraceID = (TDSClientTraceID)data; LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()}."); } else { throw new ArgumentException(); } break; } case TDSPreLoginOptionTokenType.NonceOpt: { if (data is byte[]) { Nonce = (byte[])data; LoggingUtilities.WriteLogVerboseOnly($" Adding PreLogin option {type.ToString()}."); } else { throw new ArgumentException(); } break; } default: { throw new NotSupportedException(); } } Options.Add(new TDSPreLoginOptionToken(type)); }
static int Main(string[] args) { try { var directories = new List <string>(); var files = new List <string>(); var programCommand = Command.None; Func <CompositionContractInfo, bool> contractPredicate = c => false; Func <CompositionInfo, PartDefinitionInfo, bool> partPredicate = (ci, p) => false; var verbose = false; var whitelist = new RejectionWhitelist(); var opts = new Options(); opts.Add <string>("dir", @"C:\MyApp\Parts", "Specify directories to search for parts.", d => directories.Add(d)); opts.Add <string>("file", "MyParts.dll", "Specify assemblies to search for parts.", f => files.Add(f)); opts.AddSwitch("verbose", "Print verbose information on each part.", () => verbose = true); var programCommandGroup = new ExclusiveGroup(); opts.Add <string>("type", "MyNamespace.MyType", "Print details of the given part type.", t => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p == ci.GetPartDefinitionInfo(t)); }, programCommandGroup); opts.Add <string>("importers", "MyContract", "List importers of the given contract.", i => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.ImportsContract(i)); }, programCommandGroup); opts.Add <string>("exporters", "MyContract", "List exporters of the given contract.", e => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.ExportsContract(e)); }, programCommandGroup); opts.AddSwitch("rejected", "List all rejected parts.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.IsRejected); }, programCommandGroup); opts.AddSwitch("causes", "List root causes - parts with errors not related to the rejection of other parts.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.IsPrimaryRejection); }, programCommandGroup); opts.Add <string>("whitelist", "RejectionWhitelist.txt", "Specify parts that may be validly rejected; requres the /rejected or /causes commands.", w => whitelist = new RejectionWhitelist(w)); opts.AddSwitch("parts", "List all parts found in the source assemblies.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => true); }, programCommandGroup); opts.AddSwitch("?", "Print usage.", () => programCommand = Command.PrintUsage, programCommandGroup); var contractsSubgroup = new InclusiveSubroup(programCommandGroup); opts.AddSwitch("imports", "Find imported contracts.", () => { programCommand = Command.PrintContracts; contractPredicate = AddToPredicate(contractPredicate, c => c.Importers.Any()); }, contractsSubgroup); opts.AddSwitch("exports", "Find exported contracts.", () => { programCommand = Command.PrintContracts; contractPredicate = AddToPredicate(contractPredicate, c => c.Exporters.Any()); }, contractsSubgroup); opts.Parse(args); return(Run(directories, files, programCommand, contractPredicate, partPredicate, verbose, whitelist, opts)); } catch (Exception ex) { Console.Write("Error: "); Console.WriteLine(ex.Message); return(1); } }
private void SaveAsset(Option option) { Options.Add(option); SaveChanges(); }
public CommandSet Add <TKey, TValue>(string prototype, string description, OptionAction <TKey, TValue> action) { Options.Add(prototype, description, action); return(this); }
public CommandSet Add(Option option) { Options.Add(option); return(this); }
public ImportCertificateCommand() { Options.Add("variables=", "Path to a JSON file containing variables.", v => variablesFile = Path.GetFullPath(v)); Options.Add("sensitiveVariables=", "Password protected JSON file containing sensitive-variables.", v => sensitiveVariablesFile = v); Options.Add("sensitiveVariablesPassword="******"Password used to decrypt sensitive-variables.", v => sensitiveVariablesPassword = v); }
public ClusterCommand() : base(names, help, helpHeaders) { Options.Add("write-all-fields", "Writes all the fields.", s => writeAllFields = s != null); }
/// <inheritdoc/> public UpdateApps([NotNull] ICommandHandler handler) : base(handler) { Options.Add("c|clean", () => Resources.OptionClean, _ => _clean = true); }
public Select <T> Add(SelectOption <T> option) { Options.Add(option); return(this); }
public CommandSet Add(string header) { Options.Add(header); return(this); }
public void Add(TextViewGroupOption option) => Options.Add(option);
public CommandSet Add(string prototype, OptionAction <string, string> action) { Options.Add(prototype, action); return(this); }
/// <summary> /// Query the server for multiple changelists in a range specified by the query parameter /// </summary> /// <param name="InQuery">Changelist query representing a start and end changelist number to query the Perforce server for changelists between</param> /// <return>Returns a list of changelists</return> public IList<Changelist> QueryChangelists(P4ChangelistSpanQuery InQuery) { IList<Changelist> ChangelistRecordSet = null; // Only attempt to query if actually connected if (ConnectionStatus == EP4ConnectionStatus.P4CS_Connected) { try { Options options = new Options(); //Extended descriptions options.Add("-l",null); //Only submitted changelists options.Add("-s", "submitted"); //Filter by user if (!string.IsNullOrWhiteSpace(InQuery.FilterUser)) { options.Add("-u", InQuery.FilterUser); } ChangelistRecordSet = mP4Repository.GetChangelists(options, InQuery.FileFilter); } catch (P4Exception E) { Console.WriteLine("Error running Perforce command!\n{0}", E.Message); } } return ChangelistRecordSet; }
public CommandSet Add <T>(string prototype, Action <T> action) { Options.Add(prototype, null, action); return(this); }
/// <summary> /// Gets list of workspaces for a given server and user</summary> /// <param name="serverAddress">Server address</param> /// <param name="userId">User ID</param> /// <returns>List of workspaces</returns> public IEnumerable<string> GetWorkspaces(string serverAddress, string userId) { var result = new List<string>(); try { var server = new Server(new ServerAddress(serverAddress)); var repository = new Repository(server); // This call ensures internal P4Server is set for repository.Connection, // otherwise GetUsers() call will fail. repository.Connection.Connect(ConnectionOptions); if (CheckLogin(repository.Connection)) { var opts = new Options(); opts.Add("-u", userId); //The -u user flag lists client workspaces that are owned by the specified user. foreach (var client in repository.GetClients(opts)) result.Add(client.Name); } } catch (P4Exception ex) { switch (ex.ErrorLevel) { case ErrorSeverity.E_WARN: Outputs.WriteLine(OutputMessageType.Warning, ex.Message); break; case ErrorSeverity.E_FAILED: Outputs.WriteLine(OutputMessageType.Error, ex.Message); break; case ErrorSeverity.E_INFO: Outputs.WriteLine(OutputMessageType.Info, ex.Message); break; } if (ThrowExceptions) throw; } return result; }
public void AddOption(String pOption) { Options.Add(new PollOption(pOption.ToLower())); }
public override IEnumerable<string> SelectFeatures(Prediction prediction) { _libLinear.LoadClassificationModelFiles(); string logPath = Path.Combine(Model.ModelDirectory, "feature_selection_log.txt"); System.IO.File.Delete(logPath); int nullClass = -1; foreach (string unmappedLabel in _libLinear.Labels) if (unmappedLabel == PointPrediction.NullLabel) if (nullClass == -1) nullClass = int.Parse(_libLinear.GetMappedLabel(unmappedLabel)); else throw new Exception("Multiple null classes in label map"); if (nullClass == -1) throw new Exception("Failed to find null class"); string featureSelectionTrainingPath = Path.GetTempFileName(); using (FileStream compressedTrainingInstancesFile = new FileStream(CompressedTrainingInstancesPath, FileMode.Open, FileAccess.Read)) using (GZipStream compressedTrainingInstancesGzip = new GZipStream(compressedTrainingInstancesFile, CompressionMode.Decompress)) using (StreamReader trainingInstancesFile = new StreamReader(compressedTrainingInstancesGzip)) using (FileStream compressedTrainingInstanceLocationsFile = new FileStream(CompressedTrainingInstanceLocationsPath, FileMode.Open, FileAccess.Read)) using (GZipStream compressedTrainingInstanceLocationsGzip = new GZipStream(compressedTrainingInstanceLocationsFile, CompressionMode.Decompress)) using (StreamReader trainingInstanceLocationsFile = new StreamReader(compressedTrainingInstanceLocationsGzip)) using (StreamWriter featureSelectionTrainingFile = new StreamWriter(featureSelectionTrainingPath)) { try { string instance; while ((instance = trainingInstancesFile.ReadLine()) != null) { string location = trainingInstanceLocationsFile.ReadLine(); if (location == null) throw new Exception("Missing location for training instance"); featureSelectionTrainingFile.WriteLine(instance + " # " + location); } if ((instance = trainingInstanceLocationsFile.ReadToEnd()) != null && (instance = instance.Trim()) != "") throw new Exception("Extra training instance locations: " + instance); trainingInstancesFile.Close(); trainingInstanceLocationsFile.Close(); featureSelectionTrainingFile.Close(); } catch (Exception ex) { throw new Exception("Failed to read training instances: " + ex.Message); } } string groupNamePath = Path.GetTempFileName(); Dictionary<string, string> groupNameFeatureId = new Dictionary<string, string>(); using (StreamWriter groupNameFile = new StreamWriter(groupNamePath)) { foreach (PTL.ATT.Models.Feature feature in Model.Features) { int featureNumber; if (_libLinear.TryGetFeatureNumber(feature.Id, out featureNumber)) { string groupName = feature.ToString().ReplacePunctuation(" ").RemoveRepeatedWhitespace().Replace(' ', '_').Trim('_'); groupNameFile.WriteLine(featureNumber + " " + groupName); groupNameFeatureId.Add(groupName, feature.Id); } } groupNameFile.Close(); } Options featureSelectionOptions = new Options(); featureSelectionOptions.Add(FeatureSelector.Option.ExitOnErrorAction, FeatureSelector.ExitOnErrorAction.ThrowException.ToString()); featureSelectionOptions.Add(FeatureSelector.Option.FeatureFilters, typeof(ZeroVectorFeatureFilter).FullName + "," + typeof(CosineSimilarityFeatureFilter).FullName); featureSelectionOptions.Add(FeatureSelector.Option.FloatingSelection, false.ToString()); featureSelectionOptions.Add(FeatureSelector.Option.GroupNamePath, groupNamePath); featureSelectionOptions.Add(FeatureSelector.Option.LogPath, logPath); featureSelectionOptions.Add(FeatureSelector.Option.MaxThreads, Configuration.ProcessorCount.ToString()); featureSelectionOptions.Add(FeatureSelector.Option.PerformanceIncreaseRequirement, float.Epsilon.ToString()); featureSelectionOptions.Add(FeatureSelector.Option.Scorer, typeof(SurveillancePlotScorer).FullName); featureSelectionOptions.Add(FeatureSelector.Option.TrainingInstancesInMemory, true.ToString()); featureSelectionOptions.Add(FeatureSelector.Option.TrainingInstancesPath, featureSelectionTrainingPath); featureSelectionOptions.Add(FeatureSelector.Option.Verbosity, FeatureSelector.Verbosity.Debug.ToString()); featureSelectionOptions.Add(SurveillancePlotScorer.Option.IgnoredSurveillanceClasses, nullClass.ToString()); featureSelectionOptions.Add(CommonWrapper.Option.ClassifyExePath, Configuration.ClassifierTypeOptions[GetType()]["predict"]); featureSelectionOptions.Add(CommonWrapper.Option.TrainExePath, Configuration.ClassifierTypeOptions[GetType()]["train"]); featureSelectionOptions.Add(LibLinearWrapper.Option.IgnoredProbabilisticClasses, nullClass.ToString()); featureSelectionOptions.Add(LibLinearWrapper.Option.SumInstanceProbabilities, true.ToString()); featureSelectionOptions.Add(CrossFoldValidator.Option.RandomizeInstanceBlocks, true.ToString()); featureSelectionOptions.Add(CrossFoldValidator.Option.InstanceBlockRandomizationSeed, (498734983).ToString()); featureSelectionOptions.Add(CrossFoldValidator.Option.NumFolds, (2).ToString()); featureSelectionOptions.Add(CosineSimilarityFeatureFilter.Option.Threshold, (0.98).ToString()); if (_positiveClassWeighting == PositiveClassWeighting.NegativePositiveRatio) { using (FileStream compressedTrainingInstancesFile = new FileStream(CompressedTrainingInstancesPath, FileMode.Open, FileAccess.Read)) using (GZipStream compressedTrainingInstancesGzip = new GZipStream(compressedTrainingInstancesFile, CompressionMode.Decompress)) using (StreamReader compressedTrainingInstancesReader = new StreamReader(compressedTrainingInstancesGzip)) { Dictionary<int, float> classWeight = GetPerClassWeights(compressedTrainingInstancesReader); foreach (int classNum in classWeight.Keys) featureSelectionOptions.Add((LibLinearWrapper.Option)Enum.Parse(typeof(LibLinearWrapper.Option), "W" + classNum), classWeight[classNum].ToString()); } } else if (_positiveClassWeighting != PositiveClassWeighting.None) throw new Exception("Unrecognized positive class weighting scheme: " + _positiveClassWeighting); FeatureSelector.Run(_libLinear, featureSelectionOptions); float score; Dictionary<string, Tuple<int, float>> featureRankContribution; FeatureSelector.GetResults(logPath, out score, out featureRankContribution); System.IO.File.Delete(featureSelectionTrainingPath); System.IO.File.Delete(groupNamePath); return featureRankContribution.Keys.Select(groupName => groupNameFeatureId[groupName]); }
/// <summary> /// Query the server for a single changelist specified by the query parameter /// </summary> /// <param name="ChangelistNumber">The changelist number to query for</param> /// <returns>P4Changelist object representing the queried changelist, if it exists; otherwise, P4Changelist.InvalidChangelist</returns> public Changelist QueryChangelist(int ChangelistNumber) { Changelist ChangelistRecordSet = null; // Can only query if currently connected to the server! if (ConnectionStatus == EP4ConnectionStatus.P4CS_Connected) { try { //do not include file diffs in this operation. Options options = new Options(); options.Add("-s",""); // Attempt to run a describe query on the changelist specified by the InQuery ChangelistRecordSet = mP4Repository.GetChangelist(ChangelistNumber, options); } catch (P4Exception E) { Console.WriteLine("Error running Perforce command!\n{0}", E.Message); } } return ChangelistRecordSet; }
public void Add(HexViewGroupOption option) => Options.Add(option);
public CommandLineParser(params string[] args) { var queue = new Queue<string>(args); var assemblyPaths = new List<string>(); var optionList = new Options(); var errors = new List<string>(); while (queue.Any()) { var item = queue.Dequeue(); if (IsKey(item)) { var key = KeyName(item); key = CorrectlyCasedKey(key); if (key == null) { errors.Add(string.Format("Option {0} is not recognized.", item)); break; } if (!queue.Any() || IsKey(queue.Peek())) { errors.Add(string.Format("Option {0} is missing its required value.", item)); break; } var value = queue.Dequeue(); if (key == CommandLineOption.Parameter) { if (value.Contains("=")) { var equalSignIndex = value.IndexOf('='); if (equalSignIndex == 0) { errors.Add(string.Format("Custom parameter {0} is missing its required key.", value)); break; } key = value.Substring(0, equalSignIndex); value = value.Substring(equalSignIndex + 1); } else { key = value; value = "on"; } } optionList.Add(key, value); } else { assemblyPaths.Add(item); } } if (!errors.Any() && !assemblyPaths.Any()) errors.Add("Missing required test assembly path(s)."); AssemblyPaths = assemblyPaths.ToArray(); Options = optionList; Errors = errors.ToArray(); }
public void analyzeCommands() { string currentFlag = ""; bool processingFiles = false; foreach (string word in words) { if (word.StartsWith("/") || word.StartsWith("-")) { if (word.Contains(flag_dll) || word.Contains(flag_dll.ToUpper())) { isDll = true; } else if (word.Contains(flag_exe) || word.Contains(flag_exe.ToUpper())) { isExe = true; } else if (word.Contains(flag_out) || word.Contains(flag_out.ToUpper())) { Output = word.Substring(flag_out.Length + 1); Options.Add(new KeyValuePair <string, string>(flag_out, Output)); currentFlag = flag_out; } else if (word.Contains(flag_def) || word.Contains(flag_def.ToUpper())) { Def = word.Substring(flag_def.Length + 1); Options.Add(new KeyValuePair <string, string>(flag_def, Def)); currentFlag = flag_def; } else if (word.Contains(flag_entry) || word.Contains(flag_entry.ToUpper())) { Entry = word.Substring(flag_entry.Length + 1); Options.Add(new KeyValuePair <string, string>(flag_entry, Entry)); currentFlag = flag_entry; } else { Options.Add(new KeyValuePair <string, string>(word, Entry)); } } else if (word.Contains(".obj")) { Objs.Add(word); processingFiles = true; } else if (word.Contains(".lib")) { Libs.Add(word); processingFiles = true; } else if (word.Contains(".res")) { } else if (currentFlag != "") { } else { //Unrecognized command } if (word.ToLower().Equals("link") || word.ToLower().Equals("link.exe")) { } else if (!processingFiles) { if (!word.Equals("")) { LinkOptionsLiteral += word + " "; LinkOptionsLiteral_Words.Add(word); } } } LinkOptionsLiteral = LinkOptionsLiteral.Trim(); }
static int Main(string[] args) { try { var directories = new List<string>(); var files = new List<string>(); var programCommand = Command.None; Func<CompositionContractInfo, bool> contractPredicate = c => false; Func<CompositionInfo, PartDefinitionInfo, bool> partPredicate = (ci, p) => false; var verbose = false; var whitelist = new RejectionWhitelist(); var opts = new Options(); opts.Add<string>("dir", @"C:\MyApp\Parts", "Specify directories to search for parts.", d => directories.Add(d)); opts.Add<string>("file", "MyParts.dll", "Specify assemblies to search for parts.", f => files.Add(f)); opts.AddSwitch("verbose", "Print verbose information on each part.", () => verbose = true); var programCommandGroup = new ExclusiveGroup(); opts.Add<string>("type", "MyNamespace.MyType", "Print details of the given part type.", t => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p == ci.GetPartDefinitionInfo(t)); }, programCommandGroup); opts.Add<string>("importers", "MyContract", "List importers of the given contract.", i => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.ImportsContract(i)); }, programCommandGroup); opts.Add<string>("exporters", "MyContract", "List exporters of the given contract.", e => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.ExportsContract(e)); }, programCommandGroup); opts.AddSwitch("rejected", "List all rejected parts.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.IsRejected); }, programCommandGroup); opts.AddSwitch("causes", "List root causes - parts with errors not related to the rejection of other parts.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => p.IsPrimaryRejection); }, programCommandGroup); opts.Add<string>("whitelist", "RejectionWhitelist.txt", "Specify parts that may be validly rejected; requres the /rejected or /causes commands.", w => whitelist = new RejectionWhitelist(w)); opts.AddSwitch("parts", "List all parts found in the source assemblies.", () => { programCommand = Command.PrintParts; partPredicate = AddToPredicate(partPredicate, (ci, p) => true); }, programCommandGroup); opts.AddSwitch("?", "Print usage.", () => programCommand = Command.PrintUsage, programCommandGroup); var contractsSubgroup = new InclusiveSubroup(programCommandGroup); opts.AddSwitch("imports", "Find imported contracts.", () => { programCommand = Command.PrintContracts; contractPredicate = AddToPredicate(contractPredicate, c => c.Importers.Any()); }, contractsSubgroup); opts.AddSwitch("exports", "Find exported contracts.", () => { programCommand = Command.PrintContracts; contractPredicate = AddToPredicate(contractPredicate, c => c.Exporters.Any()); }, contractsSubgroup); opts.Parse(args); return Run(directories, files, programCommand, contractPredicate, partPredicate, verbose, whitelist, opts); } catch (Exception ex) { Console.Write("Error: "); Console.WriteLine(ex.Message); return 1; } }
public NoteResult(Note note) : base(note.Content) { Subtitle = $"Created at {note.CreatedAt.ToShortDateString()}"; Options.Add(new DeleteNoteOptionResult(note)); }
/// <summary> /// Perform actions which can be automated, such as moving and deleting files. /// </summary> private void PerformDefaultActions() { if (CheckConnect()) { using (Connection P4Connection = P4Repository.Connection) { AddDeleteFilesToDefaultChangeList(P4Connection); AddMoveFilesToDefaultChangeList(P4Connection); //if there are files to move or delete submit them otherwise delete the changelist try { Options SubmitOptions = new Options(); //Add a description SubmitOptions.Add("-d", String.Format(Settings.Default.MoveDeleteChangelistDescription, _connectionDetails.UserSavedStatePreferredLanguage)); SubmitResults DeleteMoveSubmitResults = P4Connection.Client.SubmitFiles(SubmitOptions, null); log.Info(String.Format("Delete and move files submitted in CL# {0}, Files affected:", DeleteMoveSubmitResults.ChangeIdAfterSubmit)); foreach (var SubmittedFile in DeleteMoveSubmitResults.Files) { log.Info(String.Format("\t{0}:\t{1}({2})", SubmittedFile.Action, SubmittedFile.File.DepotPath, SubmittedFile.File.Version)); } } catch (P4Exception ex) { //Swallow No files to submit error if (ex.ErrorCode != 806427698) { log.Error("Error in submitting move delete changelist:"); log.Error(ex.Message); } } } } }
public void AddMenuItem(MenuItem menuItem) { Options.Add(menuItem); }
private void BuildChangeListsDescriptionMapping() { //Build filespec list of all files to get changelists for List<FileSpec> ListOfFiles = new List<FileSpec>(); foreach (var LangFile in LangFileToCreateProcessingList) { ListOfFiles.Add(new FileSpec(new DepotPath(LangFile.DepotFile), null, null, VersionSpec.Head)); } foreach (var LangFile in LangFileToUpdateProcessingList) { ListOfFiles.Add(new FileSpec(new DepotPath(LangFile.DepotFile), null, null, VersionSpec.Head)); } foreach (var LangFile in LangFileTranslatedProcessingList) { ListOfFiles.Add(new FileSpec(new DepotPath(LangFile.DepotFile), null, null, VersionSpec.Head)); } if (CheckConnect()) { Options options = new Options(); //Extended descriptions options.Add("-l", null); IList<Changelist> Changelists = P4Repository.GetChangelists(options, ListOfFiles.ToArray()); foreach (Changelist ChangelistDetails in Changelists) { if (!ChangelistIdDescriptionMapping.ContainsKey(ChangelistDetails.Id)) { ChangelistIdDescriptionMapping.Add(ChangelistDetails.Id, new ChangelistDescription(ChangelistDetails.Description)); } } } }
public void AddMenuItem(Func <Menu> func) { Refresher = func; Options.Add(func()); }