Struct NamedPipePath

pub struct NamedPipePath { /* private fields */ }

Represents a path to a Unix named pipe (FIFO).

Provides convenience methods to create readers and writers, as well as an easy way to ensure the pipe actually exists.

Implementations

impl NamedPipePath

pub fn new<T: Into<PathBuf>>(path: T) -> Self

Wraps a given path in a NamedPipePath.

Examples found in repository

examples/read_print_repeat.rs (line 15)

fn main() -> io::Result<()> {
    task::block_on(async {
        let pipe = NamedPipePath::new("./my_pipe");
        let reader = pipe.open_read();
        loop {
            reader.ensure_pipe_exists().unwrap();
            println!("Waiting for message...");
            let next_msg = reader.read_string().await?;
            println!("Received message: {}", next_msg);
        }
    })
}

examples/write_repeat.rs (line 20)

fn main() -> io::Result<()> {
    let text = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "Hello world!".to_string())
        + "\n";
    println!("Writing String: {}", &text);
    task::block_on(async move {
        let pipe = NamedPipePath::new("./my_pipe");
        let writer = pipe.open_write();
        loop {
            writer.ensure_pipe_exists().unwrap();
            println!("Waiting for receiver...");
            writer.write_str(&text).await?;
        }
    })
}

examples/read_write_repeat.rs (line 14)

fn main() -> io::Result<()> {
    task::block_on(async move {
        let pipe = NamedPipePath::new("./reverse_me");
        let writer = pipe.open_write();
        let reader = pipe.open_read();
        loop {
            pipe.ensure_exists().unwrap();
            println!("Waiting for message...");
            let msg = reader.read_string().await?;

            let answer = msg.chars().rev().collect::<String>() + "\n";
            pipe.ensure_exists().unwrap();
            println!("Received message, waiting for receiver...");
            writer.write_str(&answer).await?;
        }
    })
}

pub fn exists(&self) -> bool

Checks if the path exists.

pub fn ensure_exists(&self) -> Result<()>

Ensures the path exists, creating a named pipe in its place if it doesn’t.

Examples found in repository

examples/read_write_repeat.rs (line 18)

fn main() -> io::Result<()> {
    task::block_on(async move {
        let pipe = NamedPipePath::new("./reverse_me");
        let writer = pipe.open_write();
        let reader = pipe.open_read();
        loop {
            pipe.ensure_exists().unwrap();
            println!("Waiting for message...");
            let msg = reader.read_string().await?;

            let answer = msg.chars().rev().collect::<String>() + "\n";
            pipe.ensure_exists().unwrap();
            println!("Received message, waiting for receiver...");
            writer.write_str(&answer).await?;
        }
    })
}

pub async fn delete(self) -> Result<()>

Tries to delete the pipe from disk and consumes the NamedPipe.

pub fn open_read(&self) -> NamedPipeReader

Creates a reader for this named pipe.

Examples found in repository

examples/read_print_repeat.rs (line 16)

fn main() -> io::Result<()> {
    task::block_on(async {
        let pipe = NamedPipePath::new("./my_pipe");
        let reader = pipe.open_read();
        loop {
            reader.ensure_pipe_exists().unwrap();
            println!("Waiting for message...");
            let next_msg = reader.read_string().await?;
            println!("Received message: {}", next_msg);
        }
    })
}

examples/read_write_repeat.rs (line 16)

fn main() -> io::Result<()> {
    task::block_on(async move {
        let pipe = NamedPipePath::new("./reverse_me");
        let writer = pipe.open_write();
        let reader = pipe.open_read();
        loop {
            pipe.ensure_exists().unwrap();
            println!("Waiting for message...");
            let msg = reader.read_string().await?;

            let answer = msg.chars().rev().collect::<String>() + "\n";
            pipe.ensure_exists().unwrap();
            println!("Received message, waiting for receiver...");
            writer.write_str(&answer).await?;
        }
    })
}

pub fn open_write(&self) -> NamedPipeWriter

Creates a writer for this named pipe.

Examples found in repository

examples/write_repeat.rs (line 21)

fn main() -> io::Result<()> {
    let text = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "Hello world!".to_string())
        + "\n";
    println!("Writing String: {}", &text);
    task::block_on(async move {
        let pipe = NamedPipePath::new("./my_pipe");
        let writer = pipe.open_write();
        loop {
            writer.ensure_pipe_exists().unwrap();
            println!("Waiting for receiver...");
            writer.write_str(&text).await?;
        }
    })
}

examples/read_write_repeat.rs (line 15)

fn main() -> io::Result<()> {
    task::block_on(async move {
        let pipe = NamedPipePath::new("./reverse_me");
        let writer = pipe.open_write();
        let reader = pipe.open_read();
        loop {
            pipe.ensure_exists().unwrap();
            println!("Waiting for message...");
            let msg = reader.read_string().await?;

            let answer = msg.chars().rev().collect::<String>() + "\n";
            pipe.ensure_exists().unwrap();
            println!("Received message, waiting for receiver...");
            writer.write_str(&answer).await?;
        }
    })
}

Trait Implementations

impl Clone for NamedPipePath

fn clone(&self) -> NamedPipePath

Returns a copy of the value.

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

Performs copy-assignment from source.