Or(element, selector, comparer) Or(selector, comparer, elements) Or(selector, comparer, elements) ThenExpect<>(expectation, selector, exceptionGenerator) ThenExpect<>(expectation, selector, exceptionGenerator)
Legend Class Struct Enum Interface Delegate | Constructor Method Property Event Field |
| Sealed class: RT.Generexes.Generex<T, TResult>Summary
Provides regular-expression functionality for collections of arbitrary objects. Generic type parameters| T |
Type of the objects in the collection. | | TResult |
Type of the result object associated with each match of the regular expression. |
Remarks
This type is not directly instantiated; use Generex<T>.Process<TResult>(Func<GenerexMatch<T>, TResult>). Constructors | Instantiates an empty regular expression which always matches and returns the specified result object. |
Instance methods| Generex<T, TResult> | |
Returns a regular expression that only matches if the subarray matched by this regular expression also
contains a match for the specified other regular expression. | | Generex<T, TCombinedResult> | And<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherGenerexMatch, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also
contains a match for the specified other regular expression, and if so, combines the first match’s result
object with the second match using a specified selector. | | Generex<T, TResult> | |
Returns a regular expression that only matches if the subarray matched by this regular expression also fully
matches the specified other regular expression. | | Generex<T, TCombinedResult> | AndExact<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherGenerexMatch, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also fully
matches the specified other regular expression, and if so, combines the first match’s result object with the
second match using a specified selector. | | Generex<T, TCombinedResult> | AndExactRaw<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherResult, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also fully
matches the specified other regular expression, and if so, combines the result objects associated with both
matches using a specified selector. | | Generex<T, TCombinedResult> | AndRaw<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherResult, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also
contains a match for the specified other regular expression, and if so, combines the result objects associated
with both matches using a specified selector. | | Generex<T, TCombinedResult> | AndReverse<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherGenerexMatch, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also
contains a match for the specified other regular expression when matching backwards, and if so, combines the
first match’s result object with the second match using a specified selector. | | Generex<T, TCombinedResult> | AndReverseRaw<TOtherResult, TOtherGenerex, TOtherGenerexMatch, TCombinedResult>(GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch> other, Func<TResult, TOtherResult, TCombinedResult> selector) |
Returns a regular expression that only matches if the subarray matched by this regular expression also
contains a match for the specified other regular expression when matching backwards, and if so, combines the
result objects associated with both matches using a specified selector. | | Generex<T, TResult> | |
Matches this regular expression atomically (without backtracking into it) (cf. (?>...) in
traditional regular expression syntax). | | Generex<T, TOtherResult> | |
Returns a regular expression that casts the result object of this regular expression to a different type. | | Generex<T, TResult> | | Executes the specified code every time the regular expression engine encounters this expression. | | Generex<T, TResult> | DoRaw(Action<TResult> code) | | bool | IsMatch(T[] input, int startAt = 0) |
Determines whether the given input sequence contains a match for this regular expression, optionally starting
the search at a specified index. | | bool | |
Determines whether the given input sequence matches this regular expression at a specific index. | | bool | IsMatchExact(T[] input, int mustStartAt = 0, int? mustEndAt = null) |
Determines whether the given input sequence matches this regular expression exactly. | | bool | |
Determines whether the given input sequence contains a match for this regular expression that ends before the
specified maximum index. | | bool | |
Determines whether the given input sequence matches this regular expression up to a specific index. | | Generex<T, TResult> | |
Turns the current regular expression into a zero-width positive look-ahead assertion (cf. (?=...) in
traditional regular expression syntax). | | Generex<T, TResult> | |
Turns the current regular expression into a zero-width negative look-ahead assertion (cf. (?!...) in
traditional regular expression syntax), which returns the specified default result in case of a match. | | Generex<T, TResult> | |
Turns the current regular expression into a zero-width positive look-behind assertion (cf. (?<=...)
in traditional regular expression syntax). | | Generex<T, TResult> | |
Turns the current regular expression into a zero-width negative look-behind assertion (cf. (?<!...)
in traditional regular expression syntax), which returns the specified default result in case of a match. | | GenerexMatch<T, TResult> | Match(T[] input, int startAt = 0) |
Determines whether the given input sequence matches this regular expression, and if so, returns information
about the first match. | | IEnumerable<GenerexMatch<T, TResult>> | Matches(T[] input, int startAt = 0) |
Returns a sequence of non-overlapping regular expression matches, optionally starting the search at the
specified index. | | IEnumerable<GenerexMatch<T, TResult>> | |
Returns a sequence of non-overlapping regular expression matches going backwards (starting at the end of the
specified input sequence), optionally starting the search at the specified index. | | GenerexMatch<T, TResult> | MatchExact(T[] input, int mustStartAt = 0, int? mustEndAt = null) |
Determines whether the given input sequence matches this regular expression exactly, and if so, returns
information about the match. | | GenerexMatch<T, TResult> | |
Determines whether the given input sequence matches this regular expression, and if so, returns information
about the first match found by matching the regular expression backwards (starting from the end of the input
sequence). | | Generex<T, TOtherResult> | |
Returns a regular expression that matches only if the result object of this regular expression is of the
specified type. | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression zero times or once. Zero times is
prioritised (cf. ?? in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression zero times or once. Once is prioritised (cf.
? in traditional regular expression syntax). | | Generex<T, TResult> | |
Returns a regular expression that matches either this regular expression or a single element that satisfies
the specified predicate (cf. | in traditional regular expression syntax). | | Generex<T, TResult> | |
Returns a regular expression that matches either this regular expression or a single element (cf. | in
traditional regular expression syntax). | | Generex<T, TResult> | |
Returns a regular expression that matches either this regular expression or the specified sequence of elements
(cf. | in traditional regular expression syntax). | | Generex<T, TResult> | | | Generex<T, TResult> | Or(T element, Func<GenerexMatch<T>, TResult> selector, IEqualityComparer<T> comparer) |
Returns a regular expression that matches either this regular expression or a single element using the
specified equality comparer (cf. | in traditional regular expression syntax). | | Generex<T, TResult> | Or(Func<GenerexMatch<T>, TResult> selector, IEqualityComparer<T> comparer, IEnumerable<T> elements) |
Returns a regular expression that matches either this regular expression or the specified sequence of elements
using the specified equality comparer (cf. | in traditional regular expression syntax). | | Generex<T, TResult> | Or(Func<GenerexMatch<T>, TResult> selector, IEqualityComparer<T> comparer, params T[] elements) | | Generex<T, TResult> | |
Returns a regular expression that matches either this regular expression or the specified other regular
expression (cf. | in traditional regular expression syntax). | | Generex<T, TOtherResult> | |
Processes each match of this regular expression by running it through a provided selector. | | Generex<T, TOtherResult> | ProcessRaw<TOtherResult>(Func<TResult, TOtherResult> selector) |
Processes each match of this regular expression by running each result through a provided selector. | | TResult | |
Determines whether the given input sequence matches this regular expression, and if so, returns the result of
the first match. | | IEnumerable<TResult> | |
Returns a sequence of non-overlapping regular expression matches, optionally starting the search at the
specified index. | | IEnumerable<TResult> | |
Returns a sequence of non-overlapping regular expression matches going backwards, optionally starting the
search at the specified index. | | TResult | RawMatchExact(T[] input, int mustStartAt = 0, int? mustEndAt = null) |
Determines whether the given input sequence matches this regular expression exactly, and if so, returns the
match. | | TResult | |
Determines whether the given input sequence matches this regular expression, and if so, returns the result of
the first match found by matching the regular expression backwards. | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression zero or more times. Fewer times are
prioritised (cf. *? in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression the specified number of times or more. Fewer
times are prioritised (cf. {min,}? in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression any number of times within specified
boundaries. Fewer times are prioritised (cf. {min,max}? in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression zero or more times. More times are
prioritised (cf. * in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression the specified number of times or more. More
times are prioritised (cf. {min,} in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression any number of times within specified
boundaries. More times are prioritised (cf. {min,max} in traditional regular expression syntax). | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression one or more times, interspersed with a
separator. Fewer times are prioritised. | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression one or more times, interspersed with a
separator. More times are prioritised. | | T[] | Replace(T[] input, Func<GenerexMatch<T, TResult>, IEnumerable<T>> replaceWith, int startAt = 0, int? maxReplace = null) |
Replaces each match of this regular expression within the given input sequence with the replacement sequence
returned by the given selector. | | T[] | Replace(T[] input, IEnumerable<T> replaceWith, int startAt = 0, int? maxReplace = null) |
Replaces each match of this regular expression within the given input sequence with a replacement sequence. | | T[] | ReplaceRaw(T[] input, Func<TResult, IEnumerable<T>> replaceWithRaw, int startAt = 0, int? maxReplace = null) |
Replaces each match of this regular expression within the given input sequence with the replacement sequence
returned by the given selector. | | T[] | |
Replaces each match of this regular expression within the given input sequence, matched from the end
backwards, with the replacement sequence returned by the given selector. | | T[] | ReplaceReverse(T[] input, IEnumerable<T> replaceWith, int? endAt = null, int? maxReplace = null) |
Replaces each match of this regular expression within the given input sequence, matched from the end
backwards, with a replacement sequence. | | T[] | ReplaceReverseRaw(T[] input, Func<TResult, IEnumerable<T>> replaceWithRaw, int? endAt = null, int? maxReplace = null) |
Replaces each match of this regular expression within the given input sequence, matched from the end
backwards, with the replacement sequence returned by the given selector. | | Generex<T, TResult> | Then(params T[] elements) |
Returns a regular expression that matches this regular expression followed by the specified sequence of
elements. | | Generex<T, TResult> | Then(IEnumerable<T> elements) | | Generex<T, TResult> | Then(Predicate<T> predicate) |
Returns a regular expression that matches this regular expression followed by a single element that satisfies
the specified predicate. | | Generex<T, TResult> | Then(IEqualityComparer<T> comparer, params T[] elements) |
Returns a regular expression that matches this regular expression followed by the specified sequence of
elements, using the specified equality comparer. | | Generex<T, TResult> | Then(IEqualityComparer<T> comparer, IEnumerable<T> elements) | | Generex<T, TCombined> | |
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. | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the match, then matches the new regular expression
and retains the result object from the first match. | | Generex<T, TResult> | Then<TOtherGenerex, TOtherGenerexMatch>(params GenerexNoResultBase<T, TOtherGenerex, TOtherGenerexMatch>[] other) |
Returns a regular expression that matches a consecutive sequence of regular expressions, beginning with this
one, followed by the specified ones. | | Generex<T, TResult> | Then<TOtherGenerex, TOtherGenerexMatch>(IEnumerable<GenerexNoResultBase<T, TOtherGenerex, TOtherGenerexMatch>> other) | | Generex<T, TCombined> | |
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. | | TOtherGenerex | Then<TOtherGenerex, TOtherMatch, TOtherGenerexMatch>(Func<GenerexMatch<T, TResult>, GenerexBase<T, TOtherMatch, TOtherGenerex, TOtherGenerexMatch>> selector) |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the match, and then matches the new regular
expression. | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then attempts to match the specified
sequence of elements and throws an exception if that sequence fails to match. | | Generex<T, TResult> | | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then attempts to match a single element
that satisfies the specified predicate and throws an exception if that predicate fails to match. | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then attempts to match a single element and
throws an exception if that element fails to match. | | Generex<T, TResult> | ThenExpect(Func<GenerexMatch<T, TResult>, Exception> exceptionGenerator, IEqualityComparer<T> comparer, params T[] elements) |
Returns a regular expression that matches this regular expression, then attempts to match the specified
sequence of elements using the specified comparer and throws an exception if that sequence fails to match. | | Generex<T, TResult> | ThenExpect(Func<GenerexMatch<T, TResult>, Exception> exceptionGenerator, IEqualityComparer<T> comparer, IEnumerable<T> elements) | | Generex<T, TCombined> | |
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 current result object and the second match. | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the match; then attempts to match the new regular
expression and throws an exception if that regular expression fails to match. This regular expression’s result
object remains unaltered. | | Generex<T, TResult> | ThenExpect<TOtherGenerex, TOtherGenerexMatch>(Func<GenerexMatch<T, TResult>, Exception> exceptionGenerator, params GenerexNoResultBase<T, TOtherGenerex, TOtherGenerexMatch>[] expectation) |
Returns a regular expression that matches this regular expression, then attempts to match the specified
sequence of other regular expressions and throws an exception if the sequence fails to match. | | Generex<T, TResult> | | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then attempts to match the specified other
regular expression and throws an exception if the sequence fails to match. | | Generex<T, TCombined> | |
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 current result object and the second match. | | TOtherGenerex | ThenExpect<TOtherGenerex, TOtherMatch, TOtherGenerexMatch>(Func<GenerexMatch<T, TResult>, GenerexBase<T, TOtherMatch, TOtherGenerex, TOtherGenerexMatch>> selector, Func<GenerexMatch<T, TResult>, Exception> exceptionGenerator) |
Returns a regular expression that matches this regular expression, uses a specified selector to create a new regular expression from the match, attempts to match the new regular
expression and throws an exception if the new regular expression fails to match. | | Generex<T, TResult> | ThenExpectRaw<TOtherGenerex, TOtherGenerexMatch>(Func<TResult, GenerexNoResultBase<T, TOtherGenerex, TOtherGenerexMatch>> selector, Func<TResult, Exception> exceptionGenerator) |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the result object; then attempts to match the new
regular expression and throws an exception if that regular expression fails to match. This regular
expression’s result object remains unaltered. | | Generex<T, TCombined> | ThenExpectRaw<TOther, TCombined>(Generex<T, TOther> expectation, Func<TResult, TOther, TCombined> selector, Func<GenerexMatch<T, TResult>, Exception> exceptionGenerator) |
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. | | TOtherGenerex | ThenExpectRaw<TOtherGenerex, TOtherResult, TOtherGenerexMatch>(Func<TResult, GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch>> selector, Func<TResult, Exception> exceptionGenerator) |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the result object; then attempts to match the new
regular expression and throws an exception if that regular expression fails to match. The new regular
expression’s result object replaces the current one’s. | | Generex<T, TResult> | |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the result of the match, and then matches the new
regular expression. This regular expression’s result object remains unaltered. | | Generex<T, TCombined> | ThenRaw<TOther, TCombined>(Generex<T, TOther> other, Func<TResult, TOther, TCombined> selector) |
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. | | TOtherGenerex | ThenRaw<TOtherGenerex, TOtherResult, TOtherGenerexMatch>(Func<TResult, GenerexWithResultBase<T, TOtherResult, TOtherGenerex, TOtherGenerexMatch>> selector) |
Returns a regular expression that matches this regular expression, then uses a specified selector to create a new regular expression from the result of the match, and then matches the new
regular expression. This regular expression’s result object is replaced with the new one’s. | | Generex<T, TResult> | |
Throws an exception generated by the specified code when the regular expression engine encounters this
expression. | | Generex<T, IEnumerable<TResult>> | |
Returns a regular expression that matches this regular expression the specified number of times (cf.
{times} in traditional regular expression syntax). | | Generex<T, TResult> | | Restricts matches of this regular expression to those that satisfy the specified predicate. | | Generex<T, TResult> | |
Static methods| Generex<T, TResult> | Ors(params Generex<T, TResult>[] other) |
Returns a regular expression that matches any of the specified regular expressions (cf. | in
traditional regular expression syntax). | | Generex<T, TResult> | | | Generex<T, TResult> | |
Generates a recursive regular expression, i.e. one that can contain itself, allowing the matching of
arbitrarily nested expressions. |
Operators| Generex<T, TResult> | |
Returns a regular expression that matches the first regular expression followed by the second and retains the
result object generated by each match of the first regular expression. | | Generex<T, TResult> | |
Returns a regular expression that matches the first regular expression followed by the second and retains the
result object generated by each match of the second regular expression. | | Generex<T, TResult> | |
Returns a regular expression that matches the specified regular expression (first operand) followed by the
specified element (second operand). | | Generex<T, TResult> | |
Returns a regular expression that matches the specified element (first operand) followed by the specified
regular expression (second operand). | | Generex<T, TResult> | |
Returns a regular expression that matches the specified regular expression (first operand) followed by a
single element that satisfies the specified predicate (second operand). | | Generex<T, TResult> | |
Returns a regular expression that matches a single element that satisfies the specified predicate (first
operand) followed by the specified regular expression (second operand). | | Generex<T, TResult> | |
Returns a regular expression that matches either one of the specified regular expressions (cf. | in
traditional regular expression syntax). |
Static properties| Generex<T, TResult> | |
Returns a regular expression that never matches (cf. (?!) in traditional regular expression syntax). |
|