Enum PipeDirection 

#[repr(u32)]
pub enum PipeDirection {
    ClientToServer = 0,
    ServerToClient = 1,
    Duplex = 2,
}

Available on Windows only.

The direction of a named pipe connection, designating who can read data and who can write it. This describes the direction of the data flow unambiguously, so that the meaning of the values is the same for the client and server – ClientToServer always means client → server, for example.

Variants

ClientToServer = 0

Represents a server ← client data flow: clients write data, the server reads it.

ServerToClient = 1

Represents a server → client data flow: the server writes data, clients read it.

Duplex = 2

Represents a server ⇄ client data flow: the server can write data which then is read by the client, while the client writes data which is read by the server.

Implementations

impl PipeDirection

pub const fn client_role(self) -> PipeStreamRole

Returns the role which the pipe client will have in this direction setting.

Usage

assert_eq!(
    PipeDirection::ClientToServer.client_role(),
    PipeStreamRole::Writer,
);
assert_eq!(
    PipeDirection::ServerToClient.client_role(),
    PipeStreamRole::Reader,
);
assert_eq!(
    PipeDirection::Duplex.client_role(),
    PipeStreamRole::ReaderAndWriter,
);

pub const fn server_role(self) -> PipeStreamRole

Returns the role which the pipe server will have in this direction setting.

Usage

assert_eq!(
    PipeDirection::ClientToServer.server_role(),
    PipeStreamRole::Reader,
);
assert_eq!(
    PipeDirection::ServerToClient.server_role(),
    PipeStreamRole::Writer,
);
assert_eq!(
    PipeDirection::Duplex.server_role(),
    PipeStreamRole::ReaderAndWriter,
);

Trait Implementations

impl Clone for PipeDirection

fn clone(&self) -> PipeDirection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PipeDirection

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

Formats the value using the given formatter.

impl From<PipeDirection> for u32

fn from(op: PipeDirection) -> Self

Converts to this type from the input type.

impl Hash for PipeDirection

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PipeDirection

fn eq(&self, other: &PipeDirection) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<u32> for PipeDirection

fn try_from(op: u32) -> Result<Self, ()>

Converts a Windows constant to a PipeDirection if it’s in range.

Errors

Returns Err if the value is not a valid pipe direction constant.

type Error = ()

The type returned in the event of a conversion error.

impl Copy for PipeDirection

impl Eq for PipeDirection

impl StructuralPartialEq for PipeDirection