// <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>ILCodeVersionNode</c> type.</summary>
partial class ILCodeVersionNode : global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData
{
    private static readonly string[] _typeNames = new[] { "ILCodeVersionNode" };

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

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

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

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

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

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

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

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

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

    public TargetPointer Address { get; }

    private readonly Target _target;

    private readonly LayoutSet _layouts;

    partial void OnInit(Target target, TargetPointer address);

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

        OnInit(target, address);
    }

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

    private TargetNUInt _VersionId__value = default!;
    private bool _VersionId__read;
    [DataDescriptorDependency("VersionId", "nuint")]
    public partial TargetNUInt VersionId
    {
        get
        {
            if (!_VersionId__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "VersionId");
                _VersionId__value = _target.ReadNUIntField(b, t, n);
                _VersionId__read = true;
            }
            return _VersionId__value;
        }
    }

    private TargetPointer _Next__value = default!;
    private bool _Next__read;
    [DataDescriptorDependency("Next", "pointer")]
    public partial TargetPointer Next
    {
        get
        {
            if (!_Next__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "Next");
                _Next__value = _target.ReadPointerField(b, t, n);
                _Next__read = true;
            }
            return _Next__value;
        }
    }

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

    private TargetPointer _ILAddress__value = default!;
    private bool _ILAddress__read;
    [DataDescriptorDependency("ILAddress", "pointer")]
    public partial TargetPointer ILAddress
    {
        get
        {
            if (!_ILAddress__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "ILAddress");
                _ILAddress__value = _target.ReadPointerField(b, t, n);
                _ILAddress__read = true;
            }
            return _ILAddress__value;
        }
    }

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

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

    private TargetNUInt _EnCVersion__value = default!;
    private bool _EnCVersion__read;
    [DataDescriptorDependency("EnCVersion", "nuint")]
    public partial TargetNUInt EnCVersion
    {
        get
        {
            if (!_EnCVersion__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "EnCVersion");
                _EnCVersion__value = _target.ReadNUIntField(b, t, n);
                _EnCVersion__read = true;
            }
            return _EnCVersion__value;
        }
    }

    private Data.InstrumentedILOffsetMapping _InstrumentedILMap__value = default!;
    private bool _InstrumentedILMap__read;
    [DataDescriptorDependency("InstrumentedILMap", "InstrumentedILOffsetMapping")]
    public partial Data.InstrumentedILOffsetMapping InstrumentedILMap
    {
        get
        {
            if (!_InstrumentedILMap__read)
            {
                _layouts.Select(Address, out var t, out var b, out var n, "InstrumentedILMap");
                _InstrumentedILMap__value = _target.ReadDataField<Data.InstrumentedILOffsetMapping>(b, t, n);
                _InstrumentedILMap__read = true;
            }
            return _InstrumentedILMap__value;
        }
    }

    [DataDescriptorDependency("VersionId", "nuint")]
    [DataDescriptorDependency("Next", "pointer")]
    [DataDescriptorDependency("RejitState", "uint32")]
    [DataDescriptorDependency("ILAddress", "pointer")]
    [DataDescriptorDependency("Deoptimized", "uint32")]
    [DataDescriptorDependency("Source", "uint32")]
    [DataDescriptorDependency("EnCVersion", "nuint")]
    [DataDescriptorDependency("InstrumentedILMap", "InstrumentedILOffsetMapping")]
    void global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData.EnsureAllFieldsRead()
    {
        _ = VersionId;
        _ = Next;
        _ = RejitState;
        _ = ILAddress;
        _ = Deoptimized;
        _ = Source;
        _ = EnCVersion;
        _ = InstrumentedILMap;
    }

}