public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; string VariableStart = ""; if ( Arguments.Length > 1 ) { VariableStart = ( (string) Arguments[1].GetArgument() ).ToLower(); } IDictionary EnvironmentVariables = Environment.GetEnvironmentVariables(); SortedList AlphaList = new SortedList( EnvironmentVariables ); foreach ( DictionaryEntry Entry in AlphaList ) { string VariableName = (string) Entry.Key; VariableName = VariableName.ToLower(); if ( VariableName.StartsWith( VariableStart ) ) { string VariableValue = (string) Entry.Value; TermUtil.WriteText( _Terminal, VariableName + "=" + VariableValue + Environment.NewLine ); } } return 0; }
private void RunHelp(ICommandArgument arg = null) { this.Context.Information("\n"); if (arg != null) { this.Context.Information(arg.Description); } else { var desc = this.ScriptDescription + "\n"; desc += "Typical Usage:\n"; desc += " Windows:\n"; desc += " build.ps1 <--longAction | -shortAction>=<action option>\n"; desc += " Linux:\n"; desc += " build.sh <--longAction | -shortAction>=<action option>\n"; desc += "\n"; desc += "Available Actions:\n"; foreach (var a in this.Arguments) { desc += $" --{a.Name}|-{a.Shortname}\n"; } desc += "\n"; desc += this.HelpArgument.Description; this.Context.Information(desc); } this.Context.Information("\n"); }
public static RemoteCommand FormatAddCommand(string name, string url, string master, string[] branches, bool mirror, bool fetch, bool tags) { var args = new ICommandArgument[1+2+(master!=null?1:0)+(branches!=null?branches.Length:0)+(mirror?1:0)+(fetch?(tags?2:1):0)]; int id = 0; args[id++] = Add(); if(branches != null && branches.Length != 0) { foreach(var b in branches) { args[id++] = TrackBranch(b); } } if(!string.IsNullOrEmpty(master)) { args[id++] = Master(master); } if(fetch) { args[id++] = Fetch(); if(tags) args[id++] = Tags(); } if(mirror) { args[id++] = Mirror(); } args[id++] = new CommandParameter(name); args[id++] = new CommandParameter(url); return new RemoteCommand(args); }
public static RemoteCommand FormatAddCommand(string name, string url, string master, string[] branches, bool mirror, bool fetch, bool tags) { var args = new ICommandArgument[1 + 2 + (master != null?1:0) + (branches != null?branches.Length:0) + (mirror?1:0) + (fetch?(tags?2:1):0)]; int id = 0; args[id++] = Add(); if (branches != null && branches.Length != 0) { foreach (var b in branches) { args[id++] = TrackBranch(b); } } if (!string.IsNullOrEmpty(master)) { args[id++] = Master(master); } if (fetch) { args[id++] = Fetch(); if (tags) { args[id++] = Tags(); } } if (mirror) { args[id++] = Mirror(); } args[id++] = new CommandParameter(name); args[id++] = new CommandParameter(url); return(new RemoteCommand(args)); }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { if ( Arguments.Length < 2 ) { throw new CommandException(); } System.Uri targetUri = new System.Uri( (string) Arguments[1].GetArgument() ); _Terminal.WriteTo( new StringBuilder( "Creating request\n" ), OutputType.StandardOutput ); WebRequest searchRequest = WebRequest.Create( targetUri ); _Terminal.WriteTo( new StringBuilder( "Getting request\n" ), OutputType.StandardOutput ); WebResponse searchResult = searchRequest.GetResponse(); Stream searchStream = searchResult.GetResponseStream(); ICommandArgument[] showArguments = new ICommandArgument[2]; showArguments[0] = Arguments[0]; showArguments[1] = new FileInputArgument( searchStream ); ShowpageCommand showCommand = new ShowpageCommand( _CommandProcessor, _Terminal ); return showCommand.PerformCommand( showArguments, out CommandResult ); }
internal Command(CommandType commandType, ICommandArgument argument, Guid?tempId) { CommandType = commandType; Argument = argument; TempId = tempId; Uid = Guid.NewGuid(); }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; if ( Arguments.Length < 2 ) { throw new CommandException(); } Stream sourceStream = null; if ( Arguments[1].GetArgument() is string ) { sourceStream = (Stream) new FileStream( (string) Arguments[1].GetArgument(), FileMode.Open, FileAccess.Read ); } else { sourceStream = (Stream) Arguments[1].GetArgument(); } string resultString = GetHtml( sourceStream ); _Terminal.WriteTo( new StringBuilder( resultString ), ConsoleProcessRedirection.OutputType.StandardOutput ); TextCommandResult result = new TextCommandResult( new StringBuilder( resultString ) ); CommandResult = result; return 0; }
public void ApplyArguments(TCommand command, string[] args) { for (int i = 0; i < _commandArgs.Length; i++) { ICommandArgument <TCommand> arg = _commandArgs[i]; arg.ModifyCommand(command, enabled: args.Any(c => arg.IsValidArgString(c))); } }
public void AddArgument(ICommandArgument argument) { if (_args == null) { _args = new List <ICommandArgument>(); } _args.Add(argument); }
public void AddOption(ICommandArgument option) { if (_options == null) { _options = new List <ICommandArgument>(); } _options.Add(option); }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; _CommandProcessor.Close(); return 0; }
public override int PerformCommand( ICommandArgument [] Arguments, out ICommandResult CommandResult ) { CommandResult = null; if ( Arguments.Length > 1 ) { Directory.SetCurrentDirectory( (string) Arguments[1].GetArgument() ); } return 0; }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; System.UriBuilder searchBinding = new System.UriBuilder(); searchBinding.Scheme = "http"; searchBinding.Host = searchServer; searchBinding.Path = searchRoot; string searchQuery = searchQueryPrefix; for ( int currentArgument = 1; currentArgument < Arguments.Length; currentArgument++ ) { if ( currentArgument > 1 ) { searchQuery += "%20"; } searchQuery += Arguments[currentArgument].GetArgument(); } searchBinding.Query = searchQuery; _Terminal.WriteTo( new StringBuilder( searchBinding.ToString() + "\n\n" ), ConsoleProcessRedirection.OutputType.StandardOutput ); PageCommand pageRetriever = new PageCommand( _CommandProcessor, new NullTerminal() ); ICommandArgument[] showArguments = new ICommandArgument[2]; showArguments[0] = Arguments[0]; showArguments[1] = new CommandArgument( searchBinding.ToString() ); pageRetriever.PerformCommand( showArguments, out CommandResult ); string resultString = ( (StringBuilder) CommandResult.GetArgument() ).ToString(); string[] links = FindLinks( resultString ); foreach ( string link in links ) { _Terminal.WriteTo( new StringBuilder( link + "\n\n" ), ConsoleProcessRedirection.OutputType.StandardOutput ); } return 0; }
public IBackloadStorageProviderFile Add(ICommandArgument args) { var f = this.Files.Add(new File(args.FileContext)); if (args.SaveChanges) { this.SaveChanges(); } return(f); }
private ArgumentValues ConstructDefaultArgument(ICommandArgument argument, bool isImplicit = false) { var argumentName = argument.ShortName == '\0' ? Settings.PrefixShort + argument.ShortName : Settings.PrefixLong + argument.Name; return(argument.ValueType.IsArray ? new ArgumentValues( argumentName, (argument.DefaultValue as IEnumerable)?.Cast <object>(), isImplicit: isImplicit ) : new ArgumentValues(argumentName, isImplicit: isImplicit, values: argument.DefaultValue)); }
/// <summary> /// Tries to find a player, if found then <paramref name="callback"/> will be called /// </summary> /// <param name="cmdArg"></param> /// <param name="callback"></param> public static bool TryGet(ICommandArgument cmdArg, Action <UPlayer> callback) { var player = From(cmdArg.ToString()); if (player != null) { callback(player); return(true); } return(false); }
public static bool TryConvertToByte(this ICommandArgument src, out byte?value, out CommandResult error) { byte result; if (src.TryConvertToByte(out result, out error)) { value = result; return(true); } value = null; return(false); }
public CommandArgs(string[] rawArgs) { RawArguments = rawArgs; var arguments = new ICommandArgument[Length]; for (var i = 0; i < RawArguments.Length; i++) { arguments[i] = new CommandArgument(i, RawArguments[i]); } Arguments = arguments; }
public bool TryGetArgument(string optionLabel, out ICommandArgument result) { if (this.argumentsAsDictionary.TryGetValue(optionLabel, out var found)) { result = new CommandArgument(this.Command, optionLabel, found); return(true); } else { result = default; return(false); } }
/// <summary> /// Try to convert the argument to byte. /// </summary> /// <param name="value">the converted value</param> /// <param name="error"> /// CommandResult.LangError("NUMBER_BETWEEN", byte.MinValue, byte.MaxValue) if out of range; // CommandResult.LangError("INVALID_NUMBER", src.ToString()) if invalid. /// </param> /// <returns>true if sucessfull, otherwise false</returns> public static bool TryConvertToByte(this ICommandArgument src, out byte value, out CommandResult error) { value = 0; error = null; try { value = byte.Parse(src.ToString()); return(true); } catch (OverflowException) { error = CommandResult.LangError("NUMBER_BETWEEN", byte.MinValue, byte.MaxValue); } catch (FormatException) { error = CommandResult.LangError("INVALID_NUMBER", src.ToString()); } return(false); }
public IBackloadStorageProviderFile Remove(ICommandArgument args) { var file = this.Files.Find(args.FileId); if (file != null) { this.Files.Remove(file); if (args.SaveChanges) { this.SaveChanges(); } } return(file); }
public static BranchCommand FormatCreateBranchCommand(string name, string startingRevision, bool specifyTracking, bool track, bool reflog) { var args = new ICommandArgument[2 + (specifyTracking?1:0) + (reflog?1:0)]; int id = 0; if (specifyTracking) { args[id++] = track ? Track() : NoTrack(); } if (reflog) { args[id++] = RefLog(); } args[id + 0] = new CommandParameter(name); args[id + 1] = new CommandParameter(startingRevision); return(new BranchCommand(args)); }
/// <summary> /// Gets if argument defined in Cake commandline /// </summary> /// <param name="arg">Command Argument</param> /// <param name="context">Cake Context</param> /// <returns>True if it exists, false otherwise</returns> /// <example> /// <code> /// var newArg = CommandHelper.AddArgument("test", "t", "Testing stuff"); /// var hasArg = newArg.HasArgument(Context) /// </code> /// </example> public static bool HasArgument(this ICommandArgument arg, ICakeContext context) { if (arg == null) { throw new ArgumentNullException(nameof(arg)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } var hasArg = context.HasArgument(arg.Name); hasArg |= context.HasArgument(arg.Shortname); return(hasArg); }
private static bool?GetToggleValue(ICommandArgument arg) { switch (arg.RawValue.ToLowerInvariant()) { case "true": case "on": case "1": return(true); case "false": case "off": case "0": return(false); default: return(null); } }
public static void DropKit(ICommandSource src, ICommandArgument kitArg, Vector3 pos) { var kitManager = KitModule.Instance.KitManager; var kitName = kitArg.ToString(); if (!kitManager.Contains(kitName)) { EssLang.Send(src, "KIT_NOT_EXIST", kitName); } else { var kitItems = kitManager.GetByName(kitName).Items; kitItems.Where(i => i is KitItem).Cast <KitItem>().ForEach(i => ItemManager.dropItem(i.UnturnedItem, pos, true, true, true) ); } }
public Parser(IParserService parserService, IEnumerable <IOspCommand> commands, IOptions <OspToolOptions> options) { _parserService = parserService; _commands = commands; Options = options; _commandArg = _parserService.AddCommandArgument("c", "command", new[] { "Command that has to be executed:" }, true); foreach (var ospCommand in _commands) { ospCommand.AddCommand(_commandArg); } CreateSamples(); }
public IBackloadStorageProviderFile Update(ICommandArgument args) { File f = this.Files.Find(args.FileId); // Update or add file to context if (f != null) { f.Update(args.FileContext); } else { f = this.Files.Add(new File(args.FileContext)); } if (args.SaveChanges) { this.SaveChanges(); } return(f); }
public static PushCommand FormatPushCommand(string remote, ICollection<string> branches, bool force, bool thin, bool tags) { var args = new ICommandArgument[branches.Count + 3 + (force?1:0) + (tags?1:0)]; int arg = 0; if(tags) { args[arg++] = Tags(); } if(force) { args[arg++] = Force(); } args[arg++] = thin ? Thin() : NoThin(); args[arg++] = Porcelain(); args[arg++] = new CommandParameter(remote); foreach(var branch in branches) { args[arg++] = new CommandParameter(branch); } return new PushCommand(args); }
public static PushCommand FormatPushCommand(string remote, ICollection <string> branches, bool force, bool thin, bool tags) { var args = new ICommandArgument[branches.Count + 3 + (force?1:0) + (tags?1:0)]; int arg = 0; if (tags) { args[arg++] = Tags(); } if (force) { args[arg++] = Force(); } args[arg++] = thin ? Thin() : NoThin(); args[arg++] = Porcelain(); args[arg++] = new CommandParameter(remote); foreach (var branch in branches) { args[arg++] = new CommandParameter(branch); } return(new PushCommand(args)); }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; Assembly ThisAssembly = Assembly.GetCallingAssembly(); string AppTitle = "Shango"; string AppCompany = "Afrosoft"; Version AppVersion = new Version("0.1.0.10"); object[] Attributes = ThisAssembly.GetCustomAttributes( false ); foreach ( object Attr in Attributes ) { if ( Attr is AssemblyTitleAttribute ) { AppTitle = ( ( AssemblyTitleAttribute ) Attr ).Title; } if ( Attr is AssemblyCompanyAttribute ) { AppCompany = ( ( AssemblyCompanyAttribute ) Attr ).Company; } if ( Attr is AssemblyName ) { AppVersion = ( ( AssemblyName ) Attr ).Version; } } string AppDescription = AppCompany + " " + AppTitle; AppDescription += " [Version " + AppVersion.Major + "." + AppVersion.Minor + "." + AppVersion.Revision + "." + AppVersion.Build + "]"; TermUtil.WriteText( _Terminal, AppDescription + Environment.NewLine ); return 0; }
/// <summary> /// Gets argument value from Cake commandline. /// </summary> /// <param name="arg">Command Argument</param> /// <param name="context">Cake Context</param> /// <returns>Value as string if defined. Empty string if not defined.</returns> /// <example> /// <code> /// var newArg = CommandHelper.AddArgument("test", "t", "Testing stuff"); /// var argVal = newArg.GetArgumentValue(Context) /// </code> /// </example> public static string GetArgumentValue(this ICommandArgument arg, ICakeContext context) { if (arg == null) { throw new ArgumentNullException(nameof(arg)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } var longArgValue = context.Argument(arg.Name, string.Empty); if (!string.IsNullOrWhiteSpace(longArgValue)) { return(longArgValue); } var shortArgValue = context.Argument(arg.Shortname, string.Empty); return(shortArgValue); }
public static void DropKit(ICommandSource src, ICommandArgument kitArg, Vector3 pos) { var kitManager = KitModule.Instance.KitManager; var kitName = kitArg.ToString(); if (!kitManager.Contains(kitName)) { context.User.SendLocalizedMessage(Translations, "KIT_NOT_EXIST", kitName); return; } foreach (var item in kitManager.GetByName(kitName).Items) { if (item is KitItem kitItem) { ItemManager.dropItem(kitItem.UnturnedItem, pos, true, true, true); } if (item is KitItemVehicle vehicleItem) { VehicleManager.spawnVehicle(vehicleItem.Id, pos + (Vector3.up * 16), Quaternion.identity); } } }
public override int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult ) { CommandResult = null; string CommandName = (string) Arguments[0].GetArgument(); string CommandArguments = null; if ( Arguments.Length > 1 ) { CommandArguments = (string) Arguments[1].GetArgument(); } for ( int Argument = 2; Argument < Arguments.Length; Argument++ ) { CommandArguments += " " + Arguments[Argument].GetArgument(); } _Process = new RedirectedProcess( _Terminal, this ); _Process.Start( CommandName, CommandArguments ); return 0; }
/// <summary> /// </summary> /// <param name="src"></param> /// <param name="minInclusive">Maximum value</param> /// <param name="maxInclusive">Minimum value</param> /// <returns></returns> public static bool IsInRange(this ICommandArgument src, int minInclusive, int maxInclusive) { var val = src.ToInt; return(val >= minInclusive && val <= maxInclusive); }
internal Command(CommandType commandType, ICommandArgument argument) // ReSharper disable once IntroduceOptionalParameters.Global : this(commandType, argument, null) { }
private static void GiveItem( ICommandSource src, UPlayer target, ICommandArgument itemArg, ICommandArgument amountArg, bool allPlayers = false ) { ItemAsset asset; if ( itemArg.IsUshort ) { var id = itemArg.ToUshort; asset = (ItemAsset) Assets.find( EAssetType.ITEM, id ); } else { asset = UnturnedItems.GetItemAssetByName( itemArg.ToLowerString ); } if ( asset == null ) { src.SendMessage( $"Could not find an item with this name or id: {itemArg}" ); return; } ushort amt = 1; if ( amountArg != null ) { if ( !amountArg.IsShort ) { EssLang.INVALID_NUMBER.SendTo( src, amountArg ); } else if ( amountArg.ToUshort <= 0 ) { EssLang.MUST_POSITIVE.SendTo( src ); } else { amt = amountArg.ToUshort; goto give; } return; } give: var playersToReceive = new List<UPlayer>(); var item = new Item( asset.id, true ); if ( allPlayers ) { UServer.Players.ForEach( playersToReceive.Add ); EssLang.GIVEN_ITEM_ALL.SendTo( src, amt, asset.Name ); } else { playersToReceive.Add( target ); if ( !src.IsConsole && src.ToPlayer() != target ) { EssLang.GIVEN_ITEM.SendTo( src, amt, asset.Name, target.CharacterName ); } } playersToReceive.ForEach( p => { var success = p.GiveItem( item, amt, true ); EssLang.RECEIVED_ITEM.SendTo( p, amt, asset.Name ); if ( !success ) { EssLang.INVENTORY_FULL.SendTo( p ); } } ); }
private static void GiveItem(ICommandSource src, UPlayer target, ICommandArgument itemArg, ICommandArgument amountArg, bool allPlayers = false) { if (!src.HasPermission("essentials.command.item.other") && target != src) { EssLang.Send(src, "COMMAND_NO_PERMISSION"); return; } var optAsset = ItemUtil.GetItem(itemArg.ToString()); if (optAsset.IsAbsent) { EssLang.Send(src, "ITEM_NOT_FOUND", itemArg); return; } if (UEssentials.Config.GiveItemBlacklist.Contains(optAsset.Value.id) && !src.HasPermission("essentials.bypass.blacklist.item")) { EssLang.Send(src, "BLACKLISTED_ITEM", $"{optAsset.Value.itemName} ({optAsset.Value.id})"); return; } ushort amt = 1; if (amountArg != null) { if (!amountArg.IsShort) { EssLang.Send(src, "INVALID_NUMBER", amountArg); } else if (amountArg.ToShort <= 0) { EssLang.Send(src, "MUST_POSITIVE"); } else { amt = amountArg.ToUShort; goto give; } return; } give: var asset = optAsset.Value; var playersToReceive = new List <UPlayer>(); var item = new Item(asset.id, true); if (asset is ItemFuelAsset) { ItemUtil.Refuel(item); } if (!src.HasPermission("essentials.bypass.itemlimit") && amt > UEssentials.Config.ItemSpawnLimit) { amt = UEssentials.Config.ItemSpawnLimit; EssLang.Send(src, "ITEM_LIMIT", amt); } if (allPlayers) { UServer.Players.ForEach(playersToReceive.Add); EssLang.Send(src, "GIVEN_ITEM_ALL", amt, asset.itemName, asset.id); } else { playersToReceive.Add(target); if (!src.IsConsole && src.ToPlayer() == target) { goto give2; } EssLang.Send(src, "GIVEN_ITEM", amt, asset.itemName, asset.id, target.CharacterName); } give2: playersToReceive.ForEach(p => { var success = p.GiveItem(item, amt, true); EssLang.Send(p, "RECEIVED_ITEM", amt, asset.itemName, asset.id); if (!success) { EssLang.Send(p, "INVENTORY_FULL"); } }); }
public bool Equals(ICommandArgument other) { return(other.RawValue == this.RawValue); }
public int SqlExecute(ICommandArgument args) { return(this.Database.ExecuteSqlCommand(args.SqlCommand, args.SqlParameter)); }
public CommandArgs( string rawArgs ) { RawArguments = new string[0]; if ( rawArgs.Length < 0 ) return; var args = new List<string>(); var argBuilder = new StringBuilder(); var inQuot = false; var chars = rawArgs.ToCharArray(); var charLen = chars.Length; for ( var i = 0; i < charLen; i++ ) { var ch = chars[i]; if ( (ch == '\'' || ch == '"') ) { if ( i != 0 && chars[i - 1] == '\\' ) { argBuilder.Length = argBuilder.Length - 1; goto append; } inQuot = !inQuot; goto appendAll; } if ( ch == ' ' ) { if ( inQuot ) goto append; goto appendAll; } append: argBuilder.Append( ch ); if ( i == (charLen - 1) ) goto appendAll; continue; appendAll: if ( argBuilder.Length > 0 ) { args.Add( argBuilder.ToString() ); argBuilder.Length = 0; } } RawArguments = args.ToArray(); var arguments = new ICommandArgument[ Length ]; for ( var i = 0; i < RawArguments.Length; i++ ) { arguments[i] = new CommandArgument( i, RawArguments[i] ); } Arguments = arguments; }
public CommandArgs(string[] rawArgs) { /*RawArguments = new string[0]; * * if ( rawArgs.Length < 0 ) * return; * * var args = new List<string>(); * var argBuilder = new StringBuilder(); * var inQuot = false; * * var chars = rawArgs.ToCharArray(); * var charLen = chars.Length; * * for ( var i = 0; i < charLen; i++ ) * { * var ch = chars[i]; * * if ( (ch == '\'' || ch == '"') ) * { * if ( i != 0 && chars[i - 1] == '\\' ) * { * argBuilder.Length = argBuilder.Length - 1; * goto append; * } * * inQuot = !inQuot; * goto appendAll; * } * * if ( ch == ' ' ) * { * if ( inQuot ) * goto append; * goto appendAll; * } * * append: * argBuilder.Append( ch ); * if ( i == (charLen - 1) ) * goto appendAll; * continue; * * appendAll: * if ( argBuilder.Length > 0 ) * { * args.Add( argBuilder.ToString() ); * argBuilder.Length = 0; * } * }*/ RawArguments = rawArgs; var arguments = new ICommandArgument[Length]; for (var i = 0; i < RawArguments.Length; i++) { arguments[i] = new CommandArgument(i, RawArguments[i]); } Arguments = arguments; }
public void SetNext(ICommandArgument icommand) { nextCommandArgument = icommand; }
private static void InsertQueryRevisionsParameters(QueryRevisionsParameters parameters, IList<ICommandArgument> args, ICommandArgument format) { #region Commit Limiting if(parameters.MaxCount != 0) { args.Add(LogCommand.MaxCount(parameters.MaxCount)); } if(parameters.Skip != 0) { args.Add(LogCommand.Skip(parameters.Skip)); } if(parameters.SinceDate.HasValue) { args.Add(LogCommand.Since(parameters.SinceDate.Value)); } if(parameters.UntilDate.HasValue) { args.Add(LogCommand.Until(parameters.UntilDate.Value)); } if(parameters.AuthorPattern != null) { args.Add(LogCommand.Author(parameters.AuthorPattern)); } if(parameters.CommitterPattern != null) { args.Add(LogCommand.Committer(parameters.CommitterPattern)); } if(parameters.MessagePattern != null) { args.Add(LogCommand.Grep(parameters.MessagePattern)); } if(parameters.AllMatch) { args.Add(LogCommand.AllMatch()); } if(parameters.RegexpIgnoreCase) { args.Add(LogCommand.RegexpIgnoreCase()); } if(parameters.RegexpExtended) { args.Add(LogCommand.ExtendedRegexp()); } if(parameters.RegexpFixedStrings) { args.Add(LogCommand.FixedStrings()); } if(parameters.RemoveEmpty) { args.Add(LogCommand.RemoveEmpty()); } switch(parameters.MergesMode) { case RevisionMergesQueryMode.MergesOnly: args.Add(LogCommand.Merges()); break; case RevisionMergesQueryMode.NoMerges: args.Add(LogCommand.NoMerges()); break; } if(parameters.Follow) { args.Add(LogCommand.Follow()); } if(parameters.Not) { args.Add(LogCommand.Not()); } if(parameters.All) { args.Add(LogCommand.All()); } if(parameters.ReferencesGlob != null) { args.Add(LogCommand.Glob(parameters.ReferencesGlob)); } if(parameters.Branches != null) { args.Add(LogCommand.Branches(parameters.Branches)); } if(parameters.Tags != null) { args.Add(LogCommand.Tags(parameters.Tags)); } if(parameters.Remotes != null) { args.Add(LogCommand.Remotes(parameters.Remotes)); } #endregion #region History Simplification if(parameters.FirstParent) { args.Add(LogCommand.FirstParent()); } if(parameters.SimplifyByDecoration) { args.Add(LogCommand.SimplifyByDecoration()); } if(parameters.EnableParentsRewriting) { args.Add(LogCommand.Parents()); } #endregion #region Ordering switch(parameters.Order) { case RevisionQueryOrder.DateOrder: args.Add(LogCommand.DateOrder()); break; case RevisionQueryOrder.TopoOrder: args.Add(LogCommand.TopoOrder()); break; } if(parameters.Reverse) { args.Add(LogCommand.Reverse()); } #endregion #region Formatting args.Add(LogCommand.NullTerminate()); if(format != null) { args.Add(format); } #endregion if(parameters.Since != null && parameters.Until != null) { args.Add(new CommandParameter(parameters.Since + ".." + parameters.Until)); } if(parameters.References != null) { foreach(var reference in parameters.References) { args.Add(new CommandParameter(reference)); } } if(parameters.Paths != null && parameters.Paths.Count != 0) { args.Add(CommandFlag.NoMoreOptions()); foreach(var path in parameters.Paths) { args.Add(new PathCommandArgument(path)); } } }
public void AddCommand(ICommandArgument commandArgument) { CommandArgumentValue = commandArgument.AddCommandValue(CommandValue, _commandDescription); AddArguments(); }
public abstract int PerformCommand( ICommandArgument[] Arguments, out ICommandResult CommandResult );