GFramework/GFramework.SourceGenerators.Tests/Config/snapshots/SchemaConfigGenerator/MonsterTable.g.txt

// <auto-generated />
#nullable enable

namespace GFramework.Game.Config.Generated;

/// <summary>
///     Auto-generated table wrapper for schema file 'monster.schema.json'.
///     The wrapper keeps generated call sites strongly typed while delegating actual storage to the runtime config table implementation.
/// </summary>
public sealed partial class MonsterTable : global::GFramework.Game.Abstractions.Config.IConfigTable<int, MonsterConfig>
{
    private readonly global::GFramework.Game.Abstractions.Config.IConfigTable<int, MonsterConfig> _inner;
    private readonly global::System.Lazy<global::System.Collections.Generic.IReadOnlyDictionary<string, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>>> _nameIndex;

    /// <summary>
    ///     Creates a generated table wrapper around the runtime config table instance.
    /// </summary>
    /// <param name="inner">The runtime config table instance.</param>
    public MonsterTable(global::GFramework.Game.Abstractions.Config.IConfigTable<int, MonsterConfig> inner)
    {
        _inner = inner ?? throw new global::System.ArgumentNullException(nameof(inner));
        _nameIndex = new global::System.Lazy<global::System.Collections.Generic.IReadOnlyDictionary<string, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>>>(
            BuildNameIndex,
            global::System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
    }

    /// <inheritdoc />
    public global::System.Type KeyType => _inner.KeyType;

    /// <inheritdoc />
    public global::System.Type ValueType => _inner.ValueType;

    /// <inheritdoc />
    public int Count => _inner.Count;

    /// <inheritdoc />
    public MonsterConfig Get(int key)
    {
        return _inner.Get(key);
    }

    /// <inheritdoc />
    public bool TryGet(int key, out MonsterConfig? value)
    {
        return _inner.TryGet(key, out value);
    }

    /// <inheritdoc />
    public bool ContainsKey(int key)
    {
        return _inner.ContainsKey(key);
    }

    /// <inheritdoc />
    public global::System.Collections.Generic.IReadOnlyCollection<MonsterConfig> All()
    {
        return _inner.All();
    }

    /// <summary>
    ///     Builds the exact-match lookup index declared for property 'name'.
    /// </summary>
    /// <returns>A read-only lookup index keyed by <c>Name</c>.</returns>
    private global::System.Collections.Generic.IReadOnlyDictionary<string, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>> BuildNameIndex()
    {
        return BuildLookupIndex(static config => config.Name);
    }

    /// <summary>
    ///     Materializes a read-only exact-match lookup index from the current table snapshot.
    /// </summary>
    /// <typeparam name="TProperty">Indexed property type.</typeparam>
    /// <param name="keySelector">Selects the indexed property from one config entry.</param>
    /// <returns>A read-only dictionary whose values preserve snapshot iteration order.</returns>
    /// <remarks>
    ///     The generated index skips runtime null keys even though <typeparamref name="TProperty"/> is constrained to <c>notnull</c>. Malformed YAML payloads can still deserialize missing indexed values to <see langword="null" />, and throwing from this lazy path would permanently poison the cached index for the current table wrapper instance.
    /// </remarks>
    private global::System.Collections.Generic.IReadOnlyDictionary<TProperty, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>> BuildLookupIndex<TProperty>(
        global::System.Func<MonsterConfig, TProperty> keySelector)
        where TProperty : notnull
    {
        var buckets = new global::System.Collections.Generic.Dictionary<TProperty, global::System.Collections.Generic.List<MonsterConfig>>();

        // Capture the current table snapshot once so indexed lookups stay deterministic for this wrapper instance.
        foreach (var candidate in All())
        {
            var key = keySelector(candidate);
            if (key is null)
            {
                // Skip malformed runtime data so the lazy lookup cache remains usable for valid keys.
                // Throwing here would permanently poison the cached index for this wrapper instance.
                continue;
            }

            if (!buckets.TryGetValue(key, out var matches))
            {
                matches = new global::System.Collections.Generic.List<MonsterConfig>();
                buckets.Add(key, matches);
            }

            matches.Add(candidate);
        }

        var materialized = new global::System.Collections.Generic.Dictionary<TProperty, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>>(buckets.Count, buckets.Comparer);
        foreach (var pair in buckets)
        {
            materialized.Add(pair.Key, pair.Value.AsReadOnly());
        }

        return new global::System.Collections.ObjectModel.ReadOnlyDictionary<TProperty, global::System.Collections.Generic.IReadOnlyList<MonsterConfig>>(materialized);
    }

    /// <summary>
    ///     Finds all config entries whose property 'name' equals the supplied value.
    /// </summary>
    /// <param name="value">The property value to match.</param>
    /// <returns>A read-only snapshot containing every matching config entry.</returns>
    /// <remarks>
    ///     This property declares <c>x-gframework-index</c>, so the generated helper resolves matches through a lazily materialized read-only lookup index built from the current table snapshot.
    /// </remarks>
    public global::System.Collections.Generic.IReadOnlyList<MonsterConfig> FindByName(string value)
    {
        if (value is null)
        {
            return global::System.Array.Empty<MonsterConfig>();
        }

        if (_nameIndex.Value.TryGetValue(value, out var matches))
        {
            return matches;
        }

        return global::System.Array.Empty<MonsterConfig>();
    }

    /// <summary>
    ///     Tries to find the first config entry whose property 'name' equals the supplied value.
    /// </summary>
    /// <param name="value">The property value to match.</param>
    /// <param name="result">The first matching config entry when lookup succeeds; otherwise <see langword="null" />.</param>
    /// <returns><see langword="true" /> when a matching config entry is found; otherwise <see langword="false" />.</returns>
    /// <remarks>
    ///     This property declares <c>x-gframework-index</c>, so the generated helper returns the first element from the lazily materialized exact-match bucket.
    /// </remarks>
    public bool TryFindFirstByName(string value, out MonsterConfig? result)
    {
        if (value is null)
        {
            result = null;
            return false;
        }

        if (_nameIndex.Value.TryGetValue(value, out var matches) && matches.Count > 0)
        {
            result = matches[0];
            return true;
        }

        result = null;
        return false;
    }

    /// <summary>
    ///     Finds all config entries whose property 'hp' equals the supplied value.
    /// </summary>
    /// <param name="value">The property value to match.</param>
    /// <returns>A read-only snapshot containing every matching config entry.</returns>
    /// <remarks>
    ///     The generated helper performs a deterministic linear scan over <see cref="All"/> so it stays compatible with runtime hot reload and does not require secondary index infrastructure.
    /// </remarks>
    public global::System.Collections.Generic.IReadOnlyList<MonsterConfig> FindByHp(int? value)
    {
        var matches = new global::System.Collections.Generic.List<MonsterConfig>();

        // Scan the current table snapshot on demand so generated helpers stay aligned with reloadable runtime data.
        foreach (var candidate in All())
        {
            if (global::System.Collections.Generic.EqualityComparer<int?>.Default.Equals(candidate.Hp, value))
            {
                matches.Add(candidate);
            }
        }

        return matches.Count == 0 ? global::System.Array.Empty<MonsterConfig>() : matches.AsReadOnly();
    }

    /// <summary>
    ///     Tries to find the first config entry whose property 'hp' equals the supplied value.
    /// </summary>
    /// <param name="value">The property value to match.</param>
    /// <param name="result">The first matching config entry when lookup succeeds; otherwise <see langword="null" />.</param>
    /// <returns><see langword="true" /> when a matching config entry is found; otherwise <see langword="false" />.</returns>
    /// <remarks>
    ///     The generated helper walks the same snapshot exposed by <see cref="All"/> and returns the first match in iteration order.
    /// </remarks>
    public bool TryFindFirstByHp(int? value, out MonsterConfig? result)
    {
        // Keep the search path allocation-free for the first-match case by exiting as soon as one entry matches.
        foreach (var candidate in All())
        {
            if (global::System.Collections.Generic.EqualityComparer<int?>.Default.Equals(candidate.Hp, value))
            {
                result = candidate;
                return true;
            }
        }

        result = null;
        return false;
    }
}