public void TestFlagParsingError() { string[] args = new string[] { "-myintflag=", "--mystringflag", "test.txt", "-myintflag=10", "-myboolFlag" }; var flags = new Parser(); var intFlag = flags.AddIntFlag("myintflag", 0, "An integer flag"); // defaults to 0 var stringFlag = flags.AddStringFlag("mystringflag", "nothing", "A string flag"); // defaults to "nothing" var boolFlag = flags.AddBoolFlag("myboolFlag", false, "A bool flag"); // defaults to false. flags.Parse(args); Assert.IsTrue(flags.HasErrors); // The parser breaks once an error is enountered so these values would NOT be set FlagValue <string> flagString = flags["mystringflag"] as FlagValue <string>; Assert.AreNotEqual("test.txt", flagString.Value); FlagValue <bool> flagBool = flags["myboolFlag"] as FlagValue <bool>; Assert.AreNotEqual(true, flagBool.Value); FlagValue <int> flagInt = flags["myintflag"] as FlagValue <int>; Assert.AreNotEqual(10, flagInt.Value); }
public static void Main(string[] args) { Parser parser = new Parser(); FlagValue <string> file = parser.AddStringFlag("File", "", "File to read"); parser.Parse(args); if (file == null) { throw new Exception("Unable to get file information"); } try { FileReader fr = new FileReader(); string line = fr.Read(file.Value); Histogram histogram = new Histogram(); IEnumerable <WordPair> wordPairs = histogram.CreateHistogram(line); foreach (var item in wordPairs) { Console.WriteLine(@"""{0}"" {1}", item.Text, item.Count); } Console.ReadKey(); } catch (Exception e) { Console.WriteLine(e.Message); Console.ReadKey(); } }
public void TestSetup() { parser = new Parser(); stringFlag = parser.AddStringFlag("MyStringFlag", ""); intFlag = parser.AddIntFlag("MyIntFlag", 0); boolFlag = parser.AddBoolFlag("MyBoolFlag", false); }
public PatternEntry(string pattern, string pattern2, string pattern3, FlagValue condition, FlagValue condition2) { Pattern = pattern; Pattern2 = pattern2; Pattern3 = pattern3; Condition = condition; Condition2 = condition2; }
/// <summary> /// Sets the value of a conditional flag. /// </summary> /// <param name="p_strFlagName">The name of the falg whose value is to be set.</param> /// <param name="p_strValue">The value to which to set the flag.</param> /// <param name="p_pifPlugin">The plugin that is responsible for setting the flag's value.</param> public void SetFlagValue(string p_strFlagName, string p_strValue, Option p_pifPlugin) { if (!m_dicFlags.ContainsKey(p_strFlagName)) { m_dicFlags[p_strFlagName] = new FlagValue(); } m_dicFlags[p_strFlagName].Value = p_strValue; m_dicFlags[p_strFlagName].Owner = p_pifPlugin; }
public IActionResult DeleteFlagValue(long id) { FlagValue a = FlagValue_repo.Find(id); if (a == null) { return(NotFound()); } FlagValue_repo.Delete(a); return(Ok()); }
private void SetDefault() { this.ForegroundBright = FlagValue.Unset; this.BackgroundBright = FlagValue.Unset; this.Underline = FlagValue.Unset; this.Inverse = FlagValue.Unset; this.HaveForeground = this.HaveBackground = false; this.HaveBasicForeground = this.HaveBasicBackground = true; this.BasicForegroundColor = DefaultForegroundColor; this.BasicBackgroundColor = DefaultBackgroundColor; }
public void Should_Return_Correct_String_Representation_From_ToString_If_Value_Is_Not_Set( bool isSet, string expected) { // Given var flag = new FlagValue <string>(); flag.IsSet = isSet; // When var result = flag.ToString(); // Then result.ShouldBe(expected); }
public void Should_Return_Correct_String_Representation_From_ToString( string value, bool isSet, string expected) { // Given var flag = new FlagValue <string> { Value = value, IsSet = isSet, }; // When var result = flag.ToString(); // Then result.ShouldBe(expected); }
public bool ContainsFlagAt(int wordIndex, FlagValue flag) { #if DEBUG if (wordIndex < 0) { throw new ArgumentOutOfRangeException(nameof(wordIndex)); } #endif if (wordIndex < Words.Count) { var detail = Words[wordIndex]; if (detail != null) { return(detail.ContainsFlag(flag)); } } return(false); }
public void TestFlagParsing() { string[] args = new string[] { "--mystringflag", "test.txt", "-myintflag=10", "-myboolFlag" }; var flags = new Parser(); var intFlag = flags.AddIntFlag("myintflag", 0, "An integer flag"); // defaults to 0 var stringFlag = flags.AddStringFlag("mystringflag", "nothing", "A string flag"); // defaults to "nothing" var boolFlag = flags.AddBoolFlag("myboolFlag", false, "A bool flag"); // defaults to false. flags.Parse(args); Assert.IsFalse(flags.HasErrors); FlagValue <string> flagString = flags["mystringflag"] as FlagValue <string>; Assert.AreEqual("test.txt", flagString.Value); FlagValue <bool> flagBool = flags["myboolFlag"] as FlagValue <bool>; Assert.AreEqual(true, flagBool.Value); FlagValue <int> flagInt = flags["myintflag"] as FlagValue <int>; Assert.AreEqual(10, flagInt.Value); }
static bool handleProperties(XmlNode node, ElementInfo ei) { if (ei.properties == null) ei.properties = new ArrayList (); XmlElement elt = node as XmlElement; if (elt == null) return true; foreach (XmlElement property in elt.ChildNodes) { if (IsHidden (property)) continue; PropertyInfo pi = new PropertyInfo (); pi.name = property["name"].InnerText; pi.managed_name = (property["managed_name"] != null) ? property["managed_name"].InnerText : null; pi.type = property["type"].InnerText; pi.readable = property["flags"].InnerText.IndexOf ('R') != -1; pi.writeable = property["flags"].InnerText.IndexOf ('W') != -1; if (property["enum-values"] != null) { pi.enuminfo = new EnumInfo (); pi.enuminfo.flag = false; pi.enuminfo.values = new ArrayList (); foreach (XmlNode val in property["enum-values"].ChildNodes) { EnumValue env = new EnumValue (); env.name = val.Attributes["nick"].InnerText; env.value = Int32.Parse (val.Attributes["value"].InnerText); pi.enuminfo.values.Add (env); } } else if (property["flags-values"] != null) { pi.enuminfo = new EnumInfo (); pi.enuminfo.flag = true; pi.enuminfo.values = new ArrayList (); foreach (XmlNode val in property["flags-values"].ChildNodes) { FlagValue env = new FlagValue (); env.name = val.Attributes["nick"].InnerText; env.value = UInt32.Parse (val.Attributes["value"].InnerText); pi.enuminfo.values.Add (env); } } ei.properties.Add (pi); } return true; }
/// <summary> /// Sets the value of a conditional flag. /// </summary> /// <param name="p_strFlagName">The name of the falg whose value is to be set.</param> /// <param name="p_strValue">The value to which to set the flag.</param> /// <param name="p_pifPlugin">The plugin that is responsible for setting the flag's value.</param> public void SetFlagValue(string p_strFlagName, string p_strValue, PluginInfo p_pifPlugin) { if (!m_dicFlags.ContainsKey(p_strFlagName)) m_dicFlags[p_strFlagName] = new FlagValue(); m_dicFlags[p_strFlagName].Value = p_strValue; m_dicFlags[p_strFlagName].Owner = p_pifPlugin; }
public bool ContainsAnyFlags(FlagValue a, FlagValue b, FlagValue c, FlagValue d) => HasFlags && Flags.ContainsAny(a, b, c, d);
public bool ContainsAnyFlags(FlagValue a, FlagValue b) => HasFlags && Flags.ContainsAny(a, b);
public NumberToFlagMappingBuilder <TResult> AddMapping(FlagValue digit, Expression <Func <TResult, bool> > targetExpression) { _mappingDictionary.Set((int)digit, targetExpression); return(this); }
public Flag() { Value = FlagValue.Public; }
public static void DisplayMethod(Type a, FlagValue f) { Console.Write(a.Name); if (f == FlagValue.Public) { Console.WriteLine(" -- public"); } else if (f == FlagValue.Static) { Console.WriteLine(" -- static"); } foreach (var meth in a.GetMethods()) { if (f == FlagValue.Static) { if (!meth.IsStatic) { continue; } } if (f == FlagValue.Public) { if (meth.IsStatic) { continue; } } Console.Write("public "); if (meth.IsStatic) { Console.Write("static "); } Console.Write(meth.ReturnType.Name + " "); Console.Write(meth.Name + " ("); ArrayList paramValue = new ArrayList(); bool isFirst = true; foreach (var param in meth.GetParameters()) { if (isFirst) { isFirst = false; } else { Console.Write(", "); } Console.Write(param.ParameterType.Name + " " + param.Name); if (param.ParameterType == typeof(String)) { paramValue.Add(GetRandomString(5)); } if (param.ParameterType == typeof(int)) { paramValue.Add(GetRandomInt()); } if (param.ParameterType == typeof(double)) { paramValue.Add((double)GetRandomInt()); } if (param.ParameterType == typeof(object)) { paramValue.Add(null); } } Console.Write(")"); Console.WriteLine(); if (meth.ReturnType != typeof(void)) { if (f == FlagValue.Public) { Console.WriteLine("-----Rusult: " + a.GetMethod(meth.Name).Invoke( Activator.CreateInstance(a), GetObjParamValue(paramValue) )); } else if (f == FlagValue.Static) { Console.WriteLine("-----Rusult: " + a.GetMethod(meth.Name).Invoke( a, GetObjParamValue(paramValue) )); } } } }
private void Reset() { this.ForegroundBright = this.BackgroundBright = this.Underline = this.Inverse = FlagValue.None; this.HaveBasicForeground = this.HaveForeground = this.HaveXtermForeground = false; this.HaveBasicBackground = this.HaveBackground = this.HaveXtermBackground = false; }
public IActionResult UpdateFlagValue([FromBody] FlagValue model) { FlagValue_repo.Update(model); return(new OkObjectResult(new { FlagValueID = model.FlagValueId })); }
static bool handleProperties(XmlNode node, ElementInfo ei) { if (ei.properties == null) { ei.properties = new ArrayList(); } XmlElement elt = node as XmlElement; if (elt == null) { return(true); } foreach (XmlElement property in elt.ChildNodes) { if (IsHidden(property)) { continue; } PropertyInfo pi = new PropertyInfo(); pi.name = property["name"].InnerText; pi.managed_name = (property["managed_name"] != null) ? property["managed_name"].InnerText : null; pi.type = property["type"].InnerText; pi.readable = property["flags"].InnerText.IndexOf('R') != -1; pi.writeable = property["flags"].InnerText.IndexOf('W') != -1; if (property["enum-values"] != null) { pi.enuminfo = new EnumInfo(); pi.enuminfo.flag = false; pi.enuminfo.values = new ArrayList(); foreach (XmlNode val in property["enum-values"].ChildNodes) { EnumValue env = new EnumValue(); env.name = val.Attributes["nick"].InnerText; env.value = Int32.Parse(val.Attributes["value"].InnerText); pi.enuminfo.values.Add(env); } } else if (property["flags-values"] != null) { pi.enuminfo = new EnumInfo(); pi.enuminfo.flag = true; pi.enuminfo.values = new ArrayList(); foreach (XmlNode val in property["flags-values"].ChildNodes) { FlagValue env = new FlagValue(); env.name = val.Attributes["nick"].InnerText; env.value = UInt32.Parse(val.Attributes["value"].InnerText); pi.enuminfo.values.Add(env); } } ei.properties.Add(pi); } return(true); }
private bool GetFlag(FlagValue flagValue) { return((Value & (ushort)flagValue) > 0); }
private void ResetFlag(FlagValue flagValue) { Value &= (ushort)~((ushort)flagValue); }
private void SetFlag(FlagValue flagValue) { Value |= (ushort)flagValue; }
private static void FetchOptions(CommandContext state) { state.Commands.Clear(); foreach (MethodInfo i in state.CurrentObject.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance)) { var cmd = i.GetCustomAttribute(typeof(CommandAttribute)) as CommandAttribute; if (cmd == null) { continue; } CommandValue value = new CommandValue() { Arguments = cmd, Method = i, Instance = state.CurrentObject }; state.Commands.Replace(value.Arguments.Name, value); } foreach (PropertyInfo i in state.CurrentObject.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { var cmd = i.GetCustomAttribute(typeof(CommandAttribute)) as CommandAttribute; var nvalue = i.GetCustomAttribute(typeof(NamedValueAttribute)) as NamedValueAttribute; var flag = i.GetCustomAttribute(typeof(FlagValueAttribute)) as FlagValueAttribute; if (cmd != null) { CommandValue value = new CommandValue() { Arguments = cmd, Property = i, Instance = state.CurrentObject }; state.Commands.Replace(value.Arguments.Name, value); } if (nvalue != null) { NamedValue value = new NamedValue() { Arguments = nvalue, Property = i, Instance = state.CurrentObject }; state.NamedValues.Replace(value.Arguments.Name, value); if (value.Arguments.Name == "") { state.DefaultValue = value; } } if (flag != null) { FlagValue value = new FlagValue() { Arguments = flag, Property = i, Instance = state.CurrentObject }; state.LongFlags.Replace(value.Arguments.Name, value); state.ShortFlags.Replace(value.Arguments.ShortName, value); } } }
/// <summary> /// Returns a <see cref="string"/> that represents this instance. /// </summary> /// <returns>A <see cref="string"/> that represents this instance.</returns> public override string ToString() => $"{FlagName} {FlagValue.ToString(x => x.ToString())}";
/// <summary> /// Add your own Custom FlagValue handler for flag parsing. /// </summary> public FlagValue <T> Add <T>(string name, FlagValue <T> val) { _flags[name] = val; return(val); }
public Flag(FlagValue a) { Value = a; }
public bool ContainsFlag(FlagValue flag) => Flags.Contains(flag);
internal static bool Is(this FlagValue <bool> flagValue, bool target, bool defaultValue = false) { return(flagValue.IsSet ? flagValue.Value == target : defaultValue == target); }
public SetGraphicsRendition(string bufferData) : base(bufferData) { this.ForegroundBright = FlagValue.None; this.BackgroundBright = FlagValue.None; this.Underline = FlagValue.None; this.Inverse = FlagValue.None; if (this.Parameters.Count == 0) { this.SetDefault(); return; } var p = 0; while (p < this.Parameters.Count) { var pValue = this.ParameterToNumber(p, defaultValue: -1); switch (pValue) { case 0: this.SetDefault(); break; case 1: this.ForegroundBright = FlagValue.Set; break; case 22: this.ForegroundBright = FlagValue.Unset; break; case 4: this.Underline = FlagValue.Set; break; case 24: this.Underline = FlagValue.Unset; break; case 7: this.Inverse = FlagValue.Set; break; case 27: this.Inverse = FlagValue.Unset; break; case 30: case 31: case 32: case 33: case 34: case 35: case 36: case 37: this.HaveBasicForeground = true; this.BasicForegroundColor = (Colors)(pValue - 30); break; case 38: { if (this.ReadXtermColorInfo(ref p, out var idx, out var color)) { if (idx > -1) { this.HaveXtermForeground = true; this.XtermForegroundColor = idx; } else { this.HaveForeground = true; this.ForegroundColor = color; } break; } this.Reset(); return; } case 39: this.HaveBasicForeground = true; this.BasicForegroundColor = DefaultForegroundColor; break; case 40: case 41: case 42: case 43: case 44: case 45: case 46: case 47: this.HaveBasicBackground = true; this.BasicBackgroundColor = (Colors)(pValue - 40); break; case 48: { if (this.ReadXtermColorInfo(ref p, out var idx, out var color)) { if (idx > -1) { this.HaveXtermBackground = true; this.XtermBackgroundColor = idx; } else { this.HaveBackground = true; this.BackgroundColor = color; } break; } this.Reset(); return; } case 49: this.HaveBasicBackground = true; this.BasicBackgroundColor = DefaultBackgroundColor; break; case 90: case 91: case 92: case 93: case 94: case 95: case 96: case 97: this.HaveBasicForeground = true; this.ForegroundBright = FlagValue.Set; // XXX: idk if this is right this.BasicForegroundColor = (Colors)(pValue - 90); break; case 100: case 101: case 102: case 103: case 104: case 105: case 106: case 107: this.HaveBasicBackground = true; this.BackgroundBright = FlagValue.Set; // same as above. this.BasicBackgroundColor = (Colors)(pValue - 100); break; } ++p; } }