Trait osrs_bytes::ReadExt

source · 
pub trait ReadExt: Read {

Show 22 methods    fn read_u8(&mut self) -> Result<u8> { ... }
    fn read_i8(&mut self) -> Result<i8> { ... }
    fn read_bool(&mut self) -> Result<bool> { ... }
    fn read_u16(&mut self) -> Result<u16> { ... }
    fn read_u16_le(&mut self) -> Result<u16> { ... }
    fn read_u16_add(&mut self) -> Result<u16> { ... }
    fn read_u16_add_le(&mut self) -> Result<u16> { ... }
    fn read_i16(&mut self) -> Result<i16> { ... }
    fn read_i16_le(&mut self) -> Result<i16> { ... }
    fn read_i16_add(&mut self) -> Result<i16> { ... }
    fn read_i16_add_le(&mut self) -> Result<i16> { ... }
    fn read_u32(&mut self) -> Result<u32> { ... }
    fn read_u32_le(&mut self) -> Result<u32> { ... }
    fn read_u32_me(&mut self) -> Result<u32> { ... }
    fn read_u32_ime(&mut self) -> Result<u32> { ... }
    fn read_i32(&mut self) -> Result<i32> { ... }
    fn read_i32_le(&mut self) -> Result<i32> { ... }
    fn read_i32_me(&mut self) -> Result<i32> { ... }
    fn read_i32_ime(&mut self) -> Result<i32> { ... }
    fn read_u64(&mut self) -> Result<u64> { ... }
    fn read_i64(&mut self) -> Result<i64> { ... }
    fn read_string_cp1252(&mut self) -> Result<String> { ... }

}

Provided Methods§

Reads an unsigned byte

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![2, 5]);
assert_eq!(rdr.read_u8().unwrap(), 2);
assert_eq!(rdr.read_u8().unwrap(), 5);

Reads a signed byte

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![248, 6]);
assert_eq!(rdr.read_i8().unwrap(), -8);
assert_eq!(rdr.read_i8().unwrap(), 6);

Reads a bool

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![0, 1, 2]);
assert_eq!(rdr.read_bool().unwrap(), false);
assert_eq!(rdr.read_bool().unwrap(), true);
assert_eq!(rdr.read_bool().unwrap(), true);

Reads an unsigned short as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![66, 89]);
assert_eq!(rdr.read_u16().unwrap(), 16985);

Reads an unsigned short as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![89, 66]);
assert_eq!(rdr.read_u16_le().unwrap(), 16985);

Reads an unsigned short as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![99, 130]);
assert_eq!(rdr.read_u16_add().unwrap(), 25346);

Reads an unsigned short add as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![89, 66]);
assert_eq!(rdr.read_u16_add_le().unwrap(), 17113);

Reads a signed short as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![255, 98]);
assert_eq!(rdr.read_i16().unwrap(), -158);

Reads a signed short as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![98, 255]);
assert_eq!(rdr.read_i16_le().unwrap(), -158);

Reads a signed short add

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![253, 177]);
assert_eq!(rdr.read_i16_add().unwrap(), -719);

Reads an unsigned short add as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![98, 255]);
assert_eq!(rdr.read_i16_add_le().unwrap(), -30);

Reads an unsigned dword as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![42, 87, 33, 16]);
assert_eq!(rdr.read_u32().unwrap(), 710353168);

Reads an unsigned dword as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![16, 33, 87, 42]);
assert_eq!(rdr.read_u32_le().unwrap(), 710353168);

Reads an unsigned dword as middle endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![1, 5, 9, 49]);
assert_eq!(rdr.read_u32_me().unwrap(), 83964169);

Reads an unsigned dword as inversed middle endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![0, 0, 0, 149]);
assert_eq!(rdr.read_u32_ime().unwrap(), 9764864);

Reads a signed dword as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![255, 87, 33, 16]);
assert_eq!(rdr.read_i32().unwrap(), -11067120);

Reads an signed dword as little endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![16, 33, 87, 250]);
assert_eq!(rdr.read_i32_le().unwrap(), -94953200);

Reads an signed dword as middle endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![0, 149, 0, 0]);
assert_eq!(rdr.read_i32_me().unwrap(), -1795162112);

Reads an unsigned dword as inversed middle endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![118, 195, 254, 193]);
assert_eq!(rdr.read_i32_ime().unwrap(), -20875581);

Reads an unsigned dword as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![31, 84, 11, 99, 45, 12, 94, 36]);
assert_eq!(rdr.read_u64().unwrap(), 2257441833804914212);

Reads an signed dword as big endian

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![255, 84, 11, 99, 45, 12, 94, 36]);
assert_eq!(rdr.read_i64().unwrap(), -48401175408779740);

Reads a CP1252 string

Examples
use std::io::Cursor;
use osrs_bytes::ReadExt;

let mut rdr = Cursor::new(vec![109, 121, 32, 116, 101, 115, 116, 0]);
assert_eq!(rdr.read_string_cp1252().unwrap(), "my test");

Implementors§