Struct gix_transport::client::RequestWriter

pub struct RequestWriter<'a> { /* private fields */ }

Available on crate feature blocking-client only.

A Write implementation optimized for writing packet lines. A type implementing Write for packet lines, which when done can be transformed into a Read for obtaining the response.

Implementations

impl<'a> RequestWriter<'a>

methods with bonds to IO

pub fn new_from_bufread<W: Write + 'a>( writer: W, reader: Box<dyn ExtendedBufRead<'a> + Unpin + 'a>, write_mode: WriteMode, on_into_read: MessageKind, trace: bool ) -> Self

Create a new instance from a writer (commonly a socket), a reader into which to transform once the writes are finished, along with configuration for the write_mode and information about which message to write when this instance is converted into a reader to read the request’s response. If trace is true, gix_trace will be used on every written message or data.

pub fn write_message(&mut self, message: MessageKind) -> Result<()>

Write the given message as packet line.

pub fn into_read(self) -> Result<Box<dyn ExtendedBufRead<'a> + Unpin + 'a>>

Discard the ability to write and turn this instance into the reader for obtaining the other side’s response.

Doing so will also write the message type this instance was initialized with.

pub fn into_parts( self ) -> (Box<dyn Write + 'a>, Box<dyn ExtendedBufRead<'a> + Unpin + 'a>)

Dissolve this instance into its write and read handles without any message-writing side-effect as in RequestWriter::into_read().

Furthermore, the writer will not encode everything it writes as packetlines, but write everything verbatim into the underlying channel.

Note

It’s of utmost importance to drop the request writer before reading the response as these might be inter-dependent, depending on the underlying transport mechanism. Failure to do so may result in a deadlock depending on how the write and read mechanism is implemented.

Trait Implementations

impl<'a> Write for RequestWriter<'a>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.