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,6 +1,62 @@
-use nom::IResult;
+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),
+    }
+  }
+}
Add `ByteStream` for entire files of a byte slice
