Trait ReadExt 

pub trait ReadExt: Read {
    // Provided methods
    fn read_u8(&mut self) -> Result<u8> { ... }
    fn read_u8_add(&mut self) -> Result<u8> { ... }
    fn read_u8_neg(&mut self) -> Result<u8> { ... }
    fn read_u8_sub(&mut self) -> Result<u8> { ... }
    fn read_i8(&mut self) -> Result<i8> { ... }
    fn read_i8_add(&mut self) -> Result<i8> { ... }
    fn read_i8_neg(&mut self) -> Result<i8> { ... }
    fn read_i8_sub(&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_smart(&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_smart(&mut self) -> Result<i16> { ... }
    fn read_i16_add(&mut self) -> Result<i16> { ... }
    fn read_i16_add_le(&mut self) -> Result<i16> { ... }
    fn read_u24(&mut self) -> Result<u32> { ... }
    fn read_u24_le(&mut self) -> Result<u32> { ... }
    fn read_i24(&mut self) -> Result<i32> { ... }
    fn read_i24_le(&mut self) -> Result<i32> { ... }
    fn read_u32(&mut self) -> Result<u32> { ... }
    fn read_u32_smart(&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_smart(&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_bytes::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_u8_add(&mut self) -> Result<u8>

Reads an unsigned byte add

Examples

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

let mut rdr = Cursor::new(vec![125]);
assert_eq!(rdr.read_u8_add().unwrap(), 253)

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_u8_add().unwrap(), 0)

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

Reads an unsigned byte negate

Examples

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_u8_neg().unwrap(), 128);

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

let mut rdr = Cursor::new(vec![127]);
assert_eq!(rdr.read_u8_neg().unwrap(), 129);

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

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

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

Reads an unsigned byte sub

Examples

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_u8_sub().unwrap(), 0);

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

let mut rdr = Cursor::new(vec![127]);
assert_eq!(rdr.read_u8_sub().unwrap(), 1);

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

let mut rdr = Cursor::new(vec![0]);
assert_eq!(rdr.read_u8_sub().unwrap(), 128);

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

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

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

Reads a signed byte add

Examples

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

let mut rdr = Cursor::new(vec![125]);
assert_eq!(rdr.read_i8_add().unwrap(), -3);

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_i8_add().unwrap(), 0);

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

Reads a signed byte negate

Examples

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_i8_neg().unwrap(), -128);

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

let mut rdr = Cursor::new(vec![42]);
assert_eq!(rdr.read_i8_neg().unwrap(), -42);

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

Reads a signed byte sub

Examples

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

let mut rdr = Cursor::new(vec![128]);
assert_eq!(rdr.read_i8_sub().unwrap(), 0);

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

let mut rdr = Cursor::new(vec![42]);
assert_eq!(rdr.read_i8_sub().unwrap(), 86);

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

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

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

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

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

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

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

Reads an unsigned short as smart

Examples

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

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

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

let mut rdr = Cursor::new(vec![0x40]);
assert_eq!(rdr.read_u16_smart().unwrap(), 0x40);

Example with a value less than 128. Here we can see that the first byte is returned.

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

let mut rdr = Cursor::new(vec![0x7F]);
assert_eq!(rdr.read_u16_smart().unwrap(), 0x7F);

Example where the first byte’s value is 128 or greater. 128 is the max value in a smart type.

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

let mut rdr = Cursor::new(vec![0x80, 0x80]);
assert_eq!(rdr.read_u16_smart().unwrap(), 0x80);

Example where the first byte’s value is 128 or greater. This returns it as a short.

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

let mut rdr = Cursor::new(vec![0xC0, 0x00]);
assert_eq!(rdr.read_u16_smart().unwrap(), 0x4000);

Example of the highest possible value for a smart type.

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

let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
assert_eq!(rdr.read_u16_smart().unwrap(), 0x7FFF);

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

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

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

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

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

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

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

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

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

Reads a signed short as smart

Examples

Example with a value less than 128. Here we can see that the first byte is returned.

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

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

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

let mut rdr = Cursor::new(vec![0x40]);
assert_eq!(rdr.read_i16_smart().unwrap(), 0);

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

let mut rdr = Cursor::new(vec![0x7F]);
assert_eq!(rdr.read_i16_smart().unwrap(), 0x3F);

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

let mut rdr = Cursor::new(vec![0x80, 0x00]);
assert_eq!(rdr.read_i16_smart().unwrap(), -0x4000);

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

let mut rdr = Cursor::new(vec![0xBF, 0xBF]);
assert_eq!(rdr.read_i16_smart().unwrap(), -0x41);

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

let mut rdr = Cursor::new(vec![0xC0, 0x40]);
assert_eq!(rdr.read_i16_smart().unwrap(), 0x40);

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

let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
assert_eq!(rdr.read_i16_smart().unwrap(), 0x3FFF);

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

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

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

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

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

Reads an unsigned medium as big endian

Examples

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

let mut rdr = Cursor::new(vec![1, 2, 3]);
assert_eq!(rdr.read_u24().unwrap(), 66051);

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

Reads an unsigned medium as little endian

Examples

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

let mut rdr = Cursor::new(vec![3, 2, 1]);
assert_eq!(rdr.read_u24_le().unwrap(), 66051);

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

Reads a signed medium as big endian

Examples

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

let mut rdr = Cursor::new(vec![255, 255, 255]);
assert_eq!(rdr.read_i24().unwrap(), 16777215);

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

Reads a signed medium as little endian

Examples

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

let mut rdr = Cursor::new(vec![255, 255, 255]);
assert_eq!(rdr.read_i24_le().unwrap(), 16777215);

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

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

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

Read an unsigned dword as a smart

Examples

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

let mut rdr = Cursor::new(vec![0x00, 0x00]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0);

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

let mut rdr = Cursor::new(vec![0x40, 0x00]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0x4000);

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

let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0x7FFF);

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

let mut rdr = Cursor::new(vec![0x80, 0x00, 0x80, 0x00]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0x8000);

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

let mut rdr = Cursor::new(vec![0xC0, 0x00, 0x00, 0x00]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0x40000000);

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

let mut rdr = Cursor::new(vec![0xFF, 0xFF, 0xFF, 0xFF]);
assert_eq!(rdr.read_u32_smart().unwrap(), 0x7FFFFFFF);

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

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

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

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

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

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

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

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

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

Read an signed dword as a smart

Examples

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

let mut rdr = Cursor::new(vec![0x00, 0x00]);
assert_eq!(rdr.read_i32_smart().unwrap(), -0x4000);

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

let mut rdr = Cursor::new(vec![0x40, 0x00]);
assert_eq!(rdr.read_i32_smart().unwrap(), 0);

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

let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
assert_eq!(rdr.read_i32_smart().unwrap(), 0x3FFF);

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

let mut rdr = Cursor::new(vec![0x80, 0x00, 0x00, 0x00]);
assert_eq!(rdr.read_i32_smart().unwrap(), -0x40000000);

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

let mut rdr = Cursor::new(vec![0xBF, 0xFF, 0xBF, 0xFF]);
assert_eq!(rdr.read_i32_smart().unwrap(), -0x4001);

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

let mut rdr = Cursor::new(vec![0xC0, 0x00, 0x40, 0x00]);
assert_eq!(rdr.read_i32_smart().unwrap(), 0x4000);

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

let mut rdr = Cursor::new(vec![0xFF, 0xFF, 0xFF, 0xFF]);
assert_eq!(rdr.read_i32_smart().unwrap(), 0x3FFFFFFF);

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

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

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

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

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

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

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

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

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

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

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

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

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