Struct split_channel::SplitChannelOptions

pub struct SplitChannelOptions { /* private fields */ }

Implementations

impl SplitChannelOptions

pub fn connect(&self) -> Result<(RecvChannel, SendChannel), Error>

Examples found in repository

examples/split_channel-benchmark-client.rs (line 35)

fn main() {
    std::thread::spawn(|| {
        let mut collector = Collector::new();
        split_channel::register_biometrics(&mut collector);
        let fout = File::create("/dev/stdout").unwrap();
        let mut emit = PlainTextEmitter::new(fout);
        loop {
            let now = SystemTime::now()
                .duration_since(SystemTime::UNIX_EPOCH)
                .expect("clock should never fail")
                .as_millis()
                .try_into()
                .expect("millis since epoch should fit u64");
            if let Err(e) = collector.emit(&mut emit, now) {
                eprintln!("collector error: {}", e);
            }
            std::thread::sleep(std::time::Duration::from_millis(249));
        }
    });
    let (options, free) = SplitChannelOptions::from_command_line_relaxed(
        "Usage: split_channel-benchmark-client [OPTIONS]",
    );
    if !free.is_empty() {
        eprintln!("command ignores positional arguments");
    }
    let (mut recv_chan, mut send_chan) = match options.connect() {
        Ok((recv_chan, send_chan)) => (recv_chan, send_chan),
        Err(e) => {
            panic!("err: {}", e);
        }
    };
    let mut counter = 0u64;
    loop {
        let msg = format!("ping {}", counter);
        let buf = msg.as_bytes();
        counter += 1;
        send_chan.send(buf).expect("send");
        let _ = recv_chan.recv().expect("recv");
    }
}

pub fn bind_to(&self) -> Result<Listener, Error>

Examples found in repository

examples/split_channel-benchmark-server.rs (line 36)

fn main() {
    std::thread::spawn(|| {
        let mut collector = Collector::new();
        split_channel::register_biometrics(&mut collector);
        let fout = File::create("/dev/stdout").unwrap();
        let mut emit = PlainTextEmitter::new(fout);
        loop {
            let now = SystemTime::now()
                .duration_since(SystemTime::UNIX_EPOCH)
                .expect("clock should never fail")
                .as_millis()
                .try_into()
                .expect("millis since epoch should fit u64");
            if let Err(e) = collector.emit(&mut emit, now) {
                eprintln!("collector error: {}", e);
            }
            std::thread::sleep(std::time::Duration::from_millis(249));
        }
    });

    let (options, free) = SplitChannelOptions::from_command_line_relaxed(
        "Usage: split_channel-benchmark-server [OPTIONS]",
    );
    if !free.is_empty() {
        eprintln!("command ignores positional arguments");
    }
    let listener = options.bind_to().expect("bind-to");

    let handle_client = |mut recv_chan: RecvChannel, mut send_chan: SendChannel| loop {
        let buf = recv_chan.recv().expect("recv");
        send_chan.send(&buf).expect("send");
    };
    let mut threads = Vec::new();
    for stream in listener {
        match stream {
            Ok((recv_chan, send_chan)) => {
                threads.push(std::thread::spawn(move || {
                    handle_client(recv_chan, send_chan);
                }));
            }
            Err(e) => {
                eprintln!("failure: {}", e);
            }
        }
    }
    for thread in threads.into_iter() {
        thread.join().expect("join");
    }
}

Trait Implementations

impl Clone for SplitChannelOptions

fn clone(&self) -> SplitChannelOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommandLine for SplitChannelOptions

fn add_opts(&self, prefix: Option<&str>, opts: &mut Options)

Add options to the getopts parser.

fn matches(&mut self, prefix: Option<&str>, matches: &Matches)

Assign values to self using the provided getopts matches.

fn canonical_command_line(&self, prefix: Option<&str>) -> Vec<String>

Return the canonical command line for this CommandLine.

fn from_command_line(usage: &str) -> (Self, Vec<String>)

Parse from the command line. This function will panic if a non-canonical command line is provided.

fn from_command_line_relaxed(usage: &str) -> (Self, Vec<String>)

Parse from the command line. This function will allow a non-canonical command line to execute.

fn from_arguments(usage: &str, args: &[&str]) -> (Self, Vec<String>)

Parse from the provided arguments. This function will panic if a non-canonical command line is provided.

fn from_arguments_relaxed(usage: &str, args: &[&str]) -> (Self, Vec<String>)

Parse from the provided arguments. This function will allow a non-canonical command line to execute.

fn usage(&mut self, opts: Options, brief: &str) -> !

Display the usage and exit 1.

impl Debug for SplitChannelOptions

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

Formats the value using the given formatter.

impl Default for SplitChannelOptions

fn default() -> SplitChannelOptions

Returns the “default value” for a type.

impl PartialEq for SplitChannelOptions

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for SplitChannelOptions

impl StructuralPartialEq for SplitChannelOptions