osrs-bytes 0.5.0

//! A Rust library for working with the Oldschool Runescape data types.
//!
//! Data types in Oldschool Runescape are slightly different compared to normal types. Example of these types are the smart type, middle endian, and occassional switching to little endian. Therefore it has been seen as necessary to have traits that can work with these data types.
//!
//! This crate provides Read and Write extensions for working with the data types on any data structure implementing `&[u8]` such as Vec, Cursor etc.

use std::io::{self, Error, ErrorKind, Read, Result, Write};

pub trait ReadExt: Read {
    /// Reads an unsigned byte
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u8(&mut self) -> Result<u8> {
        let mut buf = [0; 1];
        self.read_exact(&mut buf)?;
        Ok(buf[0])
    }

    /// Reads an unsigned byte add
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![125]);
    /// assert_eq!(rdr.read_u8_add().unwrap(), 253)
    /// ```
    ///
    /// ```rust
    ///
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_u8_add().unwrap(), 0)
    /// ```
    #[inline]
    fn read_u8_add(&mut self) -> Result<u8> {
        Ok(self.read_u8()?.wrapping_sub(128))
    }

    /// Reads an unsigned byte negate
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_u8_neg().unwrap(), 128);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![127]);
    /// assert_eq!(rdr.read_u8_neg().unwrap(), 129);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0]);
    /// assert_eq!(rdr.read_u8_neg().unwrap(), 0);
    /// ```
    #[inline]
    fn read_u8_neg(&mut self) -> Result<u8> {
        Ok(0u8.wrapping_sub(self.read_u8()?))
    }

    /// Reads an unsigned byte sub
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_u8_sub().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![127]);
    /// assert_eq!(rdr.read_u8_sub().unwrap(), 1);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0]);
    /// assert_eq!(rdr.read_u8_sub().unwrap(), 128);
    /// ```
    #[inline]
    fn read_u8_sub(&mut self) -> Result<u8> {
        Ok(128u8.wrapping_sub(self.read_u8()?))
    }

    /// Reads a signed byte
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i8(&mut self) -> Result<i8> {
        Ok(self.read_u8()? as i8)
    }

    /// Reads a signed byte add
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![125]);
    /// assert_eq!(rdr.read_i8_add().unwrap(), -3);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_i8_add().unwrap(), 0);
    /// ```
    #[inline]
    fn read_i8_add(&mut self) -> Result<i8> {
        Ok(self.read_u8_add()? as i8)
    }

    /// Reads a signed byte negate
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_i8_neg().unwrap(), -128);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![42]);
    /// assert_eq!(rdr.read_i8_neg().unwrap(), -42);
    /// ```
    #[inline]
    fn read_i8_neg(&mut self) -> Result<i8> {
        Ok(self.read_u8_neg()? as i8)
    }

    /// Reads a signed byte sub
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![128]);
    /// assert_eq!(rdr.read_i8_sub().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![42]);
    /// assert_eq!(rdr.read_i8_sub().unwrap(), 86);
    /// ```
    #[inline]
    fn read_i8_sub(&mut self) -> Result<i8> {
        Ok(self.read_u8_sub()? as i8)
    }

    /// Reads a bool
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_bool(&mut self) -> Result<bool> {
        let mut buf = [0; 1];
        self.read_exact(&mut buf)?;
        Ok(buf[0] != 0)
    }

    /// Reads an unsigned short as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![66, 89]);
    /// assert_eq!(rdr.read_u16().unwrap(), 16985);
    /// ```
    #[inline]
    fn read_u16(&mut self) -> Result<u16> {
        let mut buf = [0; 2];
        self.read_exact(&mut buf)?;
        Ok(u16::from_be_bytes(buf))
    }

    /// Reads an unsigned short as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![89, 66]);
    /// assert_eq!(rdr.read_u16_le().unwrap(), 16985);
    /// ```
    #[inline]
    fn read_u16_le(&mut self) -> Result<u16> {
        let mut buf = [0; 2];
        self.read_exact(&mut buf)?;
        Ok(u16::from_le_bytes(buf))
    }

    /// Reads an unsigned short as smart
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0]);
    /// assert_eq!(rdr.read_u16_smart().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// 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.
    ///
    /// ```rust
    /// 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.
    ///
    /// ```rust
    /// 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.
    ///
    /// ```rust
    /// 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.
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
    /// assert_eq!(rdr.read_u16_smart().unwrap(), 0x7FFF);
    /// ```
    #[inline]
    fn read_u16_smart(&mut self) -> Result<u16> {
        let peek = self.read_u8()?;
        if peek & 128 == 0 {
            Ok(peek as u16)
        } else {
            Ok(((peek as u16 & 0x7F) << 8) | (self.read_u8()? as u16))
        }
    }

    /// Reads an unsigned short as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![99, 130]);
    /// assert_eq!(rdr.read_u16_add().unwrap(), 25346);
    /// ```
    #[inline]
    fn read_u16_add(&mut self) -> Result<u16> {
        Ok(((self.read_u8()? as u16) << 8) | ((self.read_u8()?.wrapping_sub(128)) as u16))
    }

    /// Reads an unsigned short add as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u16_add_le(&mut self) -> Result<u16> {
        Ok(((self.read_u8()?.wrapping_sub(128)) as u16) | ((self.read_u8()? as u16) << 8))
    }

    /// Reads a signed short as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![255, 98]);
    /// assert_eq!(rdr.read_i16().unwrap(), -158);
    /// ```
    #[inline]
    fn read_i16(&mut self) -> Result<i16> {
        Ok(self.read_u16()? as i16)
    }

    /// Reads a signed short as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![98, 255]);
    /// assert_eq!(rdr.read_i16_le().unwrap(), -158);
    /// ```
    #[inline]
    fn read_i16_le(&mut self) -> Result<i16> {
        Ok(self.read_u16_le()? as 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.
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), -64);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x40]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x7F]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x3F);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x80, 0x00]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), -0x4000);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0xBF, 0xBF]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), -0x41);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0xC0, 0x40]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x40);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0xFF, 0xFF]);
    /// assert_eq!(rdr.read_i16_smart().unwrap(), 0x3FFF);
    /// ```
    #[inline]
    fn read_i16_smart(&mut self) -> Result<i16> {
        let peek = self.read_u8()?;
        if peek & 128 == 0 {
            Ok(peek as i16 - 64)
        } else {
            Ok((((peek as i16 & 0x7F) << 8) | (self.read_u8()? as i16) & 0x7FFF) - 16384)
        }
    }

    /// Reads a signed short add
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![253, 177]);
    /// assert_eq!(rdr.read_i16_add().unwrap(), -719);
    /// ```
    #[inline]
    fn read_i16_add(&mut self) -> Result<i16> {
        Ok(self.read_u16_add()? as i16)
    }

    /// Reads an unsigned short add as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i16_add_le(&mut self) -> Result<i16> {
        Ok(self.read_u16_add_le()? as i16)
    }

    /// Reads an unsigned medium as big endian
    ///
    /// # Examples
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![1, 2, 3]);
    /// assert_eq!(rdr.read_u24().unwrap(), 66051);
    /// ```
    #[inline]
    fn read_u24(&mut self) -> Result<u32> {
        let mut buf = [0; 3];
        self.read_exact(&mut buf)?;
        Ok(u32::from_be_bytes([0, buf[0], buf[1], buf[2]]))
    }

    /// Reads an unsigned medium as little endian
    ///
    /// # Examples
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u24_le(&mut self) -> Result<u32> {
        let mut buf = [0; 3];
        self.read_exact(&mut buf)?;
        Ok(u32::from_le_bytes([buf[0], buf[1], buf[2], 0]))
    }

    /// Reads a signed medium as big endian
    ///
    /// # Examples
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![255, 255, 255]);
    /// assert_eq!(rdr.read_i24().unwrap(), 16777215);
    /// ```
    #[inline]
    fn read_i24(&mut self) -> Result<i32> {
        Ok(self.read_u24()? as i32)
    }

    /// Reads a signed medium as little endian
    ///
    /// # Examples
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i24_le(&mut self) -> Result<i32> {
        Ok(self.read_u24_le()? as i32)
    }

    /// Reads an unsigned dword as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u32(&mut self) -> Result<u32> {
        let mut buf = [0; 4];
        self.read_exact(&mut buf)?;
        Ok(u32::from_be_bytes(buf))
    }

    /// Read an unsigned dword as a smart
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x00, 0x00]);
    /// assert_eq!(rdr.read_u32_smart().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x40, 0x00]);
    /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x4000);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
    /// assert_eq!(rdr.read_u32_smart().unwrap(), 0x7FFF);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u32_smart(&mut self) -> Result<u32> {
        let peek = self.read_u8()?;
        if peek & 128 == 0 {
            Ok(((peek as u32 & 0x7F) << 8) | (self.read_u8()? as u32) & 0x7FFF)
        } else {
            Ok((((peek as u32 & 0x7F) << 24)
                | ((self.read_u8()? as u32) << 16)
                | ((self.read_u8()? as u32) << 8)
                | (self.read_u8()? as u32))
                & 0x7FFFFFFF)
        }
    }

    /// Reads an unsigned dword as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u32_le(&mut self) -> Result<u32> {
        let mut buf = [0; 4];
        self.read_exact(&mut buf)?;
        Ok(u32::from_le_bytes(buf))
    }

    /// Reads an unsigned dword as middle endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    ///
    /// ```
    #[inline]
    fn read_u32_me(&mut self) -> Result<u32> {
        Ok((self.read_u16_le()? as u32) << 16 | (self.read_u16_le()? as u32))
    }

    /// Reads an unsigned dword as inversed middle endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    ///
    /// ```
    #[inline]
    fn read_u32_ime(&mut self) -> Result<u32> {
        Ok((self.read_u16()? as u32) | ((self.read_u16()? as u32) << 16))
    }

    /// Reads a signed dword as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i32(&mut self) -> Result<i32> {
        Ok(self.read_u32()? as i32)
    }

    /// Read an signed dword as a smart
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x00, 0x00]);
    /// assert_eq!(rdr.read_i32_smart().unwrap(), -0x4000);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x40, 0x00]);
    /// assert_eq!(rdr.read_i32_smart().unwrap(), 0);
    /// ```
    ///
    /// ```rust
    /// use std::io::Cursor;
    /// use osrs_bytes::ReadExt;
    ///
    /// let mut rdr = Cursor::new(vec![0x7F, 0xFF]);
    /// assert_eq!(rdr.read_i32_smart().unwrap(), 0x3FFF);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i32_smart(&mut self) -> Result<i32> {
        let peek = self.read_u8()?;
        if peek & 128 == 0 {
            Ok((((peek as i32 & 0x7F) << 8) | (self.read_u8()? as i32) & 0x7FFF) - 0x4000)
        } else {
            Ok(((((peek as i32 & 0x7F) << 24)
                | ((self.read_u8()? as i32) << 16)
                | ((self.read_u8()? as i32) << 8)
                | (self.read_u8()? as i32))
                & 0x7FFFFFFF)
                - 0x40000000)
        }
    }

    /// Reads an signed dword as little endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i32_le(&mut self) -> Result<i32> {
        Ok(self.read_u32_le()? as i32)
    }

    /// Reads an signed dword as middle endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    ///
    /// ```
    #[inline]
    fn read_i32_me(&mut self) -> Result<i32> {
        Ok(self.read_u32_me()? as i32)
    }

    /// Reads an unsigned dword as inversed middle endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    ///
    /// ```
    #[inline]
    fn read_i32_ime(&mut self) -> Result<i32> {
        Ok(self.read_u32_ime()? as i32)
    }

    /// Reads an unsigned dword as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_u64(&mut self) -> Result<u64> {
        let mut buf = [0; 8];
        self.read_exact(&mut buf)?;
        Ok(u64::from_be_bytes(buf))
    }

    /// Reads an signed dword as big endian
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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);
    /// ```
    #[inline]
    fn read_i64(&mut self) -> Result<i64> {
        Ok(self.read_u64()? as i64)
    }

    /// Reads a CP1252 string
    ///
    /// # Examples
    ///
    /// ```rust
    /// 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");
    /// ```
    #[inline]
    fn read_string_cp1252(&mut self) -> Result<String> {
        let mut str = Vec::new();

        while let Ok(x) = self.read_u8() {
            if x != 0 {
                str.push(x);
            } else {
                break;
            }
        }

        let s = match std::str::from_utf8(&str) {
            Ok(v) => v,
            Err(e) => {
                return Err(Error::new(
                    ErrorKind::Other,
                    format!("Invalid UTF-8 sequence: {}", e),
                ))
            }
        };

        Ok(s.to_owned())
    }
}

