use futures::prelude::*;
use std::io;

/// Copies the entire contents of a reader into a writer.
///
/// This function will continuously read data from `reader` and then
/// write it into `writer` in a streaming fashion until `reader`
/// returns EOF.
///
/// On success, the total number of bytes that were copied from
/// `reader` to `writer` is returned.
///
/// If you’re wanting to copy the contents of one file to another and you’re
/// working with filesystem paths, see the [`fs::copy`] function.
///
/// This function is an async version of [`std::fs::write`].
///
/// [`std::io::copy`]: https://doc.rust-lang.org/std/io/fn.copy.html
/// [`fs::copy`]: ../fs/fn.copy.html
///
/// # Errors
///
/// This function will return an error immediately if any call to `read` or
/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
/// handled by this function and the underlying operation is retried.
///
/// # Examples
///
/// ```
/// # #![feature(async_await)]
/// use async_std::{io, task};
///
/// fn main() -> std::io::Result<()> {
///     task::block_on(async {
///         let mut reader: &[u8] = b"hello";
///         let mut writer: Vec<u8> = vec![];
///
///         io::copy(&mut reader, &mut writer).await?;
///
///         assert_eq!(&b"hello"[..], &writer[..]);
///         Ok(())
///     })
/// }
/// ```
pub async fn copy<R, W>(reader: &mut R, writer: &mut W) -> io::Result<u64>
where
    R: AsyncRead + Unpin + ?Sized,
    W: AsyncWrite + Unpin + ?Sized,
{
    let bytes_read = reader.copy_into(writer).await?;
    Ok(bytes_read)
}