Struct MsgReaderPipeStream

pub struct MsgReaderPipeStream { /* private fields */ }

Available on Windows only.

Message stream reader for a named pipe.

Created either by using PipeListener or by connecting to a named pipe server.

Implementations

impl MsgReaderPipeStream

pub fn connect(name: impl AsRef<OsStr>) -> Result<Self>

Connects to the specified named pipe (the \\.\pipe\ prefix is added automatically), blocking until a server instance is dispatched.

pub fn connect_to_remote( pipe_name: impl AsRef<OsStr>, hostname: impl AsRef<OsStr>, ) -> Result<Self>

Connects to the specified named pipe at a remote computer (the \\<hostname>\pipe\ prefix is added automatically), blocking until a server instance is dispatched.

pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()>

Sets whether the nonblocking mode for the pipe stream is enabled. By default, it is disabled.

In nonblocking mode, attempts to read from the pipe when there is no data available or to write when the buffer has filled up because the receiving side did not read enough bytes in time will never block like they normally do. Instead, a WouldBlock error is immediately returned, allowing the thread to perform useful actions in the meantime.

If called on the server side, the flag will be set only for one stream instance. A listener creation option, nonblocking, and a similar method on the listener, set_nonblocking, can be used to set the mode in bulk for all current instances and future ones.

pub fn is_server(&self) -> bool

Returns true if the stream was created by a listener (server-side), false if it was created by connecting to a server (server-side).

pub fn is_client(&self) -> bool

Returns true if the stream was created by connecting to a server (client-side), false if it was created by a listener (server-side).

pub fn client_process_id(&self) -> Result<u32>

Retrieves the process identifier of the client side of the named pipe connection.

pub fn client_session_id(&self) -> Result<u32>

Retrieves the session identifier of the client side of the named pipe connection.

pub fn server_process_id(&self) -> Result<u32>

Retrieves the process identifier of the server side of the named pipe connection.

pub fn server_session_id(&self) -> Result<u32>

Retrieves the session identifier of the server side of the named pipe connection.

pub fn disconnect_without_flushing(self) -> Result<()>

Disconnects the named pipe stream without flushing buffers, causing all data in those buffers to be lost. This is much faster (and, in some case, the only finite-time way of ending things) than simply dropping the stream, since, for non-async named pipes, the Drop implementation flushes first.

Only makes sense for server-side pipes and will return an error if called on a client stream. For async pipe streams, this is the same as dropping the pipe.

Trait Implementations

impl Debug for MsgReaderPipeStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for MsgReaderPipeStream

fn drop(&mut self)

Executes the destructor for this type.

impl PipeStream for MsgReaderPipeStream

const ROLE: PipeStreamRole = PipeStreamRole::Reader

The data stream flow direction for the pipe. See the PipeStreamRole enumeration for more on what this means.

const WRITE_MODE: Option<PipeMode> = None

The data stream mode for the pipe. If set to PipeMode::Bytes, message boundaries will broken and having READ_MODE at PipeMode::Messages would be a pipe creation error.

const READ_MODE: Option<PipeMode>

The data stream mode used when reading from the pipe: if WRITE_MODE is PipeMode::Messages and READ_MODE is PipeMode::Bytes, the message boundaries will be destroyed when reading even though they are retained when written. See the PipeMode enumeration for more on what those modes mean.

impl Read for MsgReaderPipeStream

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl ReliableReadMsg for MsgReaderPipeStream

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

Reads one message from the stream into the specified buffer, returning either the size of the message written, a bigger buffer if the one provided was too small, or an error in the outermost Result if the operation could not be completed for OS reasons.

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

Attempts to read one message from the stream into the specified buffer, returning the size of the message, which, depending on whether it was in the Ok or Err variant, either did fit or did not fit into the provided buffer, respectively; if the operation could not be completed for OS reasons, an error from the outermost Result is returned.