public MDTableModel(MDTableHeapModel parent, IMetaData metadata, TablesStream stream, MDTable table) {
Parent = parent;
MetaData = metadata;
Tables = stream;
MDTable = table;
Text = string.Format("{0:x2}: {1} (0x{2:x})", (byte)table.Table, table.Name, table.Rows);
}
public MetaDataTableNode(HexDocument doc, MDTable mdTable, IMetaData md)
: base((ulong)mdTable.StartOffset, (ulong)mdTable.EndOffset - 1) {
this.doc = doc;
this.tableInfo = mdTable.TableInfo;
this.tablesStreamVM = MetaDataTableVM.Create(this, doc, StartOffset, mdTable);
this.tablesStreamVM.FindMetaDataTable = FindMetaDataTable;
this.tablesStreamVM.InitializeHeapOffsets((ulong)md.StringsStream.StartOffset, (ulong)md.StringsStream.EndOffset - 1);
}
/// <summary>
/// Returns a reader positioned at a table row
/// </summary>
/// <param name="table">Table</param>
/// <param name="rid">A valid row ID (i.e., >= <c>1</c> and <= number of rows)</param>
/// <returns>The reader (owned by us) or <c>null</c> if the row isn't present</returns>
public IImageStream GetTableReader(MDTable table, uint rid) {
long offset;
if (GetRowOffset(table, rid, out offset)) {
fullStream.Position = offset;
return fullStream;
}
return null;
}
public MetaDataTableNode(HexBuffer buffer, MDTable mdTable, IMetaData md)
: base(HexSpan.FromBounds((ulong)mdTable.StartOffset, (ulong)mdTable.EndOffset)) {
Buffer = buffer;
TableInfo = mdTable.TableInfo;
var stringsHeapSpan = HexSpan.FromBounds((ulong)md.StringsStream.StartOffset, (ulong)md.StringsStream.EndOffset);
var guidHeapSpan = HexSpan.FromBounds((ulong)md.GuidStream.StartOffset, (ulong)md.GuidStream.EndOffset);
MetaDataTableVM = MetaDataTableVM.Create(this, buffer, Span.Start, mdTable, stringsHeapSpan, guidHeapSpan);
MetaDataTableVM.FindMetaDataTable = FindMetaDataTable;
}
protected MetaDataTableVM(object owner, HexBuffer buffer, HexPosition startOffset, MDTable mdTable, HexSpan stringsHeapSpan, HexSpan guidHeapSpan) {
this.buffer = buffer;
this.stringsHeapSpan = stringsHeapSpan;
this.guidHeapSpan = guidHeapSpan;
Owner = owner;
Span = new HexSpan(startOffset, (ulong)mdTable.Rows * mdTable.RowSize);
Rows = mdTable.Rows;
TableInfo = CreateTableInfo(mdTable.TableInfo);
Collection = new VirtualizedList<MetaDataTableRecordVM>((int)Rows, CreateItem);
}
IBinaryReader GetReader_NoLock(MDTable table, uint rid) {
IBinaryReader reader;
if (hotTableStream != null) {
reader = hotTableStream.GetTableReader(table, rid);
if (reader != null)
return reader;
}
reader = table.ImageStream;
reader.Position = (rid - 1) * table.TableInfo.RowSize;
return reader;
}
/// <inheritdoc/>
protected override uint BinarySearch_NoLock(MDTable tableSource, int keyColIndex, uint key)
{
var keyColumn = tableSource.TableInfo.Columns[keyColIndex];
uint ridLo = 1, ridHi = tableSource.Rows;
while (ridLo <= ridHi) {
uint rid = (ridLo + ridHi) / 2;
uint key2;
if (!tablesStream.ReadColumn_NoLock(tableSource, rid, keyColumn, out key2))
break; // Never happens since rid is valid
if (key == key2)
return rid;
if (key2 > key)
ridHi = rid - 1;
else
ridLo = rid + 1;
}
return 0;
}
/// <summary>
/// Writes a <c>AssemblyRefProcessor</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawAssemblyRefProcessorRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.Processor);
cols[1].Write(writer, row.AssemblyRef);
}
}
/// <summary>
/// Writes a <c>AssemblyRefOS</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawAssemblyRefOSRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.OSPlatformId);
writer.Write(row.OSMajorVersion);
writer.Write(row.OSMinorVersion);
cols[3].Write(writer, row.AssemblyRef);
}
}
/// <summary>
/// Writes a <c>Property</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawPropertyRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.PropFlags);
cols[1].Write(writer, row.Name);
cols[2].Write(writer, row.Type);
}
}
/// <summary>
/// Writes a <c>AssemblyRef</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawAssemblyRefRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.MajorVersion);
writer.Write(row.MinorVersion);
writer.Write(row.BuildNumber);
writer.Write(row.RevisionNumber);
writer.Write(row.Flags);
cols[5].Write(writer, row.PublicKeyOrToken);
cols[6].Write(writer, row.Name);
cols[7].Write(writer, row.Locale);
cols[8].Write(writer, row.HashValue);
}
}
/// <summary>
/// Writes a <c>GenericParam</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawGenericParamRow> table) {
var cols = table.TableInfo.Columns;
bool useKindColumn = cols.Count >= 5;
foreach (var row in table) {
writer.Write(row.Number);
writer.Write(row.Flags);
cols[2].Write(writer, row.Owner);
cols[3].Write(writer, row.Name);
if (useKindColumn)
cols[4].Write(writer, row.Kind);
}
}
/// <summary>
/// Writes a <c>GenericParamConstraint</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawGenericParamConstraintRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
cols[0].Write(writer, row.Owner);
cols[1].Write(writer, row.Constraint);
}
}
/// <summary>
/// Writes a <c>FieldRVA</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawFieldRVARow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.RVA);
cols[1].Write(writer, row.Field);
}
}
/// <summary>
/// Writes a <c>ManifestResource</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawManifestResourceRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.Offset);
writer.Write(row.Flags);
cols[2].Write(writer, row.Name);
cols[3].Write(writer, row.Implementation);
}
}
/// <summary>
/// Writes a <c>TypeSpec</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawTypeSpecRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table)
cols[0].Write(writer, row.Signature);
}
/// <summary>
/// Writes a <c>ImplMap</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawImplMapRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.MappingFlags);
cols[1].Write(writer, row.MemberForwarded);
cols[2].Write(writer, row.ImportName);
cols[3].Write(writer, row.ImportScope);
}
}
/// <summary>
/// Writes a <c>ModuleRef</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawModuleRefRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table)
cols[0].Write(writer, row.Name);
}
/// <summary>
/// Writes a <c>MethodImpl</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawMethodImplRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
cols[0].Write(writer, row.Class);
cols[1].Write(writer, row.MethodBody);
cols[2].Write(writer, row.MethodDeclaration);
}
}
/// <summary>
/// Writes a <c>MethodSemantics</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawMethodSemanticsRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.Semantic);
cols[1].Write(writer, row.Method);
cols[2].Write(writer, row.Association);
}
}
/// <summary>
/// Writes a <c>File</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawFileRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.Flags);
cols[1].Write(writer, row.Name);
cols[2].Write(writer, row.HashValue);
}
}
/// <summary>
/// Writes a <c>PropertyMap</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawPropertyMapRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
cols[0].Write(writer, row.Parent);
cols[1].Write(writer, row.PropertyList);
}
}
/// <summary>
/// Writes a <c>ExportedType</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawExportedTypeRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
writer.Write(row.Flags);
writer.Write(row.TypeDefId);
cols[2].Write(writer, row.TypeName);
cols[3].Write(writer, row.TypeNamespace);
cols[4].Write(writer, row.Implementation);
}
}
/// <summary>
/// Writes a <c>ENCMap</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawENCMapRow> table) {
foreach (var row in table)
writer.Write(row.Token);
}
/// <summary>
/// Writes a <c>NestedClass</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawNestedClassRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
cols[0].Write(writer, row.NestedClass);
cols[1].Write(writer, row.EnclosingClass);
}
}
/// <summary>
/// Writes a <c>AssemblyProcessor</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawAssemblyProcessorRow> table) {
foreach (var row in table)
writer.Write(row.Processor);
}
/// <summary>
/// Writes a <c>MethodSpec</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawMethodSpecRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table) {
cols[0].Write(writer, row.Method);
cols[1].Write(writer, row.Instantiation);
}
}
/// <summary>
/// Writes a <c>AssemblyOS</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawAssemblyOSRow> table) {
foreach (var row in table) {
writer.Write(row.OSPlatformId);
writer.Write(row.OSMajorVersion);
writer.Write(row.OSMinorVersion);
}
}
/// <summary>
/// Writes a <c>ENCLog</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawENCLogRow> table) {
foreach (var row in table) {
writer.Write(row.Token);
writer.Write(row.FuncCode);
}
}
/// <summary>
/// Writes a <c>PropertyPtr</c> table
/// </summary>
/// <param name="writer">Writer</param>
/// <param name="table">Table</param>
public static void Write(this BinaryWriter writer, MDTable<RawPropertyPtrRow> table) {
var cols = table.TableInfo.Columns;
foreach (var row in table)
cols[0].Write(writer, row.Property);
}
