[−][src]Struct pwn::io::BufStream
Wraps a type that is AsyncWrite
and AsyncRead
, and buffers its input and output.
It can be excessively inefficient to work directly with something that implements AsyncWrite
and AsyncRead
. For example, every write
, however small, has to traverse the syscall
interface, and similarly, every read has to do the same. The BufWriter
and BufReader
types aid with these problems respectively, but do so in only one direction. BufStream
wraps
one in the other so that both directions are buffered. See their documentation for details.
Implementations
impl<RW> BufStream<RW> where
RW: AsyncRead + AsyncWrite,
[src]
RW: AsyncRead + AsyncWrite,
pub fn new(stream: RW) -> BufStream<RW>
[src]
Wraps a type in both BufWriter
and BufReader
.
See the documentation for those types and BufStream
for details.
pub fn with_capacity(
reader_capacity: usize,
writer_capacity: usize,
stream: RW
) -> BufStream<RW>
[src]
reader_capacity: usize,
writer_capacity: usize,
stream: RW
) -> BufStream<RW>
Creates a BufStream
with the specified BufReader
capacity and BufWriter
capacity.
See the documentation for those types and BufStream
for details.
pub fn get_ref(&self) -> &RWⓘ
[src]
Gets a reference to the underlying I/O object.
It is inadvisable to directly read from the underlying I/O object.
pub fn get_mut(&mut self) -> &mut RWⓘ
[src]
Gets a mutable reference to the underlying I/O object.
It is inadvisable to directly read from the underlying I/O object.
pub fn get_pin_mut(self: Pin<&mut BufStream<RW>>) -> Pin<&mut RW>ⓘ
[src]
Gets a pinned mutable reference to the underlying I/O object.
It is inadvisable to directly read from the underlying I/O object.
pub fn into_inner(self) -> RW
[src]
Consumes this BufStream
, returning the underlying I/O object.
Note that any leftover data in the internal buffer is lost.
Trait Implementations
impl<RW> AsyncBufRead for BufStream<RW> where
RW: AsyncRead + AsyncWrite,
[src]
RW: AsyncRead + AsyncWrite,
fn poll_fill_buf(
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<&[u8], Error>>
[src]
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<&[u8], Error>>
fn consume(self: Pin<&mut BufStream<RW>>, amt: usize)
[src]
impl<RW> AsyncRead for BufStream<RW> where
RW: AsyncRead + AsyncWrite,
[src]
RW: AsyncRead + AsyncWrite,
fn poll_read(
self: Pin<&mut BufStream<RW>>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut BufStream<RW>>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize, Error>>
unsafe fn prepare_uninitialized_buffer(
&self,
buf: &mut [MaybeUninit<u8>]
) -> bool
[src]
&self,
buf: &mut [MaybeUninit<u8>]
) -> bool
fn poll_read_buf<B>(
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut B
) -> Poll<Result<usize, Error>> where
B: BufMut,
[src]
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut B
) -> Poll<Result<usize, Error>> where
B: BufMut,
impl<RW> AsyncWrite for BufStream<RW> where
RW: AsyncRead + AsyncWrite,
[src]
RW: AsyncRead + AsyncWrite,
fn poll_write(
self: Pin<&mut BufStream<RW>>,
cx: &mut Context,
buf: &[u8]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut BufStream<RW>>,
cx: &mut Context,
buf: &[u8]
) -> Poll<Result<usize, Error>>
fn poll_flush(
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<(), Error>>
[src]
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<(), Error>>
fn poll_shutdown(
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<(), Error>>
[src]
self: Pin<&mut BufStream<RW>>,
cx: &mut Context
) -> Poll<Result<(), Error>>
fn poll_write_buf<B>(
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut B
) -> Poll<Result<usize, Error>> where
B: Buf,
[src]
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut B
) -> Poll<Result<usize, Error>> where
B: Buf,
impl<RW> Debug for BufStream<RW> where
RW: Debug,
[src]
RW: Debug,
impl<RW> From<BufReader<BufWriter<RW>>> for BufStream<RW>
[src]
impl<RW> From<BufWriter<BufReader<RW>>> for BufStream<RW>
[src]
impl<'__pin, RW> Unpin for BufStream<RW> where
__Origin<'__pin, RW>: Unpin,
[src]
__Origin<'__pin, RW>: Unpin,
Auto Trait Implementations
impl<RW> RefUnwindSafe for BufStream<RW> where
RW: RefUnwindSafe,
RW: RefUnwindSafe,
impl<RW> Send for BufStream<RW> where
RW: Send,
RW: Send,
impl<RW> Sync for BufStream<RW> where
RW: Sync,
RW: Sync,
impl<RW> UnwindSafe for BufStream<RW> where
RW: UnwindSafe,
RW: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<R> AsyncBufReadExt for R where
R: AsyncBufRead + ?Sized,
[src]
R: AsyncBufRead + ?Sized,
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ReadUntil<'a, Self> where
Self: Unpin,
fn read_line(&'a mut self, buf: &'a mut String) -> ReadLine<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn split(self, byte: u8) -> Split<Self> where
Self: Unpin,
[src]
Self: Unpin,
fn lines(self) -> Lines<Self>
[src]
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,
[src]
R: AsyncRead + ?Sized,
fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead,
[src]
R: AsyncRead,
fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_buf<B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B> where
B: BufMut,
Self: Unpin,
[src]
B: BufMut,
Self: Unpin,
fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u8(&'a mut self) -> ReadU8<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i8(&'a mut self) -> ReadI8<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u16(&'a mut self) -> ReadU16<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i16(&'a mut self) -> ReadI16<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u32(&'a mut self) -> ReadU32<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i32(&'a mut self) -> ReadI32<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u64(&'a mut self) -> ReadU64<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i64(&'a mut self) -> ReadI64<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u128(&'a mut self) -> ReadU128<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i128(&'a mut self) -> ReadI128<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u16_le(&'a mut self) -> ReadU16Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i16_le(&'a mut self) -> ReadI16Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u32_le(&'a mut self) -> ReadU32Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i32_le(&'a mut self) -> ReadI32Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u64_le(&'a mut self) -> ReadU64Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i64_le(&'a mut self) -> ReadI64Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_u128_le(&'a mut self) -> ReadU128Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_i128_le(&'a mut self) -> ReadI128Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_to_end(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn read_to_string(&'a mut self, dst: &'a mut String) -> ReadToString<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn take(self, limit: u64) -> Take<Self>
[src]
impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,
[src]
W: AsyncWrite + ?Sized,
fn write(&'a mut self, src: &'a [u8]) -> Write<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_buf<B>(&'a mut self, src: &'a mut B) -> WriteBuf<'a, Self, B> where
B: Buf,
Self: Unpin,
[src]
B: Buf,
Self: Unpin,
fn write_all(&'a mut self, src: &'a [u8]) -> WriteAll<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u8(&'a mut self, n: u8) -> WriteU8<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i8(&'a mut self, n: i8) -> WriteI8<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u16(&'a mut self, n: u16) -> WriteU16<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i16(&'a mut self, n: i16) -> WriteI16<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u32(&'a mut self, n: u32) -> WriteU32<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i32(&'a mut self, n: i32) -> WriteI32<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u64(&'a mut self, n: u64) -> WriteU64<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i64(&'a mut self, n: i64) -> WriteI64<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u128(&'a mut self, n: u128) -> WriteU128<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i128(&'a mut self, n: i128) -> WriteI128<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u16_le(&'a mut self, n: u16) -> WriteU16Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i16_le(&'a mut self, n: i16) -> WriteI16Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u32_le(&'a mut self, n: u32) -> WriteU32Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i32_le(&'a mut self, n: i32) -> WriteI32Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u64_le(&'a mut self, n: u64) -> WriteU64Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i64_le(&'a mut self, n: i64) -> WriteI64Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_u128_le(&'a mut self, n: u128) -> WriteU128Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn write_i128_le(&'a mut self, n: i128) -> WriteI128Le<&'a mut Self> where
Self: Unpin,
[src]
Self: Unpin,
fn flush(&mut self) -> Flush<Self> where
Self: Unpin,
[src]
Self: Unpin,
fn shutdown(&mut self) -> Shutdown<Self> where
Self: Unpin,
[src]
Self: Unpin,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,