/// <summary> /// Generates a regular expression that matches the specified regular expressions in any order.</summary> /// <typeparam name="TResult"> /// Type of the result object associated with each match of the regular expression.</typeparam> /// <param name="stringerexes"> /// The regular expressions to match.</param> public static Stringerex <IEnumerable <TResult> > InAnyOrder <TResult>(params Stringerex <TResult>[] stringerexes) { if (stringerexes == null) { throw new ArgumentNullException("stringerexes"); } return(Generex.InAnyOrder <Stringerex <TResult>, Stringerex <IEnumerable <TResult> > >( thenner: (prev, next) => prev.ThenRaw(next, InternalExtensions.Concat), orer: (one, two) => one.Or(two), constructor: () => new Stringerex <IEnumerable <TResult> >(Enumerable.Empty <TResult>()), generexes: stringerexes)); }
/// <summary> /// Returns a regular expression that matches this regular expression, then attempts to match the specified other /// regular expression and throws an exception if the second regular expression fails to match; otherwise, a /// result object is generated from the result objects of the two matches.</summary> /// <typeparam name="TOther"> /// Type of the result object of the <paramref name="expectation"/>.</typeparam> /// <typeparam name="TCombined"> /// Type of the result object for the resulting regular expression.</typeparam> /// <param name="expectation"> /// The regular expression that is expected to match after the current one.</param> /// <param name="selector"> /// A selector which, in case of a match, generates the new result given the current result and the result object /// of the match of the <paramref name="expectation"/>.</param> /// <param name="exceptionGenerator"> /// A selector which, in case of no match, generates the exception object to be thrown.</param> /// <returns> /// The resulting regular expression.</returns> /// <remarks> /// Regular expressions created by this method cannot match backwards. The full set of affected methods is listed /// at <see cref="GenerexBase{T, TMatch, TGenerex, TGenerexMatch}.Then{TOtherGenerex, TOtherMatch, /// TOtherGenerexMatch}(Func{TGenerexMatch, GenerexBase{T, TOtherMatch, TOtherGenerex, TOtherGenerexMatch}})"/>.</remarks> public Generex <T, TCombined> ThenExpectRaw <TOther, TCombined>(Generex <T, TOther> expectation, Func <TResult, TOther, TCombined> selector, Func <GenerexMatch <T, TResult>, Exception> exceptionGenerator) { if (expectation == null) { throw new ArgumentNullException("expectation"); } if (selector == null) { throw new ArgumentNullException("selector"); } return(then <Generex <T, TCombined>, LengthAndResult <TCombined>, GenerexMatch <T, TCombined>, GenerexMatch <T, TResult> >(m => expectation.process <Generex <T, TCombined>, GenerexMatch <T, TCombined>, TCombined>(m2 => selector(m.Result, m2.Result)).expect(() => exceptionGenerator(m)), createMatch)); }
/// <summary> /// Generates a regular expression that matches the specified regular expressions in any order.</summary> /// <param name="stringerexes"> /// The regular expressions to match.</param> public static Stringerex InAnyOrder(params Stringerex[] stringerexes) { if (stringerexes == null) { throw new ArgumentNullException("stringerexes"); } return(Generex.InAnyOrder <Stringerex, Stringerex>( thenner: (prev, next) => prev.Then(next), orer: (one, two) => one.Or(two), constructor: () => new Stringerex(), generexes: stringerexes)); }
/// <summary> /// Generates a regular expression that matches the characters of the specified string in any order.</summary> /// <param name="characters"> /// A string containing the characters to match.</param> /// <param name="comparer"> /// The optional equality comparer to use to determine matching characters.</param> public static Stringerex InAnyOrder(string characters, IEqualityComparer <char> comparer = null) { if (characters == null) { throw new ArgumentNullException("characters"); } comparer = comparer ?? EqualityComparer <char> .Default; return(Generex.InAnyOrder <Stringerex, Stringerex>( thenner: (prev, next) => prev.Then(next), orer: (one, two) => one.Or(two), constructor: () => new Stringerex(), generexes: characters.Select(ch => new Stringerex(ch, comparer)).ToArray())); }
/// <summary> /// Returns a regular expression that matches this regular expression, followed by the specified one, and /// generates a result object that combines the original two matches.</summary> public Generex <T, TCombined> ThenRaw <TOther, TCombined>(Generex <T, TOther> other, Func <TResult, TOther, TCombined> selector) { return(thenRaw <Generex <T, TOther>, GenerexMatch <T, TOther>, TOther, Generex <T, TCombined>, GenerexMatch <T, TCombined>, TCombined>(other, selector)); }
/// <summary> /// Returns a regular expression that matches this regular expression, followed by the specified one, and /// generates a result object that combines the result of this regular expression with the match of the other.</summary> public Generex <T, TCombined> Then <TOther, TCombined>(Generex <T, TOther> other, Func <TResult, GenerexMatch <T, TOther>, TCombined> selector) { return(then <Generex <T, TOther>, GenerexMatch <T, TOther>, LengthAndResult <TOther>, Generex <T, TCombined>, GenerexMatch <T, TCombined>, TCombined>(other, selector)); }
/// <summary> /// Returns a regular expression that matches this regular expression, followed by the specified one, and /// generates a result object that combines the result of this regular expression with the match of the other.</summary> public Generex <T, TCombined> Then <TCombined>(Generex <T> other, Func <TResult, GenerexMatch <T>, TCombined> selector) { return(then <Generex <T>, GenerexMatch <T>, int, Generex <T, TCombined>, GenerexMatch <T, TCombined>, TCombined>(other, selector)); }
/// <summary> /// Returns a regular expression that matches this regular expression one or more times, interspersed with a /// separator. More times are prioritised.</summary> public Generex <T, IEnumerable <TResult> > RepeatWithSeparatorGreedy(Generex <T> separator) { return(ThenRaw(separator.Then(this).RepeatGreedy(), InternalExtensions.Concat)); }