Struct miow::pipe::NamedPipe

pub struct NamedPipe(_);

A named pipe that can accept connections.

Methods

impl NamedPipe

fn new<A: AsRef<OsStr>>(addr: A) -> Result<NamedPipe>

Creates a new initial named pipe.

This function is equivalent to:

use miow::pipe::NamedPipeBuilder;

NamedPipeBuilder::new(addr)
                 .first(true)
                 .inbound(true)
                 .outbound(true)
                 .out_buffer_size(65536)
                 .in_buffer_size(65536)
                 .create();

fn wait<A: AsRef<OsStr>>(addr: A, timeout: Option<u32>) -> Result<()>

Waits until either a time-out interval elapses or an instance of the specified named pipe is available for connection.

If this function succeeds the process can create a File to connect to the named pipe.

fn connect(&self) -> Result<()>

Connects this named pipe to a client, blocking until one becomes available.

This function will call the ConnectNamedPipe function to await for a client to connect. This can be called immediately after the pipe is created, or after it has been disconnected from a previous client.

unsafe fn connect_overlapped(&self, overlapped: &mut Overlapped) -> Result<bool>

Issue a connection request with the specified overlapped operation.

This function will issue a request to connect a client to this server, returning immediately after starting the overlapped operation.

If this function immediately succeeds then Ok(true) is returned. If the overlapped operation is enqueued and pending, then Ok(false) is returned. Otherwise an error is returned indicating what went wrong.

Unsafety

This function is unsafe because the kernel requires that the overlapped pointer is valid until the end of the I/O operation. The kernel also requires that overlapped is unique for this I/O operation and is not in use for any other I/O.

To safely use this function callers must ensure that this pointer is valid until the I/O operation is completed, typically via completion ports and waiting to receive the completion notification on the port.

fn disconnect(&self) -> Result<()>

Disconnects this named pipe from any connected client.

unsafe fn read_overlapped(&self,
                          buf: &mut [u8],
                          overlapped: &mut Overlapped)
                          -> Result<bool>

Issues an overlapped read operation to occur on this pipe.

This function will issue an asynchronous read to occur in an overlapped fashion, returning immediately. The buf provided will be filled in with data and the request is tracked by the overlapped function provided.

If the operation succeeds immediately, Ok(true) is returned. If an asynchronous operation is enqueued, then Ok(false) is returned. Otherwise if an error occurred it is returned.

When this operation completes (or if it completes immediately), another mechanism must be used to learn how many bytes were transferred (such as looking at the filed in the IOCP status message).

Unsafety

This function is unsafe because the kernel requires that the buf and overlapped pointers to be valid until the end of the I/O operation. The kernel also requires that overlapped is unique for this I/O operation and is not in use for any other I/O.

To safely use this function callers must ensure that the pointers are valid until the I/O operation is completed, typically via completion ports and waiting to receive the completion notification on the port.

unsafe fn write_overlapped(&self,
                           buf: &[u8],
                           overlapped: &mut Overlapped)
                           -> Result<bool>

Issues an overlapped write operation to occur on this pipe.

This function will issue an asynchronous write to occur in an overlapped fashion, returning immediately. The buf provided will be filled in with data and the request is tracked by the overlapped function provided.

If the operation succeeds immediately, Ok(true) is returned. If an asynchronous operation is enqueued, then Ok(false) is returned. Otherwise if an error occurred it is returned.

When this operation completes (or if it completes immediately), another mechanism must be used to learn how many bytes were transferred (such as looking at the filed in the IOCP status message).

Unsafety

This function is unsafe because the kernel requires that the buf and overlapped pointers to be valid until the end of the I/O operation. The kernel also requires that overlapped is unique for this I/O operation and is not in use for any other I/O.

To safely use this function callers must ensure that the pointers are valid until the I/O operation is completed, typically via completion ports and waiting to receive the completion notification on the port.

unsafe fn result(&self, overlapped: *mut Overlapped) -> Result<usize>

Calls the GetOverlappedResult function to get the result of an overlapped operation for this handle.

This function takes the OVERLAPPED argument which must have been used to initiate an overlapped I/O operation, and returns either the successful number of bytes transferred during the operation or an error if one occurred.

Unsafety

This function is unsafe as overlapped must have previously been used to execute an operation for this handle, and it must also be a valid pointer to an Overlapped instance.

Panics

This function will panic

Trait Implementations

impl Debug for NamedPipe

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Read for NamedPipe

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_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

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

Creates an adaptor which will chain this stream with another.

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

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

impl<'a> Read for &'a NamedPipe

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_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

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

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

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

Creates an adaptor which will chain this stream with another.

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

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

impl Write for NamedPipe

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

Write a buffer into this object, 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_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

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

Creates a "by reference" adaptor for this instance of Write.

impl<'a> Write for &'a NamedPipe

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

Write a buffer into this object, 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_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

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

Creates a "by reference" adaptor for this instance of Write.

impl AsRawHandle for NamedPipe

fn as_raw_handle(&self) -> HANDLE

Extracts the raw handle, without taking any ownership.

impl FromRawHandle for NamedPipe

unsafe fn from_raw_handle(handle: HANDLE) -> NamedPipe

Constructs a new I/O object from the specified raw handle.

impl IntoRawHandle for NamedPipe

fn into_raw_handle(self) -> HANDLE

Consumes this object, returning the raw underlying handle.