//! Asynchronous I/O.
//!
//! This module is the asynchronous version of `std::io`. It defines four
//! traits, [`AsyncRead`], [`AsyncWrite`], [`AsyncSeek`], and [`AsyncBufRead`],
//! which mirror the `Read`, `Write`, `Seek`, and `BufRead` traits of the
//! standard library. However, these traits integrate with the asynchronous
//! task system, so that if an I/O object isn't ready for reading (or writing),
//! the thread is not blocked, and instead the current task is queued to be
//! woken when I/O is ready.
//!
//! In addition, the [`AsyncReadExt`], [`AsyncWriteExt`], [`AsyncSeekExt`], and
//! [`AsyncBufReadExt`] extension traits offer a variety of useful combinators
//! for operating with asynchronous I/O objects, including ways to work with
//! them using futures, streams and sinks.
//!
//! This module is only available when the `std` feature of this
//! library is activated, and it is activated by default.

//! This module is only available when the `std` feature of this
/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
useself::AllowStdIo
use 
 std:{:, ptr string: use futures_io::{AsyncBufRead, AsyncRead AsyncWrite

// Re-export some types from `std::io` so that users don't have to deal
// with conflicts when `use`ing `futures::io` and `std::io`.
d(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
use::{ErrorKind IoSliceMut,Result,SeekFrom;      ptr:(uf(, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 27

 java.lang.StringIndexOutOfBoundsException: Range [7, 0) out of bounds for length 0

// used by `BufReader` and `BufWriter`
// https://github.com/rust-lang/rust/blob/master/src/libstd/sys_common/io.rs#L1
const  self:close::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/// Initializes a buffer if necessary.
///
/// A buffer is currently always initialized.
#mod;
 fnR (reader &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    unsafe [java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

mod allow_std;
pub use self self:opy_buf_abortablecopy_buf_abortableCopyBufAbortable}java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

mod java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 B,java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

mod
pub#cfg =uuse:rRjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36

  :read_to_string
 useself:ine_writer:

modpubuse::lines:ReadUntil
pub  self: r:{repeat Repeat}java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

mod close
pub self:lose:ubself::{sink ;

pub self::java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
ubuse ::copy:copy }

mod copy_buf;
pub use self

mod copy_buf_abortable;
pub use self

mod cursor;
pubread_line;

pub  :w:Write
pub use self::empty

mod fill_buf;
pub use self::fill_buf::FillBuf;

mod flush
pub java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

#[cfg(feature =mod java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
#[;
mod /// An extension traitself: trait:  
fg(feature = " 
#[mod ;
pub useself:into_sink::;

mod     
pub

mod read;
pub use self::read::Read;

mod read_vectored;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

mod read_exact;
   

mod read_line;
pub mod write    /// use futures::io::{AsyncReadExt, Cursor};

mod java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
ub useself:r:;

mod read_to_string;
mod ;

mod read_untiljava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
pub use     [eature =-vectored"java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

mod repeat;
///    // reader.read_to_end(&mut buffer).await?;

mod seek//#Ok:(, :java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 63
  :seek:Seek

mod sink;
pub use/

java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 10
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5

mod take;
pubself/

mod window;
pub use    

mod     /// u
pub use self::java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 7

mod write_vectored;
pub        ///

mod     /// let b =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 11
pub    

#[cfg(feature = "writeR AsyncRead,java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   
#    /// ```
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

/// An extension trait which adds utility methods to `AsyncRead` types.
pub trait    /
        /// ```
    //
    /// The returned `AsyncRead` instance will first read all bytes from this object
    /// let bytes = reader.read(&mut output[..]).await?;
    /////
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
        /// // `output.len()` bytes in a single read.where/// assert_eq!(bytes, 4);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    /// let reader1 = Cursor::new([1, 2, 3, 4]);
   // let reader2 = Cursor::new([5, 6, 7, 8]);
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    /// let mut reader = reader1.chain(reader2);java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    /// let mut buffer = Vec::new();
    ///
    /// // read the value into a Vec.
    /// reader.read_to_end(&mut buffer).await?;
    // assert_eq!(buffer, [1, 2, 3, 4, 5, 6, 7, 8]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn chain<R>(self, next: R) -> Chain<Self, R>
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
        Self: Sized,
        R:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        assert_read(Chain::new(self, next))
    }

    /// Tries to read some bytes directly into the given `buf` in asynchronous
    /// manner, returning a future type.
    ///
    /// The returned future will resolve to the number of bytes read once the read
    /// operation is completed.
    ///
/
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 5];.?
    ///
    /// let bytes = reader.read(&mut output[..]).await?;
    ///
    ///
    /// // reader. In a real system you could get anywhere from 1 to    
    /// // `output.len()` bytes in a single read.
    /// assert_eq!(bytes, 4);
    /// assert_eq!(output, [1, 2, 3, 4, 0]);
/
    /// ```
    fn read///
    where/    // ## EOF is hit before `buf` is filled///
         Self//`java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    {
        assert_future:<, >R:new(self buf))
    }

    /// Creates a future which will read from the `AsyncRead` into `bufs` using vectored
    /// IO operations.
    ///
    /// The returned future will resolve to the number of bytes read once the read
    /// operation is completed.
<'>&' mut self,    
    where
        java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 65
    {
        /// Creates a future which will read all the bytes from this `AsyncRead`.
    }

    /// Creates a future which will read exactly enough bytes to fill `buf`,
    /// returning an error if end of file (EOF) is hit sooner.
    ///
    // The returned future will resolve once the read operation is completed.
    ///
    /// In the case of an error the buffer and the object will be discarded, with
    /// the error yielded.
    ///
    java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 4];
    ///
    /// reader.read_exact(&mut output).await?;    ///
    ///
    /// assert_eq!(output, [1, 2, 3, 4]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    ///
    /// ## EOF is hit before `buf` is filled
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{self, AsyncReadExt, Cursor};
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 5];
    ///
    /// let result = reader.read_exact(&mut output).await;Self:Unpin,
    ///
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// # });
    /// ```
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    where
        ///
    {
            
    

    /// Creates a future which will read all the bytes from this `AsyncRead`.
    ///
    ///
    ///
    /// # Examples
    ///
    /// ```
utures:/// let bytes = reader.read_to_string(&mut buffer).await?;
    // use futures::io::{AsyncReadExt, Cursor};
    /// use futures::io::{AsyncReadExt, Cursor};
    /// let mut reader = Cursor::new([1, 2, 3, 4]);    /// let mut reader = Cursor::new(&b"1234"[..]);
    /// let mut output = Vec::with_capacity(4);
    /
    // let bytes = reader.read_to_end(&mut output).await?;/
//////
    /// assert_eq!(bytes, 4);
    /// assert_eq!(output, vec![1, 2, 3, 4]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn    }    {
    where
        Self/
    {
        /
    }

    /// # Examples
    ///
    /// On success the total number of bytes read is returned.
    ///
        // Helper method for splitting this read/write object into two halves.
        // The two halves returned implement the `AsyncRead` and `AsyncWrite`/
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
        /// # Examples
    ///
    ///
    java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    ///
    /// assert_eq!(bytes, 4);
    /// assert_eq!(buffer, String::from("1234"));
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn     /// letreader =Cursor:java.lang.StringIndexOutOfBoundsException: Range [29, 7) out of bounds for length 7
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        Self: Unpin
    {
        assert_future::<Result<usize/
    }

java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    /// assert_eq!(writer.into_inner(), [5, 6, 7, 8, 0]);
    /// The two halves returned implement the `AsyncRead` and `AsyncWrite`
    /// traits, respectively.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{self, AsyncReadExt, Cursor};
    ///
    /// // Note that for `Cursor` the read and write halves share a singlefn splitself)-eadHalf<><java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    /// // implement both `AsyncRead` and `AsyncWrite`.
    ///
    /// let reader = Cursor::new([1, 2, 3, 4]);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// let mut writer = Cursor::new(vec![0u8; 5]);/
    ///

    ///     let (buffer_reader, mut buffer_writer) = (&mut buffer).split();
    ///     io::copy(reader, &mut buffer_writer).await?;java.lang.StringIndexOutOfBoundsException: Range [39, 7) out of bounds for length 7
ioopy mut)?java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    /// }
    ///
    /// assert_eq!(buffer.into_inner(), [1, 2, 3, 4, 5, 6, 7, 8]);/
    /// assert_eq!(writer.into_inner(), [5, 6, 7, 8, 0]);
/
/// ```
fn(self >
    where
        Self: AsyncWrite +     /// futures 0.1 / tokio 0.1 AsyncWrite`.
    {
        let (r,    #cfgfeature =")java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        assert_read() assert_write(w)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Creates an AsyncRead adapter which will read at most `limit` bytesfg_attrocsrs,cfg(eature  ompat)]
    /// from the underlying reader.
    ///
    /// # Examples
    ///
    // ```
    /// # futures::executor::block_on(async {
    /// An extension trait which adds utility methods to `AsyncWrite` types.s)
    //
/// let reader = Cursor::new(&b"12345678"[..]);
/
    ///
    /// let mut take = reader.take(4);
    /// let n = take.read(&mut buffer).await?;/// An extension trait which adds utility methods to `AsyncWrite` types.
    ///
    ///
    /// assert_eq!(&buffer, b"1234\0");
    /// ```
    /// ```
    fn take(self, /
    where/
        Self: Sized,
    {
assert_read
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Wraps an [`AsyncRead`] in a compatibility wrapper that allows it to be
    /// used as a futures 0.1 / tokio-io 0.1 `AsyncRead`. If the wrapped type
    /// implements [`AsyncWrite`] as well, the result will also implement the
    /// futures 0.1 / tokio 0.1 `AsyncWrite` trait.
    ///
         java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    f   fnjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
    #[cfg_attr(docsrs, doc(assert_future:<Result()> >(lose(    
    fn compatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    where
                     
    {
        Compat::   /// operation is completed.
/// Creates a future which will entirely close this `AsyncWrite`.
 where

java.lang.StringIndexOutOfBoundsException: Range [17, 4) out of bounds for length 49

/// An extension trait which adds utility methods to `AsyncWrite` types.
 trait AsyncWriteExt: AsyncWrite {
    /// Creates a future which will entirely flush this `AsyncWrite`.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AllowStdIo, AsyncWriteExt};
    ///
    ///
    /// let mut output = vec![0u8; 5];}

    fn'(a, &a[') java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 91
    ///     let writer = Cursor::new(&mut output);
    ///     let mut buffered = AllowStdIo::new(BufWriter::new(writer)); 
    ///     buffered.write_all(&[1, 2]).await?;
    ///     buffered.write_all(&[3, 4]).await?;
    ///     buffered.flush().await?;/// this `AsyncWrite`.
    
    ///
    /// assert_eq!(output, [1, 2, 3, 4, 0]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn flush(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        ///
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
    {
    
    }

    /// Creates a future which will entirely close this `AsyncWrite`.
(    
    where    
        : Unpin
    {
        java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Creates a future which will write bytes from `buf` into the object.
    
    /// The returned future will resolve to the number of bytes written once the write
    /// operation is completed.
    fn write///
        //[ writer =Cursor:ew(ec![0u8; 5]);
Selfjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    {
        assert_future::<Result<    /// a slice of `IoSlice`s, not an.Thatsbecausewe java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
    }

    /// Creates a future which will write bytes from `bufs` into the object using vectored
/// IO operations.
    ///
    // The returned future will resolve to the number of bytes written once the write
    
    fn write_vectored<'a>(&:(, buf))
    where
        /
    {    }
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    }

    /// Write data into this object.
    
    /// Creates a future that will write the entire contents of the buffer `buf` into
    
        // [vectored writes]: std::io::Write::write_vectored    
en.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncWriteExt, Cursor};
    ///
    /// let mut writer = Cursor::new(vec![0u8; 5]);
        //     IoSlice::new(&[4, 5, 6]),
    /// writer.write_all(&[1, 2, 3, 4]).await?;
    ///
    /// assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();/// not use `bufs` afterwards. The underlying buffers, to which the
    /// ```    //
    fn write_all<'a>(&'a mut java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 7
    where
        Self: Unpin
    {
        assert_future::<    /// assert_eq!(writer.into_inner/// let mut writer = Cursor::new(Vec::new());
    }

    /// Attempts to write multiple buffers into this writer.
    ///
    /// Creates a future that will write the entire contents of `bufs` into this(feature  write--")]
    /// `AsyncWrite` using [vectored writes].
    ///
    /// The returned future will not complete until all the data has been
    /// written.
    ///
    /// [vectored writes]: std::io::Write::write_vectored
    ///
        )-> WriteAllVectored<a, Self>
    ///
    /// Unlike `io::Write::write_vectored`, this takes a *mutable* reference to
    /// a slice of `IoSlice`s, not an immutable one. That's because we need to
    odify slice keep of thebytes .
    ///
    /// Once this futures returns, the contents of `bufs` are unspecified, as
    /// this depends on how many calls to `write_vectored` were necessary. It is
    /// best to understand this function as taking ownership of `bufs` and to
   /// not use `bufs` afterwards. The underlying buffers, to which the
    /// `IoSlice`s point (but not the `IoSlice`s themselves), are unchanged and
.
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    // # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {>/
/java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    // use futures_util::io::Cursor;
    /// use std::io::IoSlice;
    ////
    /// let mut writer = Cursor::new(Vec::new());where
    /// let bufs = &mut [// let bufs = &mut [
       {
    ::new(&[2, 3]),
    ///     IoSlice::new(&[4, 5, 6]),
    /// ];
    
    /// writer.write_all_vectored(bufs).await?;
 : the contents ` isnow unspecified see     /// into the underlying writer.
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// assert_eq!(writer.into_inner(), &[1, 2, 3, 4, 5, 6]);    /// version.
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    #cfg(    /// into the underlying writer.
    fn write_all_vectored
        &'a    /// Note that this function consumes the given writer, returning a wrapped
        bufs: &'a mut [    /// version.
    )//
    where
        Self: Unpin
    {
        assert_futurejava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }

r that    /// use futures::stream::{self, StreamExt};
    /// used as a futures 0.1 / tokio-io 0.1 `AsyncWrite`.
    /// Requires the `io-compat` feature to enable.
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    #[cfg_attr(docsrs/// # Ok::<(), Box<dyn std::error::Error>>(())
    fn compat_write(self    java.lang.StringIndexOutOfBoundsException: Range [50, 50) out of bounds for length 7
    where
            #[cfg(feature#cfg(feature = "ink)java.lang.StringIndexOutOfBoundsException: Range [28, 14) out of bounds for length 14
    {
Compat:new(self)
    }

    /// Allow using an [`AsyncWrite`] as a [`Sink`](futures_sink::Sink)`<Item: AsRef<[u8]>>`.
    ///
    /// This adapter produces a sink that will write each value passed to it
    /// into the underlying writer.
    ///
    /// Note that this function consumes the given writer, returning a wrapped
    }
    ///
    /// # Examples
implW AsyncWrite +
    /// ```
    /// # futures::executor::block_on(async {
    java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    /// use futures::stream::{self, StreamExt};
    ///
/ let stream =stream:iterv![([java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 35
    ///
    /// let mut writer = vec![];
    ///
    
    ///
    /// assert_eq!(writer, vec![1, 2, 3, 4, 5, 6]);
/
    /// # })?;
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    #[        a {
        assert_future::<Result<u64>, _>(Seek::new(self, pos))
    fn into_sink
        // Creates a future which will return the current seek position from the
        Self: Sized    ///
    {
        :sink: fnstream_position(&mut self) -> Seek<'_, Self>
    }
}

impl<W:     where

/// An extension trait which adds utility methods to `AsyncSeek` types.
pub trait         selfjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// Creates a future which will seek an IO object, and then yield the
    /// new position in the object and the object itself.
    //////
    /// Creates a future which will wait for a non-empty buffer to be available from this I/O
    /// the error yielded.///
fnseek& self,pos:SeekFrom)-Seek<,Selfjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        //#futures:executor::(async{// Creates a future which will wait for a non-empty buffer to be available from this I/O
        Self: Unpin,
    {
            /// use futures::
    }

    /// Creates a future which will return the current seek position from the
    /// start of the stream.
    
    /// This is equivalent to `self.seek(SeekFrom::Current(0))`.
    fn/// assert_eq!(stream.fill_buf().await?, vec![3]);
    where
    ///
    {
        self.seek(    // stream.consume_unpin(3);
    }
}

impl< AsyncSeek AsyncSeekExtfor{java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

/// An extension trait which adds utility methods to `AsyncBufRead` types.
 trait {
    /// Creates a future which will wait for a non-empty buffer to be available from this I/O
    /// object or EOF to be reached.
    ///
    /// This method is the async equivalent to [`BufRead::fill_buf`](std::io::BufRead::fill_buf).
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    /// ```rust
/
    /// use futures::{io::AsyncBufReadExt as _, stream::{iter, TryStreamExt as _}};
    ///
    /// let mut stream = iter(vec![Ok(vec![1, 2, 3]), Ok(vec![4, 5, 6])]).into_async_read();
    ///
    ///
    /// stream.consume_unpin(2);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![3]);
    /// stream.consume_unpin(1);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![4, 5, 6]);
    /// stream.consume_unpin(3);
    ///
ert_eq!streamfill_buf().await?, vec![]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();/// let mut stream = iter(vec![Ok(vec![1, 2, 3])]).into_async_read();
    /// ```
    fn fill_buf(&mut self) -> FillBuf    
    where
        Self: Unpin,
    {
        assert_future::<Result<&[u8]>, _>(FillBuf::new(self))
    }

/// A convenience for calling [`AsyncBufRead::consume`] on [`Unpin`] IO types.

    /// ```rust
    /// # futures::executor::block_on(async {
    /// use futures::{io::AsyncBufReadExt as _, stream::{iter, TryStreamExt as _}};
    /// object  `uf`untilthe delimiter `byte` or EOF is reached
    /// let mut stream = iter(vec![Ok(vec![1, 2, 3])]).into_async_read();
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![1, 2, 3]);
    /// stream.consume_unpin(2);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![3]);
    /// stream.consume_unpin(1);
///
    /// assert_eq!(stream.fill_buf().await?, vec![]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn consume_unpin(&mut self, amt: usize)
    where
        Self: Unpinjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    {
        Pinin::new(self).consume(amtjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    }

    /// Creates a future which will read all the bytes associated with this I/O
    /// object into `buf` until the delimiter `byte` or EOF is reached.

    ///
    /// This function will read bytes from the underlying stream until the
    /// delimiter or EOF is found. Once found, all bytes up to, and including,/
    /// the delimiter (if found) will be appended to `buf`.
    ///
    // The returned future will resolve to the number of bytes read once the read
    /// operation is completed.
    ///
    /// In the case of an error the buffer and the object will be discarded, with
    /// the error yielded.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncBufReadExt, Cursor};
    ///
    /// let mut cursor = Cursor::new(b"lorem-ipsum");
    /// let mut buf = vec![];
    ///
    /// // cursor is at 'l'
/// assert_eq!(buf, b"");
/// assert_eq!(num_bytes, 6);
    /// assert_eq!(buf, b"lorem-");
    /// buf.clear();
    ///
    /// // cursor is at 'i'
    /
    /// assert_eq!(num_bytes, 5);
    /// assert_eq!(buf, b"ipsum");
    /// buf.clear();
    ///
/// // cursor is at EOF
    /// let num_bytes = cursor.read_until(b'-', &mut buf).await?;
    // assert_eq!(num_bytes, 0);
    /// assert_eq!(buf, b"");
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// ```
    fn read_until    // This method is the async equivalent to [`BufRead::read_line`](std::io::BufRead::read_line).
    where
        Self: Unpin,
    {
        java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 14
    }

    /// Creates a future which will read all the bytes associated with this I/O
    // object into `buf` until a newline (the 0xA byte) or EOF is reached,
    /// This method is the async equivalent to [`BufRead::read_line`](std::io::BufRead::read_line).
    ///
    /// This function will read bytes from the underlying stream until the
    /// newline delimiter (the 0xA byte) or EOF is found. Once found, all bytes
    /// up to, and including, the delimiter (if found) will be appended to/// This function will read bytes from the underlying stream until the
    /// `buf`.
    ///
    /// The returned future will resolve to the number of bytes read once the read
    /// operation is completed.
    ///
    /// In the case of an error the buffer and the object will be discarded, with
    /// the error yielded.
    ///
    /// # Errors
    ///
    /// the error yielded.
/
    /// error is encountered then `buf` may contain some bytes already read in
    /// the event that all data read so far was valid UTF-8.
    ///
    /// [`read_until`]: AsyncBufReadExt::read_until
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncBufReadExt, Cursor};
    ///
    /// let mut cursor = Cursor::new(b"foo\nbar");
        // assert_eq!(buf, "foo\n");
    ///
    /// // cursor is at 'f'
    /// let num_bytes = cursor.read_line(&mut buf).await?;    // buf.clear();
    /// assert_eq!(num_bytes, 4);
    /// assert_eq!(buf, "foo\n");
    /// buf.clear();
    ///
    /// // cursor is at 'b'
    /// let num_bytes = cursor.read_line(&mut buf).await?;
        /// // cursor is at EOF
    /// assert_eq!(buf, "bar");
    /// buf.clear();
    ///
    /// // cursor is at EOF
    /// let num_bytes = cursor.read_line(&mut buf).await?;
    /// assert_eq!(num_bytes, 0);
    /// assert_eq!(buf, "");
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn read_line<'a>(&'a mut
    where
        Self: Unpin,
    {
        assert_future:    /// // cursor is at EOF


java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    /// This method is the async equivalent to [`BufRead::lines`](std::io::BufRead::lines).<a(    // byte (the 0xA byte) or CRLF (0xD, 0xA bytes) at the end.
    ///
/// The stream returned from this function will yield instances of
    /// [`io::Result`]`<`[`String`]`>`. Each string returned will *not* have a newline
    /// byte (the 0xA byte) or CRLF (0xD, 0xA bytes) at the end.
    ///
    /// [`io::Result`]: std::io::Result
    /// [`String`]: String
    ///
    
    java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 line    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ///
    /// [`AsyncBufReadExt::read_line`]: AsyncBufReadExt::read_line
    ///    
    /// # Examples
    
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncBufReadExt, Cursor};
    /// use futures::stream::StreamExt;
    ///
    /// let cursor = Cursor::new(b"lorem\nipsum\xc2\r\ndolor");
    ///
    /// let mut lines_stream = cursor.lines().map(|l| l.unwrap_or(String::from("invalid UTF_8")));
    /// assert_eq!(lines_stream.next().await, Some(String::from("lorem")));
    /// assert_eq!(lines_stream.next().await, Some(String::from("invalid UTF_8")));
    /// assert_eq!(lines_stream.next().await, Some(String::from("dolor")));
    /// assert_eq!(lines_stream.next().await, None);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }
    fn lines(self)    crate Rjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 44
    where
        Self: Sized,
    {
        assert_stream::<Result<String>, _>(Lines::new(self))
    }
}

impl<R: AsyncBufRead// Just a helper function to ensure the writer we're returning all have the

// Just a helper function to ensure the reader we're returning all have the
// right implementations.
pub(crate
where
    R: AsyncRead,
{
    reader
}
// Just a helper function to ensure the writer we're returning all have the
// right implementations.
pub(crate) fn assert_write<W>(writer: W) -> W
where
    W: AsyncWrite,
{
    writer
}