use extbyteorder::ByteOrder;
use extbyteorder::ReadBytesExt as ExtReadBytesExt;
use extbyteorder::WriteBytesExt as ExtWriteBytesExt;
use std::marker::PhantomData;
use std::io::{Result, Read, Write};
use std::ops::{Deref, DerefMut};
use super::super::{ReadAt, WriteAt};
use super::{ReadBytesExt, WriteBytesExt};
pub trait ReadInt: Read {
fn read_u16(&mut self) -> Result<u16>;
fn read_i16(&mut self) -> Result<i16>;
fn read_u32(&mut self) -> Result<u32>;
fn read_i32(&mut self) -> Result<i32>;
fn read_u64(&mut self) -> Result<u64>;
fn read_i64(&mut self) -> Result<i64>;
fn read_uint(&mut self, nbytes: usize) -> Result<u64>;
fn read_int(&mut self, nbytes: usize) -> Result<i64>;
fn read_f32(&mut self) -> Result<f32>;
fn read_f64(&mut self) -> Result<f64>;
}
pub trait WriteInt: Write {
fn write_u16(&mut self, n: u16) -> Result<()>;
fn write_i16(&mut self, n: i16) -> Result<()>;
fn write_u32(&mut self, n: u32) -> Result<()>;
fn write_i32(&mut self, n: i32) -> Result<()>;
fn write_u64(&mut self, n: u64) -> Result<()>;
fn write_i64(&mut self, n: i64) -> Result<()>;
fn write_uint(&mut self, n: u64, nbytes: usize) -> Result<()>;
fn write_int(&mut self, n: i64, nbytes: usize) -> Result<()>;
fn write_f32(&mut self, n: f32) -> Result<()>;
fn write_f64(&mut self, n: f64) -> Result<()>;
}
pub trait ReadIntAt: ReadAt {
fn read_u16_at(&self, pos: u64) -> Result<u16>;
fn read_i16_at(&self, pos: u64) -> Result<i16>;
fn read_u32_at(&self, pos: u64) -> Result<u32>;
fn read_i32_at(&self, pos: u64) -> Result<i32>;
fn read_u64_at(&self, pos: u64) -> Result<u64>;
fn read_i64_at(&self, pos: u64) -> Result<i64>;
fn read_uint_at(&self, pos: u64, nbytes: usize) -> Result<u64>;
fn read_int_at(&self, pos: u64, nbytes: usize) -> Result<i64>;
fn read_f32_at(&self, pos: u64) -> Result<f32>;
fn read_f64_at(&self, pos: u64) -> Result<f64>;
}
pub trait WriteIntAt: WriteAt {
fn write_u16_at(&mut self, pos: u64, n: u16) -> Result<()>;
fn write_i16_at(&mut self, pos: u64, n: i16) -> Result<()>;
fn write_u32_at(&mut self, pos: u64, n: u32) -> Result<()>;
fn write_i32_at(&mut self, pos: u64, n: i32) -> Result<()>;
fn write_u64_at(&mut self, pos: u64, n: u64) -> Result<()>;
fn write_i64_at(&mut self, pos: u64, n: i64) -> Result<()>;
fn write_uint_at(&mut self, pos: u64, n: u64, nbytes: usize) -> Result<()>;
fn write_int_at(&mut self, pos: u64, n: i64, nbytes: usize) -> Result<()>;
fn write_f32_at(&mut self, pos: u64, n: f32) -> Result<()>;
fn write_f64_at(&mut self, pos: u64, n: f64) -> Result<()>;
}
pub struct ByteIo<I, E: ByteOrder> {
io: I,
endianness: PhantomData<E>,
}
impl<I, E> ByteIo<I, E>
where E: ByteOrder
{
pub fn new(io: I) -> Self {
ByteIo {
io: io,
endianness: PhantomData,
}
}
}
impl<I, E> Deref for ByteIo<I, E>
where E: ByteOrder
{
type Target = I;
fn deref(&self) -> &I {
&self.io
}
}
impl<I, E> DerefMut for ByteIo<I, E>
where E: ByteOrder
{
fn deref_mut(&mut self) -> &mut I {
&mut self.io
}
}
impl<I, E: ByteOrder> Read for ByteIo<I, E>
where I: Read
{
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
self.io.read(buf)
}
}
impl<I, E: ByteOrder> Write for ByteIo<I, E>
where I: Write
{
fn write(&mut self, buf: &[u8]) -> Result<usize> {
self.io.write(buf)
}
fn flush(&mut self) -> Result<()> {
self.io.flush()
}
}
impl<I, E: ByteOrder> ReadAt for ByteIo<I, E>
where I: ReadAt
{
fn read_at(&self, pos: u64, buf: &mut [u8]) -> Result<usize> {
self.io.read_at(pos, buf)
}
}
impl<I, E: ByteOrder> WriteAt for ByteIo<I, E>
where I: WriteAt
{
fn write_at(&mut self, pos: u64, buf: &[u8]) -> Result<usize> {
self.io.write_at(pos, buf)
}
fn flush(&mut self) -> Result<()> {
self.io.flush()
}
}
impl<I, E: ByteOrder> ReadInt for ByteIo<I, E>
where I: Read
{
fn read_u16(&mut self) -> Result<u16> {
self.io.read_u16::<E>()
}
fn read_i16(&mut self) -> Result<i16> {
self.io.read_i16::<E>()
}
fn read_u32(&mut self) -> Result<u32> {
self.io.read_u32::<E>()
}
fn read_i32(&mut self) -> Result<i32> {
self.io.read_i32::<E>()
}
fn read_u64(&mut self) -> Result<u64> {
self.io.read_u64::<E>()
}
fn read_i64(&mut self) -> Result<i64> {
self.io.read_i64::<E>()
}
fn read_uint(&mut self, nbytes: usize) -> Result<u64> {
self.io.read_uint::<E>(nbytes)
}
fn read_int(&mut self, nbytes: usize) -> Result<i64> {
self.io.read_int::<E>(nbytes)
}
fn read_f32(&mut self) -> Result<f32> {
self.io.read_f32::<E>()
}
fn read_f64(&mut self) -> Result<f64> {
self.io.read_f64::<E>()
}
}
impl<I, E: ByteOrder> WriteInt for ByteIo<I, E>
where I: Write
{
fn write_u16(&mut self, n: u16) -> Result<()> {
self.io.write_u16::<E>(n)
}
fn write_i16(&mut self, n: i16) -> Result<()> {
self.io.write_i16::<E>(n)
}
fn write_u32(&mut self, n: u32) -> Result<()> {
self.io.write_u32::<E>(n)
}
fn write_i32(&mut self, n: i32) -> Result<()> {
self.io.write_i32::<E>(n)
}
fn write_u64(&mut self, n: u64) -> Result<()> {
self.io.write_u64::<E>(n)
}
fn write_i64(&mut self, n: i64) -> Result<()> {
self.io.write_i64::<E>(n)
}
fn write_uint(&mut self, n: u64, nbytes: usize) -> Result<()> {
self.io.write_uint::<E>(n, nbytes)
}
fn write_int(&mut self, n: i64, nbytes: usize) -> Result<()> {
self.io.write_int::<E>(n, nbytes)
}
fn write_f32(&mut self, n: f32) -> Result<()> {
self.io.write_f32::<E>(n)
}
fn write_f64(&mut self, n: f64) -> Result<()> {
self.io.write_f64::<E>(n)
}
}
impl<I, E: ByteOrder> ReadIntAt for ByteIo<I, E>
where I: ReadAt
{
fn read_u16_at(&self, pos: u64) -> Result<u16> {
self.io.read_u16_at::<E>(pos)
}
fn read_i16_at(&self, pos: u64) -> Result<i16> {
self.io.read_i16_at::<E>(pos)
}
fn read_u32_at(&self, pos: u64) -> Result<u32> {
self.io.read_u32_at::<E>(pos)
}
fn read_i32_at(&self, pos: u64) -> Result<i32> {
self.io.read_i32_at::<E>(pos)
}
fn read_u64_at(&self, pos: u64) -> Result<u64> {
self.io.read_u64_at::<E>(pos)
}
fn read_i64_at(&self, pos: u64) -> Result<i64> {
self.io.read_i64_at::<E>(pos)
}
fn read_uint_at(&self, pos: u64, nbytes: usize) -> Result<u64> {
self.io.read_uint_at::<E>(pos, nbytes)
}
fn read_int_at(&self, pos: u64, nbytes: usize) -> Result<i64> {
self.io.read_int_at::<E>(pos, nbytes)
}
fn read_f32_at(&self, pos: u64) -> Result<f32> {
self.io.read_f32_at::<E>(pos)
}
fn read_f64_at(&self, pos: u64) -> Result<f64> {
self.io.read_f64_at::<E>(pos)
}
}
impl<I, E: ByteOrder> WriteIntAt for ByteIo<I, E>
where I: WriteAt
{
fn write_u16_at(&mut self, pos: u64, n: u16) -> Result<()> {
self.io.write_u16_at::<E>(pos, n)
}
fn write_i16_at(&mut self, pos: u64, n: i16) -> Result<()> {
self.io.write_i16_at::<E>(pos, n)
}
fn write_u32_at(&mut self, pos: u64, n: u32) -> Result<()> {
self.io.write_u32_at::<E>(pos, n)
}
fn write_i32_at(&mut self, pos: u64, n: i32) -> Result<()> {
self.io.write_i32_at::<E>(pos, n)
}
fn write_u64_at(&mut self, pos: u64, n: u64) -> Result<()> {
self.io.write_u64_at::<E>(pos, n)
}
fn write_i64_at(&mut self, pos: u64, n: i64) -> Result<()> {
self.io.write_i64_at::<E>(pos, n)
}
fn write_uint_at(&mut self, pos: u64, n: u64, nbytes: usize) -> Result<()> {
self.io.write_uint_at::<E>(pos, n, nbytes)
}
fn write_int_at(&mut self, pos: u64, n: i64, nbytes: usize) -> Result<()> {
self.io.write_int_at::<E>(pos, n, nbytes)
}
fn write_f32_at(&mut self, pos: u64, n: f32) -> Result<()> {
self.io.write_f32_at::<E>(pos, n)
}
fn write_f64_at(&mut self, pos: u64, n: f64) -> Result<()> {
self.io.write_f64_at::<E>(pos, n)
}
}