impl<R: io::Read + ?Sized> ReadExt for R {}

pub trait WriteExt: Write {
    /// Writes an unsigned byte to the writer.
    ///
    /// Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8(42).unwrap();
    /// assert_eq!(wtr[0], 42);
    /// ```
    #[inline]
    fn write_u8(&mut self, n: u8) -> Result<()> {
        self.write_all(&[n])
    }

    /// Writes an unsigned byte to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_add(42).unwrap();
    /// assert_eq!(wtr[0], 170);
    /// ```
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_add(128).unwrap();
    /// assert_eq!(wtr[0], 0);
    /// ```
    #[inline]
    fn write_u8_add(&mut self, n: u8) -> Result<()> {
        self.write_u8(n.wrapping_add(128))
    }

    /// Writes an unsigned byte to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_neg(42).unwrap();
    /// assert_eq!(wtr[0], 214);
    /// ```
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_neg(0).unwrap();
    /// assert_eq!(wtr[0], 0);
    /// ```
    #[inline]
    fn write_u8_neg(&mut self, n: u8) -> Result<()> {
        self.write_u8(0u8.wrapping_sub(n))
    }

    /// Writes an unsigned byte to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_sub(42).unwrap();
    /// assert_eq!(wtr[0], 86);
    /// ```
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u8_sub(128).unwrap();
    /// assert_eq!(wtr[0], 0);
    /// ```
    #[inline]
    fn write_u8_sub(&mut self, n: u8) -> Result<()> {
        self.write_u8(128u8.wrapping_sub(n))
    }

