Trait WriteExt

pub trait WriteExt: Write {
    // Provided methods
    fn write_u8(&mut self, n: u8) -> Result<()> { ... }
    fn write_i8(&mut self, n: i8) -> Result<()> { ... }
    fn write_i8_sub(&mut self, n: i8) -> Result<()> { ... }
    fn write_i8_add(&mut self, n: i8) -> Result<()> { ... }
    fn write_i8_neg(&mut self, n: i8) -> Result<()> { ... }
    fn write_bool(&mut self, b: bool) -> Result<()> { ... }
    fn write_u16(&mut self, n: u16) -> Result<()> { ... }
    fn write_u16_le(&mut self, n: u16) -> Result<()> { ... }
    fn write_u16_smart(&mut self, n: u16) -> Result<()> { ... }
    fn write_i16(&mut self, n: i16) -> Result<()> { ... }
    fn write_i16_le(&mut self, n: i16) -> Result<()> { ... }
    fn write_i16_add(&mut self, n: i16) -> Result<()> { ... }
    fn write_i16_le_add(&mut self, n: i16) -> Result<()> { ... }
    fn write_u32(&mut self, n: u32) -> Result<()> { ... }
    fn write_u32_le(&mut self, n: u32) -> Result<()> { ... }
    fn write_i32(&mut self, n: i32) -> Result<()> { ... }
    fn write_i32_le(&mut self, n: i32) -> Result<()> { ... }
    fn write_i32_me(&mut self, n: i32) -> Result<()> { ... }
    fn write_i32_ime(&mut self, n: i32) -> Result<()> { ... }
    fn write_u64(&mut self, n: u64) -> Result<()> { ... }
    fn write_i64(&mut self, n: i64) -> Result<()> { ... }
    fn write_string_cp1252(&mut self, s: &str) -> Result<()> { ... }
    fn write_bytes_reversed_add(&mut self, buf: &[u8]) -> Result<()> { ... }
}

Provided Methods

fn write_u8(&mut self, n: u8) -> Result<()>

Writes an unsigned byte to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u8(42).unwrap();
assert_eq!(wtr[0], 42);

fn write_i8(&mut self, n: i8) -> Result<()>

Writes an signed byte to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i8(-67).unwrap();
assert_eq!(wtr[0] as i8, -67);

fn write_i8_sub(&mut self, n: i8) -> Result<()>

Writes the number 128, subtracted by the signed byte to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i8_sub(99).unwrap();
assert_eq!(wtr[0] as i8, 29);

fn write_i8_add(&mut self, n: i8) -> Result<()>

Writes the byte and adds 128.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i8_add(42).unwrap();
assert_eq!(wtr[0], 170);

fn write_i8_neg(&mut self, n: i8) -> Result<()>

Writes a negated byte to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i8_neg(55).unwrap();
assert_eq!(wtr[0], 201);

fn write_bool(&mut self, b: bool) -> Result<()>

Writes a bool to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_bool(true).unwrap();
assert_eq!(wtr[0], 1);

fn write_u16(&mut self, n: u16) -> Result<()>

Writes an unsigned short to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u16(20065).unwrap();
assert_eq!(wtr[0], 78);
assert_eq!(wtr[1], 97);

fn write_u16_le(&mut self, n: u16) -> Result<()>

Writes an unsigned short as a little endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u16_le(29543).unwrap();
assert_eq!(wtr[0], 103);
assert_eq!(wtr[1], 115);

fn write_u16_smart(&mut self, n: u16) -> Result<()>

Writes an unsigned short smart to the writer.

Examples

Writing a value lesser than or equal to 127 makes it write out a single unsigned byte.

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u16_smart(65).unwrap();
assert_eq!(wtr[0], 65);
assert!(wtr.get(1).is_none());

Writing a value greater than 127 will make it write out two unsigned bytes.

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u16_smart(986).unwrap();
assert_eq!(wtr[0], 131);
assert_eq!(wtr[1], 218);

fn write_i16(&mut self, n: i16) -> Result<()>

Writes a signed short to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i16(-14632).unwrap();
assert_eq!(wtr[0], 198);
assert_eq!(wtr[1], 216);

fn write_i16_le(&mut self, n: i16) -> Result<()>

Writes a signed short as little endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i16_le(-7654).unwrap();
assert_eq!(wtr[0], 26);
assert_eq!(wtr[1], 226);

