// <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>LoaderAllocator</c> type.</summary>
partial class LoaderAllocator : global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData
{
private static readonly string[] _typeNames = new[] { "LoaderAllocator" };
[UsesDataDescriptorTypeSize]
public static uint GetSize(Target target)
=> checked((uint)LayoutSet.Resolve(target, _typeNames).InstanceSize);
[DataDescriptorDependency("ReferenceCount", "uint32")]
public static int GetReferenceCountOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "ReferenceCount");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("HighFrequencyHeap", "pointer")]
public static int GetHighFrequencyHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "HighFrequencyHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("LowFrequencyHeap", "pointer")]
public static int GetLowFrequencyHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "LowFrequencyHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("StaticsHeap", "pointer")]
public static int GetStaticsHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "StaticsHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("StubHeap", "pointer")]
public static int GetStubHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "StubHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("ExecutableHeap", "pointer")]
public static int GetExecutableHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "ExecutableHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("FixupPrecodeHeap", "pointer")]
public static int GetFixupPrecodeHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "FixupPrecodeHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("NewStubPrecodeHeap", "pointer")]
public static int GetNewStubPrecodeHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "NewStubPrecodeHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("DynamicHelpersStubHeap", "pointer")]
public static int GetDynamicHelpersStubHeapOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "DynamicHelpersStubHeap");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("VirtualCallStubManager", "pointer")]
public static int GetVirtualCallStubManagerOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "VirtualCallStubManager");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("ObjectHandle", "ObjectHandle")]
public static int GetObjectHandleOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "ObjectHandle");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("IsCollectible", "uint8")]
public static int GetIsCollectibleOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "IsCollectible");
return type.Fields[name].Offset;
}
[DataDescriptorDependency("CreationNumber", "uint64")]
public static int GetCreationNumberOffset(Target target)
{
LayoutSet layouts = LayoutSet.Resolve(target, _typeNames);
layouts.Select(default, out var type, out _, out var name, "CreationNumber");
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 LoaderAllocator(Target target, TargetPointer address)
{
Address = address;
_target = target;
_layouts = LayoutSet.Resolve(target, _typeNames);
OnInit(target, address);
}
static LoaderAllocator IData<LoaderAllocator>.Create(Target target, TargetPointer address)
=> new LoaderAllocator(target, address);
private uint _ReferenceCount__value = default!;
private bool _ReferenceCount__read;
[DataDescriptorDependency("ReferenceCount", "uint32")]
public partial uint ReferenceCount
{
get
{
if (!_ReferenceCount__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "ReferenceCount");
_ReferenceCount__value = _target.ReadField<uint>(b, t, n);
_ReferenceCount__read = true;
}
return _ReferenceCount__value;
}
}
private TargetPointer _HighFrequencyHeap__value = default!;
private bool _HighFrequencyHeap__read;
[DataDescriptorDependency("HighFrequencyHeap", "pointer")]
public partial TargetPointer HighFrequencyHeap
{
get
{
if (!_HighFrequencyHeap__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "HighFrequencyHeap");
_HighFrequencyHeap__value = _target.ReadPointerField(b, t, n);
_HighFrequencyHeap__read = true;
}
return _HighFrequencyHeap__value;
}
}
private TargetPointer _LowFrequencyHeap__value = default!;
private bool _LowFrequencyHeap__read;
[DataDescriptorDependency("LowFrequencyHeap", "pointer")]
public partial TargetPointer LowFrequencyHeap
{
get
{
if (!_LowFrequencyHeap__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "LowFrequencyHeap");
_LowFrequencyHeap__value = _target.ReadPointerField(b, t, n);
_LowFrequencyHeap__read = true;
}
return _LowFrequencyHeap__value;
}
}
private TargetPointer _StaticsHeap__value = default!;
private bool _StaticsHeap__read;
[DataDescriptorDependency("StaticsHeap", "pointer")]
public partial TargetPointer StaticsHeap
{
get
{
if (!_StaticsHeap__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "StaticsHeap");
_StaticsHeap__value = _target.ReadPointerField(b, t, n);
_StaticsHeap__read = true;
}
return _StaticsHeap__value;
}
}
private TargetPointer _StubHeap__value = default!;
private bool _StubHeap__read;
[DataDescriptorDependency("StubHeap", "pointer")]
public partial TargetPointer StubHeap
{
get
{
if (!_StubHeap__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "StubHeap");
_StubHeap__value = _target.ReadPointerField(b, t, n);
_StubHeap__read = true;
}
return _StubHeap__value;
}
}
private TargetPointer _ExecutableHeap__value = default!;
private bool _ExecutableHeap__read;
[DataDescriptorDependency("ExecutableHeap", "pointer")]
public partial TargetPointer ExecutableHeap
{
get
{
if (!_ExecutableHeap__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "ExecutableHeap");
_ExecutableHeap__value = _target.ReadPointerField(b, t, n);
_ExecutableHeap__read = true;
}
return _ExecutableHeap__value;
}
}
private TargetPointer? _FixupPrecodeHeap__value = default!;
private bool _FixupPrecodeHeap__read;
[DataDescriptorDependency("FixupPrecodeHeap", "pointer")]
public partial TargetPointer? FixupPrecodeHeap
{
get
{
if (!_FixupPrecodeHeap__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "FixupPrecodeHeap"))
_FixupPrecodeHeap__value = _target.ReadPointerField(b, t, n);
else
_FixupPrecodeHeap__value = default(TargetPointer?);
_FixupPrecodeHeap__read = true;
}
return _FixupPrecodeHeap__value;
}
}
private TargetPointer? _NewStubPrecodeHeap__value = default!;
private bool _NewStubPrecodeHeap__read;
[DataDescriptorDependency("NewStubPrecodeHeap", "pointer")]
public partial TargetPointer? NewStubPrecodeHeap
{
get
{
if (!_NewStubPrecodeHeap__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "NewStubPrecodeHeap"))
_NewStubPrecodeHeap__value = _target.ReadPointerField(b, t, n);
else
_NewStubPrecodeHeap__value = default(TargetPointer?);
_NewStubPrecodeHeap__read = true;
}
return _NewStubPrecodeHeap__value;
}
}
private TargetPointer? _DynamicHelpersStubHeap__value = default!;
private bool _DynamicHelpersStubHeap__read;
[DataDescriptorDependency("DynamicHelpersStubHeap", "pointer")]
public partial TargetPointer? DynamicHelpersStubHeap
{
get
{
if (!_DynamicHelpersStubHeap__read)
{
if (_layouts.TrySelect(Address, out var t, out var b, out var n, "DynamicHelpersStubHeap"))
_DynamicHelpersStubHeap__value = _target.ReadPointerField(b, t, n);
else
_DynamicHelpersStubHeap__value = default(TargetPointer?);
_DynamicHelpersStubHeap__read = true;
}
return _DynamicHelpersStubHeap__value;
}
}
private TargetPointer _VirtualCallStubManager__value = default!;
private bool _VirtualCallStubManager__read;
[DataDescriptorDependency("VirtualCallStubManager", "pointer")]
public partial TargetPointer VirtualCallStubManager
{
get
{
if (!_VirtualCallStubManager__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "VirtualCallStubManager");
_VirtualCallStubManager__value = _target.ReadPointerField(b, t, n);
_VirtualCallStubManager__read = true;
}
return _VirtualCallStubManager__value;
}
}
private Data.ObjectHandle _ObjectHandle__value = default!;
private bool _ObjectHandle__read;
[DataDescriptorDependency("ObjectHandle", "ObjectHandle")]
public partial Data.ObjectHandle ObjectHandle
{
get
{
if (!_ObjectHandle__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "ObjectHandle");
_ObjectHandle__value = _target.ReadDataField<Data.ObjectHandle>(b, t, n);
_ObjectHandle__read = true;
}
return _ObjectHandle__value;
}
}
private bool _IsCollectible__value = default!;
private bool _IsCollectible__read;
[DataDescriptorDependency("IsCollectible", "uint8")]
public partial bool IsCollectible
{
get
{
if (!_IsCollectible__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "IsCollectible");
_IsCollectible__value = _target.ReadField<byte>(b, t, n) != 0;
_IsCollectible__read = true;
}
return _IsCollectible__value;
}
}
private ulong _CreationNumber__value = default!;
private bool _CreationNumber__read;
[DataDescriptorDependency("CreationNumber", "uint64")]
public partial ulong CreationNumber
{
get
{
if (!_CreationNumber__read)
{
_layouts.Select(Address, out var t, out var b, out var n, "CreationNumber");
_CreationNumber__value = _target.ReadField<ulong>(b, t, n);
_CreationNumber__read = true;
}
return _CreationNumber__value;
}
}
[DataDescriptorDependency("ReferenceCount", "uint32")]
[DataDescriptorDependency("HighFrequencyHeap", "pointer")]
[DataDescriptorDependency("LowFrequencyHeap", "pointer")]
[DataDescriptorDependency("StaticsHeap", "pointer")]
[DataDescriptorDependency("StubHeap", "pointer")]
[DataDescriptorDependency("ExecutableHeap", "pointer")]
[DataDescriptorDependency("FixupPrecodeHeap", "pointer")]
[DataDescriptorDependency("NewStubPrecodeHeap", "pointer")]
[DataDescriptorDependency("DynamicHelpersStubHeap", "pointer")]
[DataDescriptorDependency("VirtualCallStubManager", "pointer")]
[DataDescriptorDependency("ObjectHandle", "ObjectHandle")]
[DataDescriptorDependency("IsCollectible", "uint8")]
[DataDescriptorDependency("CreationNumber", "uint64")]
void global::Microsoft.Diagnostics.DataContractReader.Data.IReadableData.EnsureAllFieldsRead()
{
_ = ReferenceCount;
_ = HighFrequencyHeap;
_ = LowFrequencyHeap;
_ = StaticsHeap;
_ = StubHeap;
_ = ExecutableHeap;
_ = FixupPrecodeHeap;
_ = NewStubPrecodeHeap;
_ = DynamicHelpersStubHeap;
_ = VirtualCallStubManager;
_ = ObjectHandle;
_ = IsCollectible;
_ = CreationNumber;
}
}