    /// Writes an signed byte to the writer.
    ///
    /// Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i8(-67).unwrap();
    /// assert_eq!(wtr[0] as i8, -67);
    /// ```
    #[inline]
    fn write_i8(&mut self, n: i8) -> Result<()> {
        self.write_u8(n as u8)
    }

    /// Writes the number 128, subtracted by the signed byte to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i8_sub(99).unwrap();
    /// assert_eq!(wtr[0] as i8, 29);
    /// ```
    #[inline]
    fn write_i8_sub(&mut self, n: i8) -> Result<()> {
        self.write_u8_sub(n as u8)
    }

    /// Writes the byte and adds 128.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i8_add(42).unwrap();
    /// assert_eq!(wtr[0], 170);
    /// ```
    #[inline]
    fn write_i8_add(&mut self, n: i8) -> Result<()> {
        self.write_u8_add(n as u8)
    }

    /// Writes a negated byte to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i8_neg(55).unwrap();
    /// assert_eq!(wtr[0], 201);
    /// ```
    #[inline]
    fn write_i8_neg(&mut self, n: i8) -> Result<()> {
        self.write_u8_neg(n as u8)
    }

    /// Writes a bool to the writer.
    ///
    /// Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_bool(true).unwrap();
    /// assert_eq!(wtr[0], 1);
    /// ```
    #[inline]
    fn write_bool(&mut self, b: bool) -> Result<()> {
        self.write_all(&[b as u8])
    }

