Subjects.cs

using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using RegexProof.Enums;

namespace RegexProof;

/// <summary>
/// Все измеряемые методы: проверка строки через new Regex, RegexOptions.Compiled,
/// [GeneratedRegex], статический Regex.IsMatch и RegexOptions.NonBacktracking,
/// плюс string.Contains как нижняя граница. Отдельно - методы, которые собирают
/// сам объект, и остальные способы получить результат, кроме IsMatch.
/// Каждый в своём методе с NoInlining, иначе его не найти в дизассемблированном
/// коде.
///
/// Исходник, который пишет генератор, лежит в папке Generated: его сохранение
/// включено в RegexProof.csproj свойством EmitCompilerGeneratedFiles.
///
/// Документация генератора:
///   https://learn.microsoft.com/dotnet/standard/base-types/regular-expression-source-generators
/// Разбор реализаций регулярных выражений в .NET, Stephen Toub:
///   https://devblogs.microsoft.com/dotnet/regular-expression-improvements-in-dotnet-7/
/// </summary>
public static partial class Subjects
{
    // Точная подстрока. Регулярное выражение здесь не нужно, и рядом
    // замеряется string.Contains, чтобы это было видно.
    public const string LiteralPattern = "orders/export";

    // Разбор адреса электронной почты: наборы символов, повторы, экранирование.
    public const string EmailPattern = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}";

    // Повторы и варианты. На строке, где символы из его набора стоят на каждом
    // шагу, разбор перебирает много вариантов - это самый тяжёлый из трёх
    // паттернов.
    public const string HeavyPattern = @"(?:[a-z]+\d+){2,}(?:foo|bar|baz)+end";

    // Известный пример, которым принято показывать опасность регулярных
    // выражений. Вложенный повтор одного и того же символа: в теории число
    // вариантов разбора удваивается с каждым лишним символом.
    // Проверяется в RegexBacktrackBench.
    public const string NestedPattern = "^(?:a+)+$";

    [GeneratedRegex(LiteralPattern)]
    public static partial Regex LiteralGenerated();

    [GeneratedRegex(EmailPattern)]
    public static partial Regex EmailGenerated();

    [GeneratedRegex(HeavyPattern)]
    public static partial Regex HeavyGenerated();

    [GeneratedRegex(NestedPattern)]
    public static partial Regex NestedGenerated();

    /// <summary>
    /// Возвращает готовый экземпляр от генератора. Отдельный метод нужен,
    /// чтобы замерялось обращение к генератору, а не выбор ветки в бенчмарке.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static Regex GetGenerated(PatternKind kind) => kind switch
    {
        PatternKind.Literal => LiteralGenerated(),
        PatternKind.Email => EmailGenerated(),
        _ => HeavyGenerated(),
    };

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchInterpreted(Regex regex, string input) => regex.IsMatch(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchCompiled(Regex regex, string input) => regex.IsMatch(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchGenerated(Regex regex, string input) => regex.IsMatch(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchNonBacktracking(Regex regex, string input) => regex.IsMatch(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchStatic(string pattern, string input) => Regex.IsMatch(input, pattern);

    // Та же статическая перегрузка, но с RegexOptions.Compiled. Пока паттерн
    // лежит в кэше, объект строится один раз; после вытеснения - на каждый вызов.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchStaticCompiled(string pattern, string input) => Regex.IsMatch(input, pattern, RegexOptions.Compiled);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchContains(string needle, string input) => input.Contains(needle, StringComparison.Ordinal);

    // Дальше - остальные способы получить результат, кроме IsMatch.
    // IsMatch и Match останавливаются на первом совпадении, остальные проходят
    // строку до конца.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool MatchFirst(Regex regex, string input) => regex.Match(input).Success;

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int MatchCount(Regex regex, string input) => regex.Count(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int MatchCollection(Regex regex, string input)
    {
        int total = 0;
        foreach (Match match in regex.Matches(input))
        {
            total += match.Length;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int MatchEnumerate(Regex regex, string input)
    {
        int total = 0;
        foreach (ValueMatch match in regex.EnumerateMatches(input))
        {
            total += match.Length;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static string MatchReplace(Regex regex, string input) => regex.Replace(input, "*");

    // Два контроля к предыдущим методам: перегрузка Count со span вместо строки
    // и обход без обращения к длине совпадения. Показывают, на что приходится
    // разница между Count и EnumerateMatches.

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int MatchCountSpan(Regex regex, string input) => regex.Count(input.AsSpan());

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int MatchEnumerateCount(Regex regex, string input)
    {
        int total = 0;
        foreach (ValueMatch _ in regex.EnumerateMatches(input))
        {
            total++;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static Regex CreateInterpreted(string pattern) => new(pattern);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static Regex CreateCompiled(string pattern) => new(pattern, RegexOptions.Compiled);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static Regex CreateNonBacktracking(string pattern) => new(pattern, RegexOptions.NonBacktracking);

    // Создание вместе с первой проверкой. Отделяет работу конструктора от той,
    // что приходится на первое обращение.
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool CreateCompiledAndMatch(string pattern, string input) =>
        new Regex(pattern, RegexOptions.Compiled).IsMatch(input);

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static bool CreateInterpretedAndMatch(string pattern, string input) =>
        new Regex(pattern).IsMatch(input);
}