Trait ReadExt

pub trait ReadExt: Read {
    // Provided 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

fn read_u8(&mut self) -> Result<u8>

Reads an unsigned byte

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i8(&mut self) -> Result<i8>

Reads a signed byte

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_bool(&mut self) -> Result<bool>

Reads a bool

Examples

use std::io::Cursor;
use osrs_buffer::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);

fn read_u16(&mut self) -> Result<u16>

Reads an unsigned short as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u16_le(&mut self) -> Result<u16>

Reads an unsigned short as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u16_add(&mut self) -> Result<u16>

Reads an unsigned short as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u16_add_le(&mut self) -> Result<u16>

Reads an unsigned short add as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i16(&mut self) -> Result<i16>

Reads a signed short as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i16_le(&mut self) -> Result<i16>

Reads a signed short as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i16_add(&mut self) -> Result<i16>

Reads a signed short add

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i16_add_le(&mut self) -> Result<i16>

Reads an unsigned short add as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u32(&mut self) -> Result<u32>

Reads an unsigned dword as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u32_le(&mut self) -> Result<u32>

Reads an unsigned dword as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u32_me(&mut self) -> Result<u32>

Reads an unsigned dword as middle endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u32_ime(&mut self) -> Result<u32>

Reads an unsigned dword as inversed middle endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i32(&mut self) -> Result<i32>

Reads a signed dword as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i32_le(&mut self) -> Result<i32>

Reads an signed dword as little endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i32_me(&mut self) -> Result<i32>

Reads an signed dword as middle endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i32_ime(&mut self) -> Result<i32>

Reads an unsigned dword as inversed middle endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_u64(&mut self) -> Result<u64>

Reads an unsigned dword as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_i64(&mut self) -> Result<i64>

Reads an signed dword as big endian

Examples

use std::io::Cursor;
use osrs_buffer::ReadExt;

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

fn read_string_cp1252(&mut self) -> Result<String>

Reads a CP1252 string

Examples

use std::io::Cursor;
use osrs_buffer::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

impl<R: Read + ?Sized> ReadExt for R