/// <summary> /// Initialize an instance of <see cref="RegexNode"/>. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { SetPattern(pattern); Minimum = min; Maximum = max; RegexQuantifierOption = quantifierOption; }
/// <summary> /// Initialize an instance of <see cref="RegexNode"/>, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { SetInnerNode(innerNode); Minimum = min; Maximum = max; RegexQuantifierOption = quantifierOption; }
public virtual string AddQuantifier(string pattern, int?min, int?max, RegexQuantifierOption quantifierOption) { if (min < 0) { throw new ArgumentOutOfRangeException(nameof(min)); } if (max < 0) { throw new ArgumentOutOfRangeException(nameof(max)); } var quantifierOptionString = ToQuantifierOptionString(quantifierOption); string result = string.Empty; if ((!min.HasValue && !max.HasValue) || (min == 1 && max == 1)) { result = pattern; } else if (min.HasValue && max.HasValue) { if (min == 0 && max == 1) { result = pattern + ToTokenString(RegexToken.ZeroOrOne); } else if (min == max) { result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierClose); } else { result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierSeparator) + max.Value + ToTokenString(RegexToken.QuantifierClose); } } else if (min == 0 && !max.HasValue) { result = pattern + ToTokenString(RegexToken.ZeroOrMore); } else if (min == 1 && !max.HasValue) { result = pattern + ToTokenString(RegexToken.OneOrMore); } else if (min.HasValue && !max.HasValue) { result = pattern + ToTokenString(RegexToken.QuantifierOpen) + min.Value + ToTokenString(RegexToken.QuantifierSeparator) + ToTokenString(RegexToken.QuantifierClose); } else if (!min.HasValue && max.HasValue) { result = pattern + ToTokenString(RegexToken.QuantifierOpen) + ToTokenString(RegexToken.QuantifierSeparator) + max.Value + ToTokenString(RegexToken.QuantifierClose); } else { throw new NotImplementedException(); } return(result + quantifierOptionString); }
public void AddNodeQuantifierTest(RegexQuantifierOption quantifierOption) { // Arrange var regexGenerator = new RegexGenerator(); // Act regexGenerator.Add(@"a", min: 1, max: 10, quantifierOption: quantifierOption); // Assert Assert.Equal($@"a{{1,10}}{regexGenerator.RegexLanguageStrategy.Stringifier.ToQuantifierOptionString(quantifierOption)}", regexGenerator.ToString()); }
public virtual string ToQuantifierOptionString(RegexQuantifierOption quantifierOption) { switch (quantifierOption) { case RegexQuantifierOption.Greedy: return(""); case RegexQuantifierOption.Lazy: return(ToTokenString(RegexToken.Lazy)); case RegexQuantifierOption.Possessive: return(ToTokenString(RegexToken.Possessive)); default: throw new ArgumentOutOfRangeException(nameof(quantifierOption)); } }
/// <summary> /// Create and add <see cref="RegexAtomicGroupNode"/> to the generator. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="AtomicGroupNotSupportedException">Atomic group is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddAtomicGroup(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var atomicGroup = new RegexAtomicGroupNode(pattern, min, max, quantifierOption); return(AddAtomicGroup(atomicGroup)); }
/// <summary> /// Create and add <see cref="RegexGroupNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="node">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="capturing">Defines the group to be capturing or not.</param> /// <param name="name">Optional name of capture group.</param> /// <param name="options">Optional inline options for the group.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="NamedCapturingGroupNotSupportedException">Named capturing group is not supported by <see cref="RegexLanguage"/>.</exception> /// <exception cref="InlineGroupOptionsNotSupportedException">Inline group option is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddGroup(RegexNode node, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var groupNode = new RegexGroupNode(node.ToString(RegexLanguageStrategy.Stringifier), capturing, name, options, min, max, quantifierOption); return(AddGroup(groupNode)); }
/// <summary> /// Create and add <see cref="RegexNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> public RegexGenerator Add(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var node = new RegexNode(innerNode, min, max, quantifierOption); return(Add(node)); }
/// <summary> /// Create and add <see cref="RegexUnicodeCategoryNode"/> to the generator. /// <seealso cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/> /// <seealso cref="AddUnicodeCategory(RegexUnicodeCategoryNode)"/> /// </summary> /// <param name="unicodeDesignation">Unicode designation or named block.</param> /// <param name="negative">Optional value to determine if negate the category.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="UnicodeCategoryNotSupportedException">Unicode category is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddUnicodeCategory(string unicodeDesignation, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var unicodeCategoryNode = new RegexUnicodeCategoryNode(unicodeDesignation, negative, min, max, quantifierOption); return(AddUnicodeCategory(unicodeCategoryNode)); }
/// <summary> /// Create and add <see cref="RegexNegativeLookbehindAssertionNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="NegativeLookbehindAssertionNotSupportedException">Negative lookbehind assertion is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddNegativeLookbehindAssertion(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var negativeLookbehindAssertion = new RegexNegativeLookbehindAssertionNode(innerNode, min, max, quantifierOption); return(AddNegativeLookbehindAssertion(negativeLookbehindAssertion)); }
/// <summary> /// Create and add <see cref="RegexNegativeLookaheadAssertionNode"/> to the generator. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="NegativeLookaheadAssertionNotSupportedException">Negative lookahead assertion is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddNegativeLookaheadAssertion(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var negativeLookaheadAssertion = new RegexNegativeLookaheadAssertionNode(pattern, min, max, quantifierOption); return(AddNegativeLookaheadAssertion(negativeLookaheadAssertion)); }
/// <summary> /// Initialize an instance of <see cref="RegexAtomicGroupNode"/>, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexAtomicGroupNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(innerNode, min, max, quantifierOption) { }
/// <summary> /// Initialize an instance of <see cref="RegexAtomicGroupNode"/>. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexAtomicGroupNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(pattern, min, max, quantifierOption) { }
/// <summary> /// Initialize an instance of <see cref="RegexConditionalNode"/>, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="trueValue">Value of successful match.</param> /// <param name="falseValue">Value of failed match.</param> /// <param name="nameOrNumber">Name or number for backtracking.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexConditionalNode(RegexNode innerNode, string trueValue, string falseValue, string nameOrNumber = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(innerNode, min, max, quantifierOption) { TrueValue = trueValue; FalseValue = falseValue; NameOrNumber = nameOrNumber; }
/// <summary> /// Create and add <see cref="RegexAtomicGroupNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="AtomicGroupNotSupportedException">Atomic group is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddAtomicGroup(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var atomicGroup = new RegexAtomicGroupNode(innerNode, min, max, quantifierOption); return(AddAtomicGroup(atomicGroup)); }
/// <summary> /// Create and add <see cref="RegexPositiveLookaheadAssertionNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="PositiveLookaheadAssertionNotSupportedException">Positive lookahead assertion is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddPositiveLookaheadAssertion(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var positiveLookaheadAssertion = new RegexPositiveLookaheadAssertionNode(innerNode, min, max, quantifierOption); return(AddPositiveLookaheadAssertion(positiveLookaheadAssertion)); }
/// <summary> /// Initialize an instance of <see cref="RegexPositiveLookbehindAssertionNode"/>. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexPositiveLookbehindAssertionNode(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(pattern, min, max, quantifierOption) { }
/// <summary> /// Create and add <see cref="RegexPositiveLookbehindAssertionNode"/> to the generator. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="PositiveLookbehindAssertionNotSupportedException">Positive lookbehind assertion is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddPositiveLookbehindAssertion(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var positiveLookbehnidAssertion = new RegexPositiveLookbehindAssertionNode(pattern, min, max, quantifierOption); return(AddPositiveLookbehindAssertion(positiveLookbehnidAssertion)); }
/// <summary> /// Initialize an instance of <see cref="RegexPositiveLookbehindAssertionNode"/>, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexPositiveLookbehindAssertionNode(RegexNode innerNode, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(innerNode, min, max, quantifierOption) { }
/// <summary> /// Create and add <see cref="RegexConditionalNode"/> to the generator, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="trueValue">Value of successful match.</param> /// <param name="falseValue">Value of failed match.</param> /// <param name="nameOrNumber">Name or number for backtracking.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="ConditionalNotSupportedException">Conditional is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddConditional(RegexNode innerNode, string trueValue, string falseValue, string nameOrNumber = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var conditionalNode = new RegexConditionalNode(innerNode, trueValue, falseValue, nameOrNumber, min, max, quantifierOption); return(AddConditional(conditionalNode)); }
/// <summary> /// Initialize an instance of <see cref="RegexUnicodeCategoryNode"/> with flag <see cref="RegexUnicodeCategoryFlag"/>. /// <para>Internally call <see cref="Enum.ToString()"/>. Therefore, only use one value from <see cref="RegexUnicodeCategoryFlag"/> while using this constructor; /// Use <see cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/> instead for named unicode block.</para> /// <seealso cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/> /// </summary> /// <remarks> /// <code> /// (RegexUnicodeCategoryFlag.Lu | RegexUnicodeCategoryFlag.Ll).ToString() // will generate "Lu, Ll", which is a invalid form. /// </code> /// </remarks> /// <param name="unicodeCategory">Value from <see cref="RegexUnicodeCategoryFlag"/>.</param> /// <param name="negative">Optional value to determine if negate the category.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexUnicodeCategoryNode(RegexUnicodeCategoryFlag unicodeCategory, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(unicodeCategory.ToString(), min, max, quantifierOption) { Negative = negative; }
/// <summary> /// Create and add <see cref="RegexNode"/> to the generator. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> public RegexGenerator Add(string pattern, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var node = new RegexNode(pattern, min, max, quantifierOption); return(Add(node)); }
/// <summary> /// Initialize an instance of <see cref="RegexUnicodeCategoryNode"/> with unicode designation or name. /// </summary> /// <param name="unicodeDesignation">Unicode designation or named block.</param> /// <param name="negative">Optional value to determine if negate the category.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexUnicodeCategoryNode(string unicodeDesignation, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(unicodeDesignation, min, max, quantifierOption) { Negative = negative; }
/// <summary> /// Initialize an instance of <see cref="RegexGroupNode"/>, and include another <see cref="RegexNode"/> inside. /// </summary> /// <param name="innerNode">An existing <see cref="RegexNode"/> to be included.</param> /// <param name="capturing">Defines the group to be capturing or not.</param> /// <param name="name">Optional name of capture group.</param> /// <param name="options">Optional inline options for the group.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> public RegexGroupNode(RegexNode innerNode, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) : base(innerNode, min, max, quantifierOption) { SetName(name); SetIsCapturingGroup(capturing); Options = options; }
/// <summary> /// Create and add <see cref="RegexGroupNode"/> to the generator. /// </summary> /// <param name="pattern">Regex pattern.</param> /// <param name="capturing">Defines the group to be capturing or not.</param> /// <param name="name">Optional name of capture group.</param> /// <param name="options">Optional inline options for the group.</param> /// <param name="min">Optional minimum number of occurance.</param> /// <param name="max">Optional maximum number of occurance.</param> /// <param name="quantifierOption">Optional quantifier option.</param> /// <returns><see cref="RegexGenerator"/></returns> /// <exception cref="NamedCapturingGroupNotSupportedException">Named capturing group is not supported by <see cref="RegexLanguage"/>.</exception> /// <exception cref="InlineGroupOptionsNotSupportedException">Inline group option is not supported by <see cref="RegexLanguage"/>.</exception> public RegexGenerator AddGroup(string pattern, bool capturing = true, string name = null, string options = null, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy) { var groupNode = new RegexGroupNode(pattern, capturing, name, options, min, max, quantifierOption); return(AddGroup(groupNode)); }