    /// Writes an unsigned short to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u16(20065).unwrap();
    /// assert_eq!(wtr[0], 78);
    /// assert_eq!(wtr[1], 97);
    /// ```
    #[inline]
    fn write_u16(&mut self, n: u16) -> Result<()> {
        self.write_all(&n.to_be_bytes())
    }

    /// Writes an unsigned short as a little endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u16_le(29543).unwrap();
    /// assert_eq!(wtr[0], 103);
    /// assert_eq!(wtr[1], 115);
    /// ```
    ///
    #[inline]
    fn write_u16_le(&mut self, n: u16) -> Result<()> {
        self.write_all(&n.to_le_bytes())
    }

    /// 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.
    ///
    /// ```rust
    /// use osrs_bytes::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.
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_u16_smart(986).unwrap();
    /// assert_eq!(wtr[0], 131);
    /// assert_eq!(wtr[1], 218);
    /// ```
    ///
    #[inline]
    fn write_u16_smart(&mut self, n: u16) -> Result<()> {
        match n {
            0..=127 => self.write_u8(n as u8),
            128..=32767 => self.write_u16(n + 32768),
            _ => Err(Error::new(
                ErrorKind::Other,
                format!("Failed writing smart, value is {}", n),
            )),
        }
    }

    /// Writes a signed short to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i16(-14632).unwrap();
    /// assert_eq!(wtr[0], 198);
    /// assert_eq!(wtr[1], 216);
    /// ```
    #[inline]
    fn write_i16(&mut self, n: i16) -> Result<()> {
        self.write_u16(n as u16)
    }

