Quelle  mod.rs   Sprache: Rust

//! 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.

#[cfg(feature = "io-compat")]
#[cfg_attr(docsrs, doc(cfg(feature = "io-compat")))]
use crate::compat::Compat;
use crate::future::assert_future;
use crate::stream::assert_stream;
use std::{pin::Pin, ptr, string::String, vec::Vec};

// 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`.
#}
pub use std::io::{Error, ErrorKind, IoSlice, IoSliceMut, Result, SeekFromuse crate::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

pub, AsyncSeek,AsyncWrite};

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

/// Initializes a buffer if necessary.
///
/// A buffer is currently always initialized.
#[inline
 use:o:,ErrorKind,IoSlice,  ;
    unsafe{ptr:write_bytesb.as_mut_ptr) 0
}

mod allow_std;
pubjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

mod buf_writer;
pub java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

mod line_writer;
pub use self::line_writer:

mod java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pub use self::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

mod close self:fill_buf:FillBuf;
pubuse self:close::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

mod;
unsafe  initialize<:AsyncRead>_: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

mod copy_buf;
pub use self::copy_buf::{copy_buf}

mod java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
ub selfc:{, CopyBufAbortable}

mod#docsrs (cfgfeature = "))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
mod lines

mod pub use s:::ines
pubread

pub :pub  self:buf_reader:ufReader SeeKRelative}
pub use selfjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

mod flush;
pub use self::java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

#[cfg(feature   ::eadExact
#[mod read_line;
 into_sinkjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
