1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::io;
use buf_redux_reexport as br;

use BufReadGrow;

impl<'a, B: BufReadGrow + ?Sized> BufReadGrow for &'a mut B {
    #[inline]
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        (**self).grow_buf()
    }
    #[inline]
    fn fill_buf_min(&mut self, size: usize) -> io::Result<&[u8]> {
        (**self).fill_buf_min(size)
    }
    #[inline]
    fn read_until2(&mut self, delims: (u8, u8), buf: &mut Vec<u8>) -> io::Result<()> {
        (**self).read_until2(delims, buf)
    }
    #[inline]
    fn skip_until2(&mut self, delims: (u8, u8)) -> io::Result<()> {
        (**self).skip_until2(delims)
    }
}

impl<B: BufReadGrow + ?Sized> BufReadGrow for Box<B> {
    #[inline]
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        (**self).grow_buf()
    }
    #[inline]
    fn fill_buf_min(&mut self, size: usize) -> io::Result<&[u8]> {
        (**self).fill_buf_min(size)
    }
    #[inline]
    fn read_until2(&mut self, delims: (u8, u8), buf: &mut Vec<u8>) -> io::Result<()> {
        (**self).read_until2(delims, buf)
    }
    #[inline]
    fn skip_until2(&mut self, delims: (u8, u8)) -> io::Result<()> {
        (**self).skip_until2(delims)
    }
}

impl BufReadGrow for io::Empty {
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Stream is already at EOF"))
    }
}

impl<'a> BufReadGrow for &'a [u8] {
    #[inline]
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Stream is already at EOF"))
    }
}

impl<T> BufReadGrow for io::Cursor<T>
    where T: AsRef<[u8]>
{
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Stream is already at EOF"))
    }
}

impl<R, Rs, Ms> BufReadGrow for br::BufReader<R, Rs, Ms>
    where R: io::Read,
          Rs: br::strategy::ReadStrategy,
          Ms: br::strategy::MoveStrategy
{
    fn grow_buf(&mut self) -> io::Result<&[u8]> {
        if self.available() == self.capacity() {
            return Err(io::Error::new(io::ErrorKind::Other,
                                      "No bytes could be read because the buffer is full"));
        }

        match try!(self.read_into_buf()) {
            0 => {
                Err(io::Error::new(io::ErrorKind::UnexpectedEof, "Stream is already at EOF"))
            }
            _ => Ok(self.get_buf()),
        }
    }
}

#[cfg(test)]
mod tests {
    use buf_redux_reexport as br;
    use std::io;
    use {Stream, Read, BufReadGrow};
    use mock::MockRead;

    #[test]
    fn bufreader_bufreadgrow_3of3() {
        let mut reader = io::repeat(0).take(3).limited(1).buffer();
        assert_eq!(reader.fill_buf_min(3).unwrap().len(), 3);
    }

        #[test]
    fn bufreader_bufreadgrow_4of3() {
        let mut reader = io::repeat(0).take(3).limited(1).buffer();
        assert_eq!(reader.fill_buf_min(4).unwrap_err().kind(),
                   io::ErrorKind::UnexpectedEof);
    }

    #[test]
    fn bufreader_bufreadgrow_3of3_smallbuf() {
        let mut reader = br::BufReader::with_capacity(3, io::repeat(0).limited(1));
        assert_eq!(reader.fill_buf_min(3).unwrap().len(), 3);
    }

    #[test]
    fn bufreader_bufreadgrow_4of3_smallbuf() {
        let mut reader = br::BufReader::with_capacity(3, io::repeat(0).limited(1));
        assert_eq!(reader.fill_buf_min(4).unwrap_err().kind(),
                   io::ErrorKind::Other);
    }
}