    /// Writes a signed short as little endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i16_le(-7654).unwrap();
    /// assert_eq!(wtr[0], 26);
    /// assert_eq!(wtr[1], 226);
    /// ```
    #[inline]
    fn write_i16_le(&mut self, n: i16) -> Result<()> {
        self.write_u16_le(n as u16)
    }

    /// Writes a signed short add to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i16_add(-9867).unwrap();
    /// assert_eq!(wtr[0], 217);
    /// assert_eq!(wtr[1], 245);
    /// ```
    ///
    #[inline]
    fn write_i16_add(&mut self, n: i16) -> Result<()> {
        self.write_i8((n >> 8) as i8)?;
        self.write_i8((n + 128) as i8)
    }

    /// Writes a signed short add as a little endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::WriteExt;
    ///
    /// let mut wtr = Vec::new();
    /// wtr.write_i16_add_le(-12632).unwrap();
    /// assert_eq!(wtr[0], 40);
    /// assert_eq!(wtr[1], 206);
    /// ```
    ///
    #[inline]
    fn write_i16_add_le(&mut self, n: i16) -> Result<()> {
        self.write_i8((n + 128) as i8)?;
        self.write_i8((n >> 8) as i8)
    }

    /// Writes an unsigned dword to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_u32(&mut self, n: u32) -> Result<()> {
        self.write_all(&n.to_be_bytes())
    }

    /// Writes am unsigned integer as little endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_u32_le(&mut self, n: u32) -> Result<()> {
        self.write_all(&n.to_le_bytes())
    }

    /// Writes a signed dword to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_i32(&mut self, n: i32) -> Result<()> {
        self.write_u32(n as u32)
    }

    /// Writes a signed integer as little endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_i32_le(&mut self, n: i32) -> Result<()> {
        self.write_u32_le(n as u32)
    }

    /// Writes a signed dword as a middle endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_i32_me(&mut self, n: i32) -> Result<()> {
        self.write_i16_le((n >> 16) as i16)?;
        self.write_i16_le(n as i16)
    }

    /// Writes a signed dword as an inversed middle endian to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_i32_ime(&mut self, n: i32) -> Result<()> {
        self.write_i16(n as i16)?;
        self.write_i16((n >> 16) as i16)
    }

    /// Writes an unsigned qword to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_u64(&mut self, n: u64) -> Result<()> {
        self.write_all(&n.to_be_bytes())
    }

    /// Writes a signed qword to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_i64(&mut self, n: i64) -> Result<()> {
        self.write_u64(n as u64)
    }

    /// Writes a CP1252 string to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_string_cp1252<T: AsRef<str>>(&mut self, s: T) -> Result<()> {
        for b in s.as_ref().as_bytes() {
            self.write_u8(*b)?;
        }
        self.write_i8(0)
    }

    /// Write bytes reversed with add to the writer.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use osrs_bytes::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);
    /// ```
    ///
    #[inline]
    fn write_bytes_reversed_add(&mut self, buf: &[u8]) -> Result<()> {
        for b in buf.iter().rev() {
            self.write_u8_add(*b)?;
        }
        Ok(())
    }
}

impl<W: io::Write + ?Sized> WriteExt for W {}

/*
#[cfg(test)]
mod tests {
    //use super::*;

    // Tests that do not fit in documentation should be placed here.


    #[test]
    fn test_write_u8() {
        ...
    }
}
*/