use nom::{IResult, Needed};

pub enum ErrorKind {
  EndOfInput,
  Unknown,
}

pub trait StreamProducer {
  fn parse<F, T>(&mut self, f: F) -> Result<T, ErrorKind>
   where F: FnOnce(&[u8]) -> IResult<&[u8], T>;
}

pub struct ByteStream<'a> {
  offset: usize,
  bytes: &'a [u8],
}

impl<'a> ByteStream<'a> {
  pub fn new(bytes: &'a [u8]) -> Self {
    ByteStream {
      offset: 0,
      bytes: bytes,
    }
  }

  #[inline]
  pub fn len(&self) -> usize {
    self.bytes.len() - self.offset
  }

  #[inline]
  pub fn is_empty(&self) -> bool {
    self.len() == 0
  }
}

impl<'a> StreamProducer for ByteStream<'a> {
  fn parse<F, T>(&mut self, f: F) -> Result<T, ErrorKind>
   where F: FnOnce(&[u8]) -> IResult<&[u8], T> {
    if self.is_empty() {
      return Err(ErrorKind::EndOfInput);
    }

    match f(&self.bytes[self.offset..]) {
      IResult::Done(i, o)    => {
        self.offset += self.len() - i.len();

        Ok(o)
      }
      IResult::Incomplete(n) => {
        let mut needed = self.len();

        if let Needed::Size(size) = n {
          needed = size;
        }

        Err(ErrorKind::Incomplete(needed))
      }
      IResult::Error(_)      => Err(ErrorKind::Unknown),
    }
  }
}

use nom::IResult;

pub trait StreamProducer {
  fn parse<F, T>(&mut self, f: F) -> Result<T, ErrorKind>
   where F: FnOnce(&[u8]) -> IResult<&[u8], T>;
}

--- 
+++ 
@@ -1,62 +1,6 @@
-use nom::{IResult, Needed};
-
-pub enum ErrorKind {
-  EndOfInput,
-  Unknown,
-}
+use nom::IResult;
 
 pub trait StreamProducer {
   fn parse<F, T>(&mut self, f: F) -> Result<T, ErrorKind>
    where F: FnOnce(&[u8]) -> IResult<&[u8], T>;
 }
-
-pub struct ByteStream<'a> {
-  offset: usize,
-  bytes: &'a [u8],
-}
-
-impl<'a> ByteStream<'a> {
-  pub fn new(bytes: &'a [u8]) -> Self {
-    ByteStream {
-      offset: 0,
-      bytes: bytes,
-    }
-  }
-
-  #[inline]
-  pub fn len(&self) -> usize {
-    self.bytes.len() - self.offset
-  }
-
-  #[inline]
-  pub fn is_empty(&self) -> bool {
-    self.len() == 0
-  }
-}
-
-impl<'a> StreamProducer for ByteStream<'a> {
-  fn parse<F, T>(&mut self, f: F) -> Result<T, ErrorKind>
-   where F: FnOnce(&[u8]) -> IResult<&[u8], T> {
-    if self.is_empty() {
-      return Err(ErrorKind::EndOfInput);
-    }
-
-    match f(&self.bytes[self.offset..]) {
-      IResult::Done(i, o)    => {
-        self.offset += self.len() - i.len();
-
-        Ok(o)
-      }
-      IResult::Incomplete(n) => {
-        let mut needed = self.len();
-
-        if let Needed::Size(size) = n {
-          needed = size;
-        }
-
-        Err(ErrorKind::Incomplete(needed))
-      }
-      IResult::Error(_)      => Err(ErrorKind::Unknown),
-    }
-  }
-}
Add `ByteStream` for entire files of a byte slice
