futures_util/io/
allow_std.rsuse futures_core::{Async, Poll, task};
use futures_io::{AsyncRead, AsyncWrite};
use std::{fmt, io};
use std::string::String;
use std::vec::Vec;
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct AllowStdIo<T>(T);
macro_rules! try_with_interrupt {
($e:expr) => {
loop {
match $e {
Ok(e) => {
break e;
}
Err(ref e) if e.kind() == ::std::io::ErrorKind::Interrupted => {
continue;
}
Err(e) => {
return Err(e);
}
}
}
}
}
impl<T> AllowStdIo<T> {
pub fn new(io: T) -> Self {
AllowStdIo(io)
}
pub fn get_ref(&self) -> &T {
&self.0
}
pub fn get_mut(&mut self) -> &mut T {
&mut self.0
}
pub fn into_inner(self) -> T {
self.0
}
}
impl<T> io::Write for AllowStdIo<T> where T: io::Write {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.0.flush()
}
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
self.0.write_all(buf)
}
fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
self.0.write_fmt(fmt)
}
}
impl<T> AsyncWrite for AllowStdIo<T> where T: io::Write {
fn poll_write(&mut self, _: &mut task::Context, buf: &[u8])
-> Poll<usize, io::Error>
{
Ok(Async::Ready(try_with_interrupt!(io::Write::write(&mut self.0, buf))))
}
fn poll_flush(&mut self, _: &mut task::Context) -> Poll<(), io::Error> {
Ok(Async::Ready(try_with_interrupt!(io::Write::flush(self))))
}
fn poll_close(&mut self, cx: &mut task::Context) -> Poll<(), io::Error> {
self.poll_flush(cx)
}
}
impl<T> io::Read for AllowStdIo<T> where T: io::Read {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.0.read(buf)
}
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
self.0.read_to_end(buf)
}
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
self.0.read_to_string(buf)
}
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
self.0.read_exact(buf)
}
}
impl<T> AsyncRead for AllowStdIo<T> where T: io::Read {
fn poll_read(&mut self, _: &mut task::Context, buf: &mut [u8])
-> Poll<usize, io::Error>
{
Ok(Async::Ready(try_with_interrupt!(io::Read::read(&mut self.0, buf))))
}
}