Add NoSeek wrapper type for io::Read -> io::Read + io::Seek

[jam1garner]

The idea would be that for format that don't involve any reverse seeking, io::Seek can be implemented in terms of just a position tracker an io::Read. This would better enable BinRead to be used for streaming use-cases (networking, serial connection, etc)

This issue is replacing #6 as I feel it didn't adequately reflect the state of the project

[m4tx]

+1 for this, requiring io::Seek is very annoying

[m4tx]

I've actually written a simple NoSeek wrapper in my project. It seems that at least for my use case, the only seeks the library is doing are no-ops, so it works perfectly fine. I've needed it to support stdin/stdout for reading and writing.

use std::io::{Read, Seek, Write};

pub struct NoSeek<T> {
    inner: T,
    position: u64,
}

impl<T> NoSeek<T> {
    pub fn new(inner: T) -> Self {
        Self { inner, position: 0 }
    }
}

impl<T> Seek for NoSeek<T> {
    fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
        match pos {
            std::io::SeekFrom::Start(i) => {
                if i == self.position {
                    Ok(self.position)
                } else {
                    unimplemented!()
                }
            }
            std::io::SeekFrom::End(_) => unimplemented!(),
            std::io::SeekFrom::Current(i) => {
                if i == 0 {
                    Ok(self.position)
                } else {
                    unimplemented!()
                }
            }
        }
    }
}

impl<R: Read> Read for NoSeek<R> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        let size = self.inner.read(buf)?;
        self.position += size as u64;
        Ok(size)
    }

    fn read_vectored(&mut self, bufs: &mut [std::io::IoSliceMut<'_>]) -> std::io::Result<usize> {
        let size = self.inner.read_vectored(bufs)?;
        self.position += size as u64;
        Ok(size)
    }
}

impl<W: Write> Write for NoSeek<W> {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        let size = self.inner.write(buf)?;
        self.position += size as u64;
        Ok(size)
    }

    fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
        let size = self.inner.write_vectored(bufs)?;
        self.position += size as u64;
        Ok(size)
    }

    fn flush(&mut self) -> std::io::Result<()> {
        self.inner.flush()
    }
}

[jam1garner]

@m4tx I'd accept a PR with this* as an initial implementation if you'd like :)

*albeit replace unimplemented!() with an io::Error