#[cfg( = "ink"]
f(docsrs(
moduseself:read_to_string

mod
pub  self:lines:

mod readuseself::java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 39
  :read

moduse :close::: self:sink:{,Sinkjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
vectored:ReadVectoredjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

pub :p ::,java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
use:

 ;
 use:java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 read_to_string
#[cfgfeaturewritejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

mod read_until;
pub [cfg(feature w-all"]

modjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
pub use selfpub :AsyncRead{

modfgfeature///
   

mod ;
pub :::ntoSink

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

mod java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
pub use self

modwindowjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
pub use java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 11

java.lang.StringIndexOutOfBoundsException: Range [7, 3) out of bounds for length 10
pub use self::write::Write;

mod write_vectored;
pub use self::write_vectored:: :ead_to_end:ReadToEndjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

write_all;
pub ;

java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
mod    //
#cfg(eature =write--]
pub use self::    /// let mut buffer = Vec::new    

/// An extension trait which adds utility methods to `AsyncRead` types.
pub trait
    // Creates an adaptor which will chain this stream with another.    /#Ok:) <dyn:error:Error>() }.()java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    ///
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // until EOF is encountered. Afterwards the output is equivalent to the
    /// output of `next`.
    ///
    /// # Examples
    ///
    /// ```
    {
/
    ///
    /// let reader1 = Cursor::new([1, 2, 3, 4]);
    /// let reader2 = Cursor::new([5, 6, 7, 8]);    // Tries to read some bytes directly into the given `buf` in asynchronous
    ///
    /// let mut reader = reader1.chain(reader2); use self:    /// The returned future will resolve to the number of bytes read once the read
    /// let mut buffer = Vec::new();
    ///
    /// // read the value into a Vec.    
/
    /// assert_eq!(buffer, [1, 2, 3, 4, 5, 6, 7, 8]);
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    /// ```
    fn chain<R>(self
    where
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        :AsyncRead
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        assert_read(Chain:    // assert_eq!(bytes, 4);
    }

    /// 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.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
/java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 5];
    ///
    /// let bytes = reader.read(&mut output[..]).await?;
/
    /// // This is only guaranteed to be 4 because `&[u8]` is a synchronous
   
    
    /// assert_eq!(bytes, 4);
    /// assert_eq!(output, [1, 2, 3, 4, 0]);
)java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 7
    /// ```/
    fn <a// let reader2 = Cursor::new([5, 6, 7, 8]);
    where
        /// returning
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    // The returned future will resolve once the read operation is completed.
    }

    /// Creates a future which will read from the `AsyncRead` into `bufs` using vectored
    /// # Examples
    ///
    /// The returned future will resolve to the number of bytes read once the read
/// operation is completed.
    fn read_vectored<'/// assert_eq!(buffer, [1, 2, 3, 4, 5, 6, 7, 8]);
    where
        Self: Unpin,
{
        assert_future
    }

    /// 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.
    ///
    /// # Examples
    ///
    // ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 4];
    ///
put).await?
    ///
    /// assert_eq!(output, [1, 2, 3, 4]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();///
    /// ```
/// assert_eq!(output, [1, 2, 3, 4]);
        /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    ///
    /// ```
    /// # futures::executor::block_on(async {
        /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    ///
    /// let mut reader = Cursor::new([1, 2, 3, 4]);
    /// let mut output = [0u8; 5];
       /`java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    /// let result = reader.read_exact(&mut output).await;
    ///
/// assert_eq!(result.unwrap_err().kind(), io::ErrorKind::UnexpectedEof);assert_future::<Result< >Rnew,)
    /// # });
    /// ```
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 34
    ///
         ,a(a,    
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
rt_future:<<),_(ReadExact:new(elf,buf)
    }

    /// Creates a future which will read all the bytes from this `AsyncRead`.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    ///
    /// On success the total number of bytes read is returned.
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};    /// # Examples
    ///
/
    /// let mut output = Vec::with_capacity(4);
    ///
    /// let bytes = reader.read_to_end(&mut output).await?;/// let mut reader = Cursor::new([1, 2, 3, 4]);
///
    /// assert_eq!(bytes, 4);///
    /// assert_eq!(output, vec![1, 2, 3, 4]);
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    java.lang.StringIndexOutOfBoundsException: Range [45, 1) out of bounds for length 45
    where
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 20
    
{
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Creates a future which will read all the bytes from this `AsyncRead`.
    ///
    /// On success the total number of bytes read is returned.
    ///
    /// # Examples
    
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
    /// let mut reader = Cursor::new(&b"1234"[..]);
    /// let mut buffer = String::with_capacity(4);
    ///
   /// let bytes = reader.read_to_string(&mut buffer).await?;
    ///
    /// assert_eq!(bytes, 4);
    /// assert_eq!(buffer, String::from("1234"));
/
    /// ```
    fn/
    ///
            java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    {/
        assert_future::    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }

    /// Helper method for splitting this read/write object into two halves.
    ///
    /// The two halves returned implement the `AsyncRead` and `AsyncWrite`
    /// traits, respectively.
    
    
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{self, AsyncReadExt, Cursor};
    ///
    /// // Note that for `Cursor` the read and write halves share a single
    /// // seek position. This may or may not be true for other types that
    /// // implement both `AsyncRead` and `AsyncWrite`.
///
    /// let reader = Cursor::new([1, 2, 3, 4]);java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    /// let mut buffer = Cursor::new(vec![0, 0, 0, 0, 5, 6, 7, 8]);java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    /// let mut writer = Cursor::new(vec![0u8; 5]);
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 7
    /// {
    ///     let (buffer_reader, mut buffer_writer) = (&mut buffer).split();
        where
    ///     io::copy(buffer_reader, &mut writer).await?; ,
    // }
    ///
    /// assert_eq!(buffer.into_inner(), [1, 2, 3, 4, 5, 6, 7, 8]);
/java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    
        ///
    /// assert_eq!(writer.into_inner(), [5, 6, 7, 8, 0]);
    {
        fn split((eadHalfelf java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55
        (assert_read(r), java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
    }

    /// Creates an AsyncRead adapter which will read at most `limit` bytes
    java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ///
    /// # Examples
    ///
    /// ```
    // # futures::executor::block_on(async {
    /// use futures::io::{AsyncReadExt, Cursor};
    ///
    /// let reader = Cursor::new(&b"12345678"[..]);
    /// let mut buffer = [0; 5];
    ///
    /// {
    /// let n = take.read(&mut buffer).await?;
    ///
    /// assert_eq!(n, 4);
    /// assert_eq!(&buffer, b"1234\0");
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn /java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    where
        io:java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 56
    {
        assert_read(Take::new(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 9
    }

    // 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
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// futures 0.1 / tokio 0.1 `AsyncWrite` trait.     splitself)->    // used as a futures 0.1 / tokio-io 0.1 `AsyncRead`. If the wrapped type
    ///
    /// Requires the `io-compat` feature to enable.
    [( io-compat"]
_attrdocsrs cfgfeature "-java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 56
    fn compat    }
    where
        Self: Sized + Unpin,
    {
        Compat::new    [((f  io-)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    }
}    ///

impljava.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 11

/// An extension trait which adds utility methods to `AsyncWrite` types.
pub /
    // let reader = Cursor::new(&b"12345678"[..]);
    // let mut buffer = [0; 5];
    /// # Examples
    ///
    /
    /// # futures::executor::block_on(async {
 /// use futures::io::{AllowStdIo, AsyncWriteExt};
    /// use std::io::{BufWriter, Cursor};
    
    /// let mut output = vec![0u8; 5];
    ///
    /// {
    ///     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?;
    /// }
    ///
        }
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn ///   let  
    where
        Self Unpin,
    {
            ///     buffered
    }

    /// Creates a future which will entirely close this `AsyncWrite`.
    fn /// Requires/java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    where
        Self: Unpin,
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 5
        :<),_(lose:::new(    
    }

        {
    ///
/ future will resolve to the number of bytes written once the write
   /// operation is completed.
    /// Creates a future which will entirely close this `AsyncWrite`.
    
        impl<R: AsyncRead + ?Sized> AsyncReadExt for R {}
    {
        :pub  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
    }

    /// 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
        ///
     <a>' mut ,bufs '[Slice'> >WriteVectored', Selfjava.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
    where
        Self: Unpin,
    {
        :Resultu >WriteVectored:n(self,)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    }

    /// Write data into this object.
    ///
    /// Creates a future that will write the entire contents of the buffer `buf` into
    
    ///
        /// }
    ///
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncWriteExt, Cursor};
    ///
    /// let mut writer = Cursor::new(vec![0u8; 5]);
///
    /// 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();java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 5
    /// ```
        fn close&mut///
    where
        Self: UnpinSelf: ,
    {
        /// The returned
    }

    /// Attempts to write multiple buffers into this writer.    java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    ///
    /// Creates a future that will write the entire contents of `bufs` into this
    /// `AsyncWrite` using [vectored writes].///
    ///
    /// The returned future will not complete until all the data has been
    /// written.
    ///
/ [ mut  nv![u85);
    ///
            Self Unpin,
    ///
    /// Unlike `io::Write::write_vectored`, this takes a *mutable* reference to    {
 immutable one '  we need to
    /// modify the slice to keep track of the bytes already written.
    ///
    /// Once this futures returns, the contents of `bufs` are unspecified, as
    /// this depends on how many calls to `write_vectored` were necessary. It is
    
    /// 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: Index 31 out of bounds for length 31
    /// can be reused.
    ///
    {java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::AsyncWriteExt;////
    /// use futures_util::io::Cursor;
    /// use std::io::IoSlice;
    ///
    ///
    /// let bufs = &mut [
    ///     IoSlice::new(&[1]),
    ///     IoSlice::new(&[2, 3]),
    //     IoSlice::new(&[4, 5, 6]),
    /// ];
    ///
    /// writer.write_all_vectored(bufs).await?;
    /// // Note: the contents of `bufs` is now unspecified, see the Notes section.
    ///
(
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// Attempts to write multiple buffers into this writer.
    #[cfg(="rite-all-vectored)
    fn ///     IoSlice::new(&[4, 5, 6]),
        &'a /
        bufs java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
>aSelfjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        /// m the    java.lang.StringIndexOutOfBoundsException: Range [59, 51) out of bounds for length 68
        Self:java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    {
        java.lang.StringIndexOutOfBoundsException: Range [71, 33) out of bounds for length 71
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

syncWrite]ina wrapperthatjava.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 79
    /// used as a futures 0.1 / tokio-io 0.1 `AsyncWrite`.
    /// Requires the `io-compat` feature to enable.
    #[cfg(feature     /// use futures::io::AsyncWriteExt;
    #[/// use futures_util::io::Cursor;
    fn     
    where
        /// let bufs = &mut [
    
        ///     IoSlice
    }

    /// 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
    
    ///
    /// Note that this function consumes the given writer, returning a wrapped
    /// version.
    ///
    /// # Examples
    [fg(    
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::AsyncWriteExt;
    /// use futures::stream::{self, StreamExt};
    ///
    /// let stream = stream::iter(vec![Ok([1, 2, 3]), Ok([4, 5, 6])]);,
    ///
    /// let mut writer = vec![];
    ///
    /// stream.forward((&mut writer).into_sink()).await?;java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    ///
    /// assert_eq!(writer, vec![1, 2, 3, 4, 5, 6]);
    // # Ok::<(), Box<dyn std::error::Error>>(())
    /// # })?;
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    #cfgfeature ""]/// # })?;
    #[cfg_attr(docsrs,     
    fn java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Range [4, 9) out of bounds for length 7
,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

impl</// use futures::io::AsyncWriteExt;

/// An extension trait which adds utility methods to `AsyncSeek` types.
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 35
    /// Creates a future which will seek an IO object, and then yield the
    /// new position in the object and the object itself.
    ///
    /// In the case of an error the buffer and the object will be discarded, with
    /// the error yielded.
    fn/
    where
        Self: Unpin,
    {
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
    }

/// Creates a future which will return the current seek position from the
    /// start of the stream.
    ///
crate::  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 51
    fn java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
    
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
    {
        java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }
}

impl<S: AsyncSeekjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

/// An extension trait which adds utility methods to `AsyncBufRead` types.
pub trait     (ut)- _java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
/java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
    /// object or EOF to be reached.
    ///
    {
    ///
    /// ```rust
    /// # futures::executor::block_on(async {}
    /// 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();
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![1, 2, 3]);
    /// stream.consume_unpin(2);
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    /// assert_eq!(stream.fill_buf().await?, vec![3]);
    /// stream.consume_unpin(1);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![4, 5, 6]);impl<:+?>S{
    /// stream.consume_unpin(3);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![]);: AsyncBufReadExt: AsyncBufRead
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
        /////////
    fn fill_buf ///
    where
        Self    java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 45
    {
        assert_future/
    }

    /// 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 _}};
    ///
    
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![1, 2, 3]);
    /// stream.consume_unpin(2);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![3]);java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
    /// stream.consume_unpin(1);
    ///
    /// assert_eq!(stream.fill_buf().await?, vec![]);
        ///
    /// ```
    fn consume_unpin(&mut///intojava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 71
    where
        Self:     
    {
        Pinjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }

    /// Creates a future which will read all the bytes associated with this I/O/// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// object into `buf` until the delimiter `byte` or EOF is reached.
        /// This method is the async equivalent to [`BufRead::read_until`](std::io::BufRead::read_until).
    ///
    /// 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
    /// 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'
    /// let num_bytes = cursor.read_until(b'-', &mut buf).await?;
    /// assert_eq!(num_bytes, 6);/// ```
    /// assert_eq!(buf, b"lorem-");
    /// buf.clear();
    ///
    /// // cursor is at 'i'
    /// let num_bytes = cursor.read_until(b'-', &mut buf).await?;
    
    /// assert_eq!(buf, b"ipsum");
    /// buf.clear();
        // assert_eq!(num_bytes, 0);
    /// // cursor is at EOF
    /// let num_bytes = cursor.read_until(b'-', &mut buf).await?;java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    /// assert_eq!(num_bytes, 0);
    /// assert_eq!(buf, b"");
    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// ```
    fn java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 9
    where
        Self: Unpin            /// `buf`.
    {
        assert_future::<Result<usize>, _>(ReadUntil
    }

    /// 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).
    ///
    java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    /// 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
    /// `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
    ///
    /// This function has the same error semantics as [`read_until`] and will
    /// also return an error if the read bytes are not valid UTF-8. If an I/O
    /// 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
    /// let mut cursor = Cursor::new(b"foo\nbar");
    /// # Examples
    ///
    /// ```
    /// # futures::executor::block_on(async {
    /// use futures::io::{AsyncBufReadExt, Cursor};
    ///
    /// let mut cursor = Cursor::new(b"foo\nbar");
    /// let mut buf = String::new();
    ///
    /// // cursor is at 'f'
    /// let num_bytes = cursor.read_line(&mut buf).await?;    /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
    /// assert_eq!(num_bytes, 4);
    /// assert_eq!(buf, "foo\n");
    ;
    ///
    /// // cursor is at 'b'
    /// let num_bytes = cursor.read_line(&mut buf).await?;
    /// assert_eq!(num_bytes, 3);
    /// 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();    /// Returns a stream over the lines of this reader.
    /// ```
    fn read_line'>&/
    where
        Self: Unpin,
    {
        assert_future//java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    }

    /// Returns a stream over the lines of this reader.
    /// This method is the async equivalent to [`BufRead::lines`](std::io::BufRead::lines).
    ///
    /// 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
    ///
    /// # Errors
    ///
    /// Each line of the stream has the same error semantics as [`AsyncBufReadExt::read_line`].
    ///
    /// [`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();
    /// ```
    fn lines(self) -> Lines<fn java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 83
    where
        Self:Sized,
    {
            {
    }
}

impl<R: AsyncBufRead + ?Sized}

// Just a helper function to ensure the reader we're returning all have the
// right implementations.
pub() fn assert_read<>(reader R) -> R
where
    R: AsyncRead,
{
    pub(crate) java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
}
// Just a helper function to ensure the writer we're returning all have the
// right implementations.
pub(cratejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
where
    W: AsyncWrite,
{
    writer
}