Parse argument in the form "1234:5678"

[potto216]

I want to parse a command line argument that contains a USB device's vendor and product ID in hexadecimal that is in the form "1234:5678" similar to Linux's lsusb -d 1234:5678
The way I implemented it is:

    let device = short('d') // start with a short name
        .long("device") // also add a long name
        .help("[vendor]:[product] Open a device with the specified vendor and product ID.  Both IDs are given in hexadecimal.")
        .argument::<String>("Device"); // and a help message to use

    let mut split = opts.device.split(":");
    
    let vec: Vec<&str> = split.collect();

    let vid = u16::from_str_radix(vec[0], 16).unwrap();
    let pid = u16::from_str_radix(vec[1], 16).unwrap();

Is this the most efficient way to parse this value?

[pacak]

I'd use parse https://docs.rs/bpaf/0.7.4/bpaf/trait.Parser.html#method.parse

So have a function that takes a string and returns a pair of numbers or an error and call that.

let parse_device(input: &str) -> Result<&'static str, (u16, u16)> {
    // it should be possible to parse this without allocations - just remember that split you get is an iterator and you can call
    // next to get the next value, then call `from_str_radix`  on that but transform the error to something helpful.
}

then use this function inside parse

    let device = short('d')
        .long("device")
        .help("[vendor]:[product] Open a device with the specified vendor and product ID.  Both IDs are given in hexadecimal.")
        .argument::<String>("Device")
        .parse(parse_device);

This way you will get a better error message if something goes wrong.

[potto216]

Thanks for the advice. I tried implementing your suggestion below:

fn parse_device(input: &str) -> std::result::Result<(u16, u16),  &'static str> {
    let mut split = input.split(":");
    
    //TODO: switch to an iterator
    let vec: Vec<&str> = split.collect();
    println!("Device is {}:{}", vec[0], vec[1]);

    let vid =u16::from_str_radix(vec[0], 16);
    if vid.is_err()  {
        return Err("TODO: Error message about vid");
    }


    let pid =u16::from_str_radix(vec[1], 16);
    if pid.is_err()  {
        return Err("TODO: Error message about pid");
    }

    Ok((vid.unwrap(), pid.unwrap()))
}

...

    let device = short('d') // start with a short name
        .long("device") // also add a long name
        .help("[vendor]:[product] Open a device with the specified vendor and product ID.  Both IDs are given in hexadecimal.")
        .argument::<String>("Device")
        .parse(parse_device); // and a help message to use

But I get the following compiler errors. It seems like the type in .argument::<String>("Device") should match what parse_device returns, but I cannot do that since FromStr is not defined for (u16,u16). Do you have any suggestions of what I should do?

error[E0631]: type mismatch in function arguments
   --> src/bin/bluetooth_le_controller.rs:53:16
    |
20  | fn parse_device(input: &str) -> std::result::Result<(u16, u16),  &'static str> {
    | ------------------------------------------------------------------------------ found signature defined here
...
53  |         .parse(parse_device); // and a help message to use
    |          ----- ^^^^^^^^^^^^ expected due to this
    |          |
    |          required by a bound introduced by this call
    |
    = note: expected function signature `fn(String) -> _`
               found function signature `for<'r> fn(&'r str) -> _`
note: required by a bound in `parse`
   --> /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/bpaf-0.7.4/src/lib.rs:926:12
    |
926 |         F: Fn(T) -> Result<R, E>,
    |            ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `parse`

error[E0599]: the method `meta` exists for struct `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>`, but its trait bounds were not satisfied
   --> src/bin/bluetooth_le_controller.rs:67:5
    |
67  | /     construct!(Out {
68  | |         device,
69  | |         verbose,
70  | |     })
    | |______^ method cannot be called on `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>` due to unsatisfied trait bounds
    |
   ::: /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/bpaf-0.7.4/src/structs.rs:300:1
    |
300 |   pub struct ParseWith<T, P, F, E, R> {
    |   ----------------------------------- doesn't satisfy `_: bpaf::Parser<_>`
    |
    = note: the following trait bounds were not satisfied:
            `<for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device} as FnOnce<(String,)>>::Output = Result<_, _>`
            which is required by `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>: bpaf::Parser<_>`
            `for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}: Fn<(String,)>`
            which is required by `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>: bpaf::Parser<_>`
    = note: this error originates in the macro `$crate::__cons_prepare` which comes from the expansion of the macro `construct` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0599]: the method `eval` exists for struct `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>`, but its trait bounds were not satisfied
   --> src/bin/bluetooth_le_controller.rs:67:5
    |
67  | /     construct!(Out {
68  | |         device,
69  | |         verbose,
70  | |     })
    | |______^ method cannot be called on `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>` due to unsatisfied trait bounds
    |
   ::: /home/user/.cargo/registry/src/github.com-1ecc6299db9ec823/bpaf-0.7.4/src/structs.rs:300:1
    |
300 |   pub struct ParseWith<T, P, F, E, R> {
    |   ----------------------------------- doesn't satisfy `_: bpaf::Parser<_>`
    |
    = note: the following trait bounds were not satisfied:
            `<for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device} as FnOnce<(String,)>>::Output = Result<_, _>`
            which is required by `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>: bpaf::Parser<_>`
            `for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}: Fn<(String,)>`
            which is required by `bpaf::structs::ParseWith<String, ParseArgument<String>, for<'r> fn(&'r str) -> Result<(u16, u16), &'static str> {parse_device}, _, _>: bpaf::Parser<_>`
    = note: this error originates in the macro `$crate::__cons_prepare` which comes from the expansion of the macro `construct` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0599, E0631.
For more information about an error, try `rustc --explain E0599`.

[pacak]

Try passing String instead of &str:

fn parse_device(input: String) -> std::result::Result<(u16, u16),  &'static str> {
    let mut split = input.split(":");
    ....

[potto216]

Thanks that worked (below).

fn parse_device(input: String) -> std::result::Result<(u16, u16),  &'static str> {
    let mut split = input.split(":");
    
    //TODO: switch to an iterator
    let vec: Vec<&str> = split.collect();
    println!("Device is {}:{}", vec[0], vec[1]);

    let vid =u16::from_str_radix(vec[0], 16);
    if vid.is_err()  {
        return Err("TODO: Error message about vid");
    }


    let pid =u16::from_str_radix(vec[1], 16);
    if pid.is_err()  {
        return Err("TODO: Error message about pid");
    }

    Ok((vid.unwrap(), pid.unwrap()))
}