// <auto-generated/>
#nullable enable

using Microsoft.Diagnostics.DataContractReader;
using Microsoft.Diagnostics.DataContractReader.Contracts;
using Microsoft.Diagnostics.DataContractReader.Generated;

namespace Microsoft.Diagnostics.DataContractReader.Data;

/// <summary>Wraps the <c>CMiniMdRW</c> type.</summary>
partial class CMiniMdRW : global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData
{
    private static readonly string[] _typeNames = new[] { "CMiniMdRW" };

    [UsesDataDescriptorTypeSize]
    public static uint GetSize(Target target)
        => checked((uint)LayoutSet.Resolve(target, _typeNames).InstanceSize);

    [DataDescriptorDependency("Schema", "pointer")]
    public static int GetSchemaOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "Schema");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("TableCount", "uint32")]
    public static int GetTableCountOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "TableCount");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("All4ByteColumns", "uint32")]
    public static int GetAll4ByteColumnsOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "All4ByteColumns");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("Tables", "pointer")]
    public static int GetTablesOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "Tables");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("StringHeap", "pointer")]
    public static int GetStringHeapOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "StringHeap");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("BlobHeap", "pointer")]
    public static int GetBlobHeapOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "BlobHeap");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("UserStringHeap", "pointer")]
    public static int GetUserStringHeapOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "UserStringHeap");
        return type.Fields[name].Offset;
    }

    [DataDescriptorDependency("GuidHeap", "pointer")]
    public static int GetGuidHeapOffset(Target target)
    {
        LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
        layouts.Select(default, out var type, out _, out var name, "GuidHeap");
        return type.Fields[name].Offset;
    }

    public TargetPointer Address { get; }

    private readonly Target _target;

    private readonly LayoutSet _layouts;

    public CMiniMdRW(Target target, TargetPointer address)
    {
        Address = address;
        _target = target;
        _layouts = LayoutSet.Resolve(target, _typeNames);
    }

    static CMiniMdRW IData<CMiniMdRW>.Create(Target target, TargetPointer address)
        => new CMiniMdRW(target, address);

    private TargetPointer _Schema__value = default!;
    private bool _Schema__read;
    [DataDescriptorDependency("Schema", "pointer")]
    public partial TargetPointer Schema
    {
        get
        {
            if (!_Schema__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "Schema");
                _Schema__value = b + (ulong)t.Fields[n].Offset;
                _Schema__read = true;
            }
            return _Schema__value;
        }
    }

    private uint _TableCount__value = default!;
    private bool _TableCount__read;
    [DataDescriptorDependency("TableCount", "uint32")]
    public partial uint TableCount
    {
        get
        {
            if (!_TableCount__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "TableCount");
                _TableCount__value = _target.ReadField<uint>(b, t, n);
                _TableCount__read = true;
            }
            return _TableCount__value;
        }
    }

    private bool _All4ByteColumns__value = default!;
    private bool _All4ByteColumns__read;
    [DataDescriptorDependency("All4ByteColumns", "uint32")]
    public partial bool All4ByteColumns
    {
        get
        {
            if (!_All4ByteColumns__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "All4ByteColumns");
                _All4ByteColumns__value = _target.ReadField<uint>(b, t, n) != 0;
                _All4ByteColumns__read = true;
            }
            return _All4ByteColumns__value;
        }
    }

    private TargetPointer _Tables__value = default!;
    private bool _Tables__read;
    [DataDescriptorDependency("Tables", "pointer")]
    public partial TargetPointer Tables
    {
        get
        {
            if (!_Tables__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "Tables");
                _Tables__value = b + (ulong)t.Fields[n].Offset;
                _Tables__read = true;
            }
            return _Tables__value;
        }
    }

    private TargetPointer _StringHeap__value = default!;
    private bool _StringHeap__read;
    [DataDescriptorDependency("StringHeap", "pointer")]
    public partial TargetPointer StringHeap
    {
        get
        {
            if (!_StringHeap__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "StringHeap");
                _StringHeap__value = b + (ulong)t.Fields[n].Offset;
                _StringHeap__read = true;
            }
            return _StringHeap__value;
        }
    }

    private TargetPointer _BlobHeap__value = default!;
    private bool _BlobHeap__read;
    [DataDescriptorDependency("BlobHeap", "pointer")]
    public partial TargetPointer BlobHeap
    {
        get
        {
            if (!_BlobHeap__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "BlobHeap");
                _BlobHeap__value = b + (ulong)t.Fields[n].Offset;
                _BlobHeap__read = true;
            }
            return _BlobHeap__value;
        }
    }

    private TargetPointer _UserStringHeap__value = default!;
    private bool _UserStringHeap__read;
    [DataDescriptorDependency("UserStringHeap", "pointer")]
    public partial TargetPointer UserStringHeap
    {
        get
        {
            if (!_UserStringHeap__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "UserStringHeap");
                _UserStringHeap__value = b + (ulong)t.Fields[n].Offset;
                _UserStringHeap__read = true;
            }
            return _UserStringHeap__value;
        }
    }

    private TargetPointer _GuidHeap__value = default!;
    private bool _GuidHeap__read;
    [DataDescriptorDependency("GuidHeap", "pointer")]
    public partial TargetPointer GuidHeap
    {
        get
        {
            if (!_GuidHeap__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "GuidHeap");
                _GuidHeap__value = b + (ulong)t.Fields[n].Offset;
                _GuidHeap__read = true;
            }
            return _GuidHeap__value;
        }
    }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "Generated lazy initializer; may read instance members.")]
    private partial System.Collections.Immutable.ImmutableArray<global::Microsoft.Diagnostics.DataContractReader.TargetPointer> InitTableSegments(Target target, TargetPointer address);
    private System.Collections.Immutable.ImmutableArray<global::Microsoft.Diagnostics.DataContractReader.TargetPointer> _TableSegments__value = default!;
    private bool _TableSegments__read;
    public partial System.Collections.Immutable.ImmutableArray<global::Microsoft.Diagnostics.DataContractReader.TargetPointer> TableSegments
    {
        get
        {
            if (!_TableSegments__read)
            {
                _TableSegments__value = InitTableSegments(_target, Address);
                _TableSegments__read = true;
            }
            return _TableSegments__value;
        }
    }

    void global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData.EnsureAllFieldsRead()
    {
        _ = Schema;
        _ = TableCount;
        _ = All4ByteColumns;
        _ = Tables;
        _ = StringHeap;
        _ = BlobHeap;
        _ = UserStringHeap;
        _ = GuidHeap;
        _ = TableSegments;
    }

}