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)); }