using System;

using ProcessNET.Marshaling;

using ProcessNET.Native.Types;

using ProcessNET.Utilities;

namespace ProcessNET.Memory

{

/// <summary>

/// Class for memory editing a process.

/// </summary>

/// <seealso cref="ProcessMemory" />

public class ExternalProcessMemory : ProcessMemory

{

/// <summary>

/// Initializes a new instance of the <see cref="ExternalProcessMemory" /> class.

/// </summary>

/// <param name="handle">The open handle to the process which contains the memory of interest.</param>

public ExternalProcessMemory(SafeMemoryHandle handle) : base(handle)

{

}

/// <summary>

/// Writes a set of bytes to memory.

/// </summary>

/// <param name="intPtr">The address where the bytes start in memory.</param>

/// <param name="length">The length of the byte chunk to read from the memory address.</param>

/// <returns>

/// The byte array section read from memory.

/// </returns>

public override byte[] Read(IntPtr intPtr, int length)

{

return MemoryHelper.ReadBytes(Handle, intPtr, length);

}

/// <summary>

/// Writes a set of bytes to memory.

/// </summary>

/// <param name="intPtr">The address where the bytes start in memory.</param>

/// <param name="buffer">The buffer to read data onto, it's size determines the count of bytes to read.</param>

public override void Read(IntPtr intPtr, byte[] buffer)

{

MemoryHelper.ReadBytes(Handle, intPtr, buffer);

}

/// <summary>

/// Reads the value of a specified type from memory.

/// </summary>

/// <typeparam name="T">The type of the value.</typeparam>

/// <param name="intPtr">The address where the value is read.</param>

/// <returns>A value.</returns>

public override T Read<T>(IntPtr intPtr)

{

int size = MarshalCache<T>.Size;

if (typeof(T) == typeof(IntPtr))

size = Is32Bit ? 4 : 8;

return MarshalType<T>.ByteArrayToObject(Read(intPtr, size));

}

/// <summary>

/// Writes the values of a specified type to memory.

/// </summary>

/// <typeparam name="T">The type of the value.</typeparam>

/// <param name="intPtr">The address where the value is written.</param>

/// <param name="value">The value to write.</param>

public override void Write<T>(IntPtr intPtr, T value)

{

Write(intPtr, MarshalType<T>.ObjectToByteArray(value));

}

/// <summary>

/// Write an array of bytes in the remote process.

/// </summary>

/// <param name="intPtr">The address where the array is written.</param>

/// <param name="bytesToWrite">The array of bytes to write.</param>

public override int Write(IntPtr intPtr, byte[] bytesToWrite)

{

using (new MemoryProtection(Handle, intPtr, MarshalType<byte>.Size * bytesToWrite.Length))

MemoryHelper.WriteBytes(Handle, intPtr, bytesToWrite);

return bytesToWrite.Length;

}

}

}