Struct interprocess::os::windows::named_pipe::ByteWriterPipeStream

pub struct ByteWriterPipeStream { /* private fields */ }

Available on Windows only.

Byte stream writer for a named pipe.

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

Implementations

impl ByteWriterPipeStream

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 ByteWriterPipeStream

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

Formats the value using the given formatter.

impl Drop for ByteWriterPipeStream

fn drop(&mut self)

Executes the destructor for this type.

impl PipeStream for ByteWriterPipeStream

const ROLE: PipeStreamRole = PipeStreamRole::Writer

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

const WRITE_MODE: Option<PipeMode> = _

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> = None

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 Write for ByteWriterPipeStream

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 Selfwhere
    Self: Sized,

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