xio_common 0.12.0

use byteorder::{ByteOrder, ReadBytesExt, WriteBytesExt};
use crate::error::Io;
use snafu::ResultExt;
use std::io::{Read, Write};
use crate::Result;

pub(crate) trait ReadExt: ReadBytesExt {
    fn read_u8(&mut self) -> Result<u8> {
        ReadBytesExt::read_u8(self).context(Io)
    }

    fn read_i8(&mut self) -> Result<i8> {
        ReadBytesExt::read_i8(self).context(Io)
    }

    fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> {
        ReadBytesExt::read_u16::<T>(self).context(Io)
    }

    fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> {
        ReadBytesExt::read_i16::<T>(self).context(Io)
    }

    fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> {
        ReadBytesExt::read_u32::<T>(self).context(Io)
    }

    fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> {
        ReadBytesExt::read_i32::<T>(self).context(Io)
    }

    fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> {
        ReadBytesExt::read_u64::<T>(self).context(Io)
    }

    fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> {
        ReadBytesExt::read_i64::<T>(self).context(Io)
    }
}

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

pub(crate) trait WriteExt: WriteBytesExt {
    fn write_u8(&mut self, n: u8) -> Result<()> {
        WriteBytesExt::write_u8(self, n).context(Io)
    }

    fn write_i8(&mut self, n: i8) -> Result<()> {
        WriteBytesExt::write_i8(self, n).context(Io)
    }

    fn write_u16<T: ByteOrder>(&mut self, n: u16) -> Result<()> {
        WriteBytesExt::write_u16::<T>(self, n).context(Io)
    }

    fn write_i16<T: ByteOrder>(&mut self, n: i16) -> Result<()> {
        WriteBytesExt::write_i16::<T>(self, n).context(Io)
    }

    fn write_u32<T: ByteOrder>(&mut self, n: u32) -> Result<()> {
        WriteBytesExt::write_u32::<T>(self, n).context(Io)
    }

    fn write_i32<T: ByteOrder>(&mut self, n: i32) -> Result<()> {
        WriteBytesExt::write_i32::<T>(self, n).context(Io)
    }

    fn write_u64<T: ByteOrder>(&mut self, n: u64) -> Result<()> {
        WriteBytesExt::write_u64::<T>(self, n).context(Io)
    }

    fn write_i64<T: ByteOrder>(&mut self, n: i64) -> Result<()> {
        WriteBytesExt::write_i64::<T>(self, n).context(Io)
    }

    fn write_all_(&mut self, buf: &[u8]) -> Result<()> {
        Write::write_all(self, buf).context(Io)
    }
}

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