Trait ReadWrite 

pub trait ReadWrite: BaseReadWrite {
    // Provided methods
    fn read_i8_rel(&self, address: Option<usize>) -> i8 { ... }
    fn read_i32_rel(&self, address: Option<usize>) -> i32 { ... }
    fn read_i64_rel(&self, address: Option<usize>) -> i64 { ... }
    fn read_u8_rel(&self, address: Option<usize>) -> u8 { ... }
    fn read_u32_rel(&self, address: Option<usize>) -> u32 { ... }
    fn read_u64_rel(&self, address: Option<usize>) -> u64 { ... }
    fn read_f32_rel(&self, address: Option<usize>) -> f32 { ... }
    fn read_f64_rel(&self, address: Option<usize>) -> f64 { ... }
    fn read_bool_rel(&self, address: Option<usize>) -> bool { ... }
    fn read_i8_abs(&self, address: usize) -> i8 { ... }
    fn read_i32_abs(&self, address: usize) -> i32 { ... }
    fn read_i64_abs(&self, address: usize) -> i64 { ... }
    fn read_u8_abs(&self, address: usize) -> u8 { ... }
    fn read_u32_abs(&self, address: usize) -> u32 { ... }
    fn read_u64_abs(&self, address: usize) -> u64 { ... }
    fn read_f32_abs(&self, address: usize) -> f32 { ... }
    fn read_f64_abs(&self, address: usize) -> f64 { ... }
    fn read_bool_abs(&self, address: usize) -> bool { ... }
    fn write_i8_rel(&self, address: Option<usize>, value: i8) { ... }
    fn write_i32_rel(&self, address: Option<usize>, value: i32) { ... }
    fn write_i64_rel(&self, address: Option<usize>, value: i64) { ... }
    fn write_u8_rel(&self, address: Option<usize>, value: u8) { ... }
    fn write_u32_rel(&self, address: Option<usize>, value: u32) { ... }
    fn write_u64_rel(&self, address: Option<usize>, value: u64) { ... }
    fn write_f32_rel(&self, address: Option<usize>, value: f32) { ... }
    fn write_f64_rel(&self, address: Option<usize>, value: f64) { ... }
    fn write_i8_abs(&self, address: usize, value: i8) { ... }
    fn write_i32_abs(&self, address: usize, value: i32) { ... }
    fn write_i64_abs(&self, address: usize, value: i64) { ... }
    fn write_u8_abs(&self, address: usize, value: u8) { ... }
    fn write_u32_abs(&self, address: usize, value: u32) { ... }
    fn write_u64_abs(&self, address: usize, value: u64) { ... }
    fn write_f32_abs(&self, address: usize, value: f32) { ... }
    fn write_f64_abs(&self, address: usize, value: f64) { ... }
}

Provided Methods

fn read_i8_rel(&self, address: Option<usize>) -> i8

Relatively read an i8 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i8_rel(Some(0x1234));

fn read_i32_rel(&self, address: Option<usize>) -> i32

Relatively read an i32 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i32_rel(Some(0x1234));

fn read_i64_rel(&self, address: Option<usize>) -> i64

Relatively read an i64 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i64_rel(Some(0x1234));

fn read_u8_rel(&self, address: Option<usize>) -> u8

Relatively read an u8 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u8_rel(Some(0x1234));

fn read_u32_rel(&self, address: Option<usize>) -> u32

Relatively read an u32 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u32_rel(Some(0x1234));

Examples found in repository

examples/dsr.rs (line 42)

    pub fn get_in_game_time_milliseconds(&self) -> u32
    {
        return self.game_data_man.read_u32_rel(Some(0xa4));
    }

fn read_u64_rel(&self, address: Option<usize>) -> u64

Relatively read an u64 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u64_rel(Some(0x1234));

fn read_f32_rel(&self, address: Option<usize>) -> f32

Relatively read an f32 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_f32_rel(Some(0x1234));

Examples found in repository

examples/dsr.rs (line 47)

    pub fn get_ai_timer(&self) -> f32
    {
        return self.ai_timer.read_f32_rel(Some(0x24));
    }

fn read_f64_rel(&self, address: Option<usize>) -> f64

Relatively read an f64 from an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_f64_rel(Some(0x1234));

fn read_bool_rel(&self, address: Option<usize>) -> bool

