parse_args_with_macro.rs

#![macro_use]

extern crate regex;

use regex::Regex;

#[derive(Debug)]
enum Errors {
    BadFormat,
}

use self::Errors::*;

impl From<std::num::ParseIntError> for Errors {
    fn from(_err: std::num::ParseIntError) -> Errors {
        BadFormat
    }
}

macro_rules! unwrap_or_return {
    ($expr:expr, $ret:expr) => (
        match $expr {
            Some(x) => x,
            None => { return $ret; }
        }
    )
}

macro_rules! unwrap_and_parse_or_return {
    ($expr:expr, $ret:expr) => (
        match $expr {
            Some(x) => try!(x.parse()),
            None => { return $ret; }
        }
    )
}

fn main() {
    let args = parse_args("100 200 300 400").unwrap();
    let (priority, delay, ttr, bytes) = args;
    
    println!("priority: {}, delay: {}, ttr: {}, bytes: {}", priority, delay, ttr, bytes);
}

fn parse_args(args: &str) -> Result<(u32, u64, u64, u16), Errors> {
    let re: Regex = Regex::new(r"^(\d+)\s(\d+)\s(\d+)\s(\d+)$").unwrap();

    let cap = unwrap_or_return!(re.captures(args), Err(BadFormat));
    let priority = unwrap_and_parse_or_return!(cap.at(1), Err(BadFormat));
    let delay = unwrap_and_parse_or_return!(cap.at(2), Err(BadFormat));
    let ttr = unwrap_and_parse_or_return!(cap.at(3), Err(BadFormat));
    let bytes = unwrap_and_parse_or_return!(cap.at(4), Err(BadFormat));

    Ok((priority, delay, ttr, bytes))
}