Merge pull request #29 from 3Hren/master

Add `read` free function to read some bytes

src/io/mod.rs

@@ -35,6 +35,7 @@ mod copy;
 mod flush;
 mod read_exact;
 mod read_to_end;
+mod read;
 mod split;
 mod window;
 mod write_all;
@@ -42,6 +43,7 @@ pub use self::copy::{copy, Copy};
 pub use self::flush::{flush, Flush};
 pub use self::read_exact::{read_exact, ReadExact};
 pub use self::read_to_end::{read_to_end, ReadToEnd};
+pub use self::read::read;
 pub use self::split::{ReadHalf, WriteHalf};
 pub use self::window::Window;
 pub use self::write_all::{write_all, WriteAll};

src/io/read.rs

@@ -0,0 +1,51 @@
+use std::mem;
+
+use futures::{Future, Poll};
+
+enum State<R, T> {
+    Pending {
+        rd: R,
+        buf: T,
+    },
+    Empty,
+}
+
+/// Tries to read some bytes directly into the given `buf` in asynchronous
+/// manner, returning a future type.
+///
+/// The returned future will resolve to both the I/O stream as well as the
+/// buffer once the read operation is completed.
+pub fn read<R, T>(rd: R, buf: T) -> Read<R, T>
+    where R: ::std::io::Read,
+          T: AsMut<[u8]>
+{
+    Read { state: State::Pending { rd: rd, buf: buf } }
+}
+
+/// A future which can be used to easily read available number of bytes to fill
+/// a buffer.
+///
+/// Created by the [`read`] function.
+pub struct Read<R, T> {
+    state: State<R, T>,
+}
+
+impl<R, T> Future for Read<R, T>
+    where R: ::std::io::Read,
+          T: AsMut<[u8]>
+{
+    type Item = (R, T, usize);
+    type Error = ::std::io::Error;
+
+    fn poll(&mut self) -> Poll<(R, T, usize), ::std::io::Error> {
+        let nread = match self.state {
+            State::Pending { ref mut rd, ref mut buf } => try_nb!(rd.read(&mut buf.as_mut()[..])),
+            State::Empty => panic!("poll a Read after it's done"),
+        };
+
+        match mem::replace(&mut self.state, State::Empty) {
+            State::Pending { rd, buf } => Ok((rd, buf, nread).into()),
+            State::Empty => panic!("invalid internal state"),
+        }
+    }
+}