public T[] Read <T>(MemoryAddress address, int count)
{
var snapshotAddress = ToSnapshotAddress(address);
if (TypeHelper <T> .IsMemoryObjectType)
{
var array = BaseMemory.Reader.Read <T>(address, count);
var itemOffset = snapshotAddress;
for (int i = 0; i < count; i++)
{
(array[i] as MemoryObject).SetSnapshot(
SnapshotReader.Segment.Array,
SnapshotReader.Segment.Offset + itemOffset,
SnapshotReader.Segment.Array.Length - (SnapshotReader.Segment.Offset + itemOffset));
itemOffset += TypeHelper <T> .SizeOf;
}
return(array);
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
// It is important that a pointer doesn't get a snapshot as context!
var array = new T[count];
for (int i = 0; i < count; i++)
{
array[i] = (T)MemoryPointerFactory.Create <T>(BaseMemory,
SnapshotReader.ReadMemoryAddress(snapshotAddress + i * BaseMemory.Reader.PointerSize));
}
return(array);
}
return(SnapshotReader.Read <T>(snapshotAddress, count));
}
public virtual T Read <T>(int offset)
{
if (!TypeHelper <T> .IsTypeSupportedByMemoryReader)
{
throw new NotSupportedException();
}
var snapshot = Snapshot;
if (snapshot != null)
{
if (TypeHelper <T> .IsMemoryObjectType)
{
var value = Memory.Reader.Read <T>(GetAbsoluteAddress(offset));
(value as MemoryObject).SetSnapshot(
snapshot.Segment.Array,
snapshot.Segment.Offset + offset,
TypeHelper <T> .SizeOf);
return(value);
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
// It is important that a pointer doesn't get a snapshot as context!
return((T)MemoryPointerFactory.Create <T>(Memory,
ReadMemoryAddress(offset)));
}
return(snapshot.Read <T>(offset));
}
return(Memory.Reader.Read <T>(GetAbsoluteAddress(offset)));
}
public T Read <T>(MemoryAddress address)
{
if (!IsValidAddress(address))
{
throw new ArgumentOutOfRangeException();
}
if (!IsValidAddress(address + TypeHelper <T> .SizeOf))
{
throw new ArgumentException("address");
}
if (TypeHelper <T> .HasKnownStructLayout)
{
byte[] buffer = GetBuffer(TypeHelper <T> .SizeOf);
UnsafeReadBytes(address, buffer, 0, TypeHelper <T> .SizeOf);
return(StructHelper <T> .UnsafeRead(buffer, 0));
}
else if (TypeHelper <T> .IsMemoryObjectType)
{
return((T)(object)MemoryObjectFactory.UnsafeCreate(typeof(T), Memory, address));
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
return((T)(object)MemoryPointerFactory.UnsafeCreate <T>(Memory, ReadMemoryAddress(address)));
}
else if (TypeHelper <T> .IsMemoryAddressType)
{
return((T)(object)ReadMemoryAddress(address));
}
else
{
throw new NotSupportedException();
}
}
public T[] Read <T>(MemoryAddress address, int count)
{
if (!IsValidAddress(address))
{
throw new ArgumentOutOfRangeException("address");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count");
}
if (!IsValidAddress(address + TypeHelper <T> .SizeOf * count))
{
throw new ArgumentException();
}
T[] array = new T[count];
if (TypeHelper <T> .HasKnownStructLayout)
{
int bufferSize = TypeHelper <T> .SizeOf * count;
byte[] buffer = GetBuffer(bufferSize);
UnsafeReadBytes(address, buffer, 0, bufferSize);
StructHelper <T> .CopyFromBuffer(buffer, 0, array, 0, count);
}
else if (TypeHelper <T> .IsMemoryObjectType)
{
for (int i = 0; i < count; i++)
{
array[i] = (T)(object)MemoryObjectFactory.UnsafeCreate(typeof(T), Memory, address + i * TypeHelper <T> .SizeOf);
}
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
var buffer = new byte[count * PointerSize];
UnsafeReadBytes(address, buffer, 0, buffer.Length);
var bufferReader = new BufferMemoryReader(buffer, 0, buffer.Length, PointerSize);
for (int i = 0; i < count; i++)
{
array[i] = (T)(object)MemoryPointerFactory.UnsafeCreate <T>(Memory, bufferReader.ReadMemoryAddress(i * PointerSize));
}
}
else if (TypeHelper <T> .IsMemoryAddressType)
{
for (int i = 0; i < count; i++)
{
array[i] = (T)(object)ReadMemoryAddress(address + i * PointerSize);
}
}
else
{
throw new NotSupportedException();
}
return(array);
}
public virtual T[] Read <T>(int offset, int count)
{
if (!TypeHelper <T> .IsTypeSupportedByMemoryReader)
{
throw new NotSupportedException();
}
var snapshot = Snapshot;
if (snapshot != null)
{
if (TypeHelper <T> .IsMemoryObjectType)
{
var array = Memory.Reader.Read <T>(GetAbsoluteAddress(offset), count);
var itemOffset = offset;
for (int i = 0; i < count; i++)
{
(array[i] as MemoryObject).SetSnapshot(
snapshot.Segment.Array,
snapshot.Segment.Offset + itemOffset,
TypeHelper <T> .SizeOf);
itemOffset += TypeHelper <T> .SizeOf;
}
return(array);
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
// It is important that a pointer doesn't get a snapshot as context!
var array = new T[count];
for (int i = 0; i < count; i++)
{
array[i] = (T)MemoryPointerFactory.Create <T>(Memory,
ReadMemoryAddress(offset + i * Memory.Reader.PointerSize));
}
return(array);
}
return(snapshot.Read <T>(offset, count));
}
return(Memory.Reader.Read <T>(GetAbsoluteAddress(offset), count));
}
public T Read <T>(MemoryAddress address)
{
var snapshotAddress = ToSnapshotAddress(address);
if (TypeHelper <T> .IsMemoryObjectType)
{
var value = BaseMemory.Reader.Read <T>(address);
(value as MemoryObject).SetSnapshot(
SnapshotReader.Segment.Array,
SnapshotReader.Segment.Offset + snapshotAddress,
SnapshotReader.Segment.Array.Length - (SnapshotReader.Segment.Offset + snapshotAddress));
return(value);
}
else if (TypeHelper <T> .IsMemoryPointerType)
{
// It is important that a pointer doesn't get a snapshot as context!
return((T)MemoryPointerFactory.Create <T>(BaseMemory,
SnapshotReader.ReadMemoryAddress(snapshotAddress)));
}
return(SnapshotReader.Read <T>(snapshotAddress));
}