Relatively read a bool from an optional offset. A single byte is read from the resolved address, the value of the bool is true if this byte is non-zero.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_bool_rel(Some(0x1234));

fn read_i8_abs(&self, address: usize) -> i8

Absolute read an i8 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i8_abs(0x1234);

fn read_i32_abs(&self, address: usize) -> i32

Absolute read an i32 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i32_abs(0x1234);

fn read_i64_abs(&self, address: usize) -> i64

Absolute read an i64 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_i64_abs(0x1234);

fn read_u8_abs(&self, address: usize) -> u8

Absolute read an u8 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u8_abs(0x1234);

fn read_u32_abs(&self, address: usize) -> u32

Absolute read an u32 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u32_abs(0x1234);

fn read_u64_abs(&self, address: usize) -> u64

Absolute read an u64 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_u64_abs(0x1234);

fn read_f32_abs(&self, address: usize) -> f32

Absolute read an f32 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_f32_abs(0x1234);

fn read_f64_abs(&self, address: usize) -> f64

Absolute read an f64 from an address. Ignores offsets. Sugar for read_memory_abs.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_f64_abs(0x1234);

fn read_bool_abs(&self, address: usize) -> bool

Absolute read a byte from an address. Ignores offsets. Sugar for read_memory_abs. The value of the bool is true if this byte is non-zero.

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data = pointer.read_bool_abs(0x1234);

fn write_i8_rel(&self, address: Option<usize>, value: i8)

Relatively write an i8 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i8 = 10;
pointer.write_i8_rel(Some(0x1234), data);

fn write_i32_rel(&self, address: Option<usize>, value: i32)

Relatively write an i32 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i32 = 10;
pointer.write_i32_rel(Some(0x1234), data);

fn write_i64_rel(&self, address: Option<usize>, value: i64)

Relatively write an i64 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i64 = 10;
pointer.write_i64_rel(Some(0x1234), data);

fn write_u8_rel(&self, address: Option<usize>, value: u8)

Relatively write an u8 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u8 = 10;
pointer.write_u8_rel(Some(0x1234), data);

fn write_u32_rel(&self, address: Option<usize>, value: u32)

Relatively write an u32 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u32 = 10;
pointer.write_u32_rel(Some(0x1234), data);

fn write_u64_rel(&self, address: Option<usize>, value: u64)

Relatively write an u64 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u64 = 10;
pointer.write_u64_rel(Some(0x1234), data);

fn write_f32_rel(&self, address: Option<usize>, value: f32)

Relatively write an f32 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: f32 = 10.0f32;
pointer.write_f32_rel(Some(0x1234), data);

fn write_f64_rel(&self, address: Option<usize>, value: f64)

Relatively write an f64 to an optional offset

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: f64 = 10.0f64;
pointer.write_f64_rel(Some(0x1234), data);

fn write_i8_abs(&self, address: usize, value: i8)

Absolute write an i8

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i8 = 10;
pointer.write_i8_abs(0x1234, data);

fn write_i32_abs(&self, address: usize, value: i32)

Absolute write an i32

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i32 = 10;
pointer.write_i32_abs(0x1234, data);

fn write_i64_abs(&self, address: usize, value: i64)

Absolute write an i64

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: i64 = 10;
pointer.write_i64_abs(0x1234, data);

fn write_u8_abs(&self, address: usize, value: u8)

Absolute write an u8

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u8 = 10;
pointer.write_u8_abs(0x1234, data);

fn write_u32_abs(&self, address: usize, value: u32)

Absolute write an u32

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u32 = 10;
pointer.write_u32_abs(0x1234, data);

fn write_u64_abs(&self, address: usize, value: u64)

Absolute write an u64

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: u64 = 10;
pointer.write_u64_abs(0x1234, data);

fn write_f32_abs(&self, address: usize, value: f32)

Absolute write an f32

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: f32 = 10.0f32;
pointer.write_f32_abs(0x1234, data);

fn write_f64_abs(&self, address: usize, value: f64)

Absolute write an f64

Example

use mem_rs::prelude::*;

let mut process = Process::new("name_of_process.exe");
process.refresh()?;
let pointer = process.create_pointer(0x1234, vec![0]);

let data: f64 = 10.0f64;
pointer.write_f64_abs(0x1234, data);

Implementors

impl ReadWrite for Pointer

impl ReadWrite for ProcessModule

impl ReadWrite for Process