Struct NamedPipeClient 

pub struct NamedPipeClient { /* private fields */ }

Available on crate feature fs and Windows only.

A Windows named pipe client.

Constructed using ClientOptions::open.

Connecting a client correctly involves a few steps. When connecting through ClientOptions::open, it might error indicating one of two things:

• std::io::ErrorKind::NotFound - There is no server available.
• ERROR_PIPE_BUSY - There is a server available, but it is busy. Sleep for a while and try again.

So a correctly implemented client looks like this:

use std::time::Duration;

use compio_fs::named_pipe::ClientOptions;
use compio_runtime::time;
use windows_sys::Win32::Foundation::ERROR_PIPE_BUSY;

const PIPE_NAME: &str = r"\\.\pipe\named-pipe-idiomatic-client";

let client = loop {
    match ClientOptions::new().open(PIPE_NAME).await {
        Ok(client) => break client,
        Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
        Err(e) => return Err(e),
    }

    time::sleep(Duration::from_millis(50)).await;
};

// use the connected client

Implementations

impl NamedPipeClient

pub fn info(&self) -> Result<PipeInfo, Error>

Retrieves information about the named pipe the client is associated with.

use compio_fs::named_pipe::{ClientOptions, PipeEnd, PipeMode};

const PIPE_NAME: &str = r"\\.\pipe\compio-named-pipe-client-info";

let client = ClientOptions::new().open(PIPE_NAME).await?;

let client_info = client.info()?;

assert_eq!(client_info.end, PipeEnd::Client);
assert_eq!(client_info.mode, PipeMode::Message);
assert_eq!(client_info.max_instances, 5);

Trait Implementations

impl AsHandle for NamedPipeClient

fn as_handle(&self) -> BorrowedHandle<'_>

Borrows the handle.

impl AsRawFd for NamedPipeClient

fn as_raw_fd(&self) -> *mut c_void

Extracts the raw fd.

impl AsRawHandle for NamedPipeClient

fn as_raw_handle(&self) -> *mut c_void

Extracts the raw handle.

impl AsyncRead for &NamedPipeClient

async fn read<B>(&mut self, buffer: B) -> BufResult<usize, B>

where B: IoBufMut,

Read some bytes from this source into the IoBufMut buffer and return a BufResult, consisting of the buffer and a usize indicating how many bytes were read.

async fn read_vectored<V>(&mut self, buf: V) -> BufResult<usize, V>

where V: IoVectoredBufMut,

Like read, except that it reads into a type implements IoVectoredBufMut.

impl AsyncRead for NamedPipeClient

async fn read<B>(&mut self, buf: B) -> BufResult<usize, B>

where B: IoBufMut,

Read some bytes from this source into the IoBufMut buffer and return a BufResult, consisting of the buffer and a usize indicating how many bytes were read.

async fn read_vectored<V>(&mut self, buf: V) -> BufResult<usize, V>

where V: IoVectoredBufMut,

Like read, except that it reads into a type implements IoVectoredBufMut.

impl AsyncReadManaged for &NamedPipeClient

type Buffer<'a> = BorrowedBuffer<'a>

Filled buffer type

type BufferPool = BufferPool

Buffer pool type

async fn read_managed<'a>( &mut self, buffer_pool: &'a <&NamedPipeClient as AsyncReadManaged>::BufferPool, len: usize, ) -> Result<<&NamedPipeClient as AsyncReadManaged>::Buffer<'a>, Error>

Read some bytes from this source with Self::BufferPool and return a Self::Buffer.

impl AsyncReadManaged for NamedPipeClient

type Buffer<'a> = BorrowedBuffer<'a>

Filled buffer type

type BufferPool = BufferPool

Buffer pool type

async fn read_managed<'a>( &mut self, buffer_pool: &'a <NamedPipeClient as AsyncReadManaged>::BufferPool, len: usize, ) -> Result<<NamedPipeClient as AsyncReadManaged>::Buffer<'a>, Error>

Read some bytes from this source with Self::BufferPool and return a Self::Buffer.

impl AsyncWrite for &NamedPipeClient

async fn write<T>(&mut self, buffer: T) -> BufResult<usize, T>

where T: IoBuf,

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn flush(&mut self) -> Result<(), Error>

Attempts to flush the object, ensuring that any buffered data reach their destination.

async fn shutdown(&mut self) -> Result<(), Error>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

async fn write_vectored<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoVectoredBuf,

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

impl AsyncWrite for NamedPipeClient

async fn write<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoBuf,

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn flush(&mut self) -> Result<(), Error>

Attempts to flush the object, ensuring that any buffered data reach their destination.

async fn shutdown(&mut self) -> Result<(), Error>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

async fn write_vectored<T>(&mut self, buf: T) -> BufResult<usize, T>

where T: IoVectoredBuf,

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

impl Clone for NamedPipeClient

fn clone(&self) -> NamedPipeClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NamedPipeClient

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

Formats the value using the given formatter.

impl FromRawHandle for NamedPipeClient

unsafe fn from_raw_handle(handle: *mut c_void) -> NamedPipeClient

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

impl Splittable for &NamedPipeClient

type ReadHalf = NamedPipeClient

The type of the read half, which normally implements AsyncRead or AsyncReadAt.

type WriteHalf = NamedPipeClient

The type of the write half, which normally implements AsyncWrite or AsyncWriteAt.

fn split(self) -> (NamedPipeClient, NamedPipeClient)

Consumes self and returns a tuple containing separate read and write halves.

impl Splittable for NamedPipeClient

type ReadHalf = NamedPipeClient

The type of the read half, which normally implements AsyncRead or AsyncReadAt.

type WriteHalf = NamedPipeClient

The type of the write half, which normally implements AsyncWrite or AsyncWriteAt.

fn split(self) -> (NamedPipeClient, NamedPipeClient)

Consumes self and returns a tuple containing separate read and write halves.

impl ToSharedFd<File> for NamedPipeClient

fn to_shared_fd(&self) -> SharedFd<File>

Return a cloned SharedFd.