fn write_i16_add(&mut self, n: i16) -> Result<()>

Writes a signed short add to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i16_add(-9867).unwrap();
assert_eq!(wtr[0], 217);
assert_eq!(wtr[1], 245);

fn write_i16_le_add(&mut self, n: i16) -> Result<()>

Writes a signed short add as a little endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i16_le_add(-12632).unwrap();
assert_eq!(wtr[0], 40);
assert_eq!(wtr[1], 206);

fn write_u32(&mut self, n: u32) -> Result<()>

Writes an unsigned dword to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u32(98571).unwrap();
assert_eq!(wtr[0], 0);
assert_eq!(wtr[1], 1);
assert_eq!(wtr[2], 129);
assert_eq!(wtr[3], 11);

fn write_u32_le(&mut self, n: u32) -> Result<()>

Writes am unsigned integer as little endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u32_le(26904).unwrap();
assert_eq!(wtr[0], 24);
assert_eq!(wtr[1], 105);
assert_eq!(wtr[2], 0);
assert_eq!(wtr[3], 0);

fn write_i32(&mut self, n: i32) -> Result<()>

Writes a signed dword to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i32(-131045).unwrap();
assert_eq!(wtr[0], 255);
assert_eq!(wtr[1], 254);
assert_eq!(wtr[2], 0);
assert_eq!(wtr[3], 27);

fn write_i32_le(&mut self, n: i32) -> Result<()>

Writes a signed integer as little endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i32_le(18879).unwrap();
assert_eq!(wtr[0], 191);
assert_eq!(wtr[1], 73);
assert_eq!(wtr[2], 0);
assert_eq!(wtr[3], 0);

fn write_i32_me(&mut self, n: i32) -> Result<()>

Writes a signed dword as a middle endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i32_me(-98231).unwrap();
assert_eq!(wtr[0], 254);
assert_eq!(wtr[1], 255);
assert_eq!(wtr[2], 73);
assert_eq!(wtr[3], 128);

fn write_i32_ime(&mut self, n: i32) -> Result<()>

Writes a signed dword as an inversed middle endian to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i32_ime(-98231).unwrap();
assert_eq!(wtr[0], 128);
assert_eq!(wtr[1], 73);
assert_eq!(wtr[2], 255);
assert_eq!(wtr[3], 254);

fn write_u64(&mut self, n: u64) -> Result<()>

Writes an unsigned qword to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_u64(8589934592).unwrap();
assert_eq!(wtr[0], 0);
assert_eq!(wtr[1], 0);
assert_eq!(wtr[2], 0);
assert_eq!(wtr[3], 2);
assert_eq!(wtr[4], 0);
assert_eq!(wtr[5], 0);
assert_eq!(wtr[6], 0);
assert_eq!(wtr[7], 0);

fn write_i64(&mut self, n: i64) -> Result<()>

Writes a signed qword to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_i64(-8589934592).unwrap();
assert_eq!(wtr[0], 255);
assert_eq!(wtr[1], 255);
assert_eq!(wtr[2], 255);
assert_eq!(wtr[3], 254);
assert_eq!(wtr[4], 0);
assert_eq!(wtr[5], 0);
assert_eq!(wtr[6], 0);
assert_eq!(wtr[7], 0);

fn write_string_cp1252(&mut self, s: &str) -> Result<()>

Writes a CP1252 string to the writer.

Examples

use osrs_buffer::WriteExt;

let mut wtr = Vec::new();
wtr.write_string_cp1252("hello").unwrap();
assert_eq!(wtr[0], 104);
assert_eq!(wtr[1], 101);
assert_eq!(wtr[2], 108);
assert_eq!(wtr[3], 108);
assert_eq!(wtr[4], 111);
assert_eq!(wtr[5], 0);

fn write_bytes_reversed_add(&mut self, buf: &[u8]) -> Result<()>

Write bytes reversed with add to the writer.

Examples

use osrs_buffer::WriteExt;

let wtr1 = vec![1, 2, 3];

let mut wtr2 = Vec::new();
wtr2.write_bytes_reversed_add(&wtr1);
assert_eq!(wtr2[0], 131);
assert_eq!(wtr2[1], 130);
assert_eq!(wtr2[2], 129);

Implementors

impl<W: Write + ?Sized> WriteExt for W