hamlib-client 1.1.0

Simple library that implements a client for Hamlib (rigctld)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/*
 * Copyright (C) 2024 Luca Cireddu <sardylan@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 *
 */

use crate::error::RigCtlError;
use crate::mode::Mode;
use crate::vfo::VFO;
use lazy_static::lazy_static;
use regex::Regex;
use std::fmt::{Display, Formatter};
use std::str::FromStr;

#[derive(Debug, PartialEq)]
pub struct Response {
    pub query_vfo: VFO,
    pub mode: Option<Mode>,
    pub passband: u64,
}

impl Display for Response {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Query VFO: {} - Mode: {} - Passband: {}",
            self.query_vfo,
            match self.mode {
                None => "None".to_string(),
                Some(m) => m.to_string(),
            },
            self.passband
        )
    }
}

pub fn parse(line: &str) -> Result<Response, RigCtlError> {
    lazy_static! {
        static ref RE: Regex = Regex::new(r"^get_split_mode: (?P<query_vfo>[a-zA-Z0-9]+)\|TX Mode: (?P<mode>[a-zA-Z0-9]*)\|TX Passband: (?P<passband>[0-9]+)\|RPRT 0$").unwrap();
    }

    let captures = RE.captures(&line).ok_or(RigCtlError::ResponseParsing(
        "Unable to capture groups".to_string(),
    ))?;
    log::trace!("Captures: {:?}", &captures);

    let query_vfo = captures
        .name("query_vfo")
        .ok_or_else(|| RigCtlError::ResponseParsing("Invalid query_vfo group".to_string()))?
        .as_str();
    let mode = captures
        .name("mode")
        .ok_or_else(|| RigCtlError::ResponseParsing("Invalid mode group".to_string()))?
        .as_str();
    let passband = captures
        .name("passband")
        .ok_or_else(|| RigCtlError::ResponseParsing("Invalid passband group".to_string()))?
        .as_str();

    let query_vfo = VFO::from_str(&query_vfo)?;
    let mode = Mode::from_str(&mode).ok();
    let passband = passband
        .parse::<u64>()
        .map_err(|e| RigCtlError::ResponseParsing(e.to_string()))?;

    Ok(Response {
        query_vfo,
        mode,
        passband,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_vfo_split_enabled() {
        let input = r"get_split_mode: VFOA|TX Mode: PKTUSB|TX Passband: 2400|RPRT 0";
        let expected = Response {
            query_vfo: VFO::VFOA,
            mode: Some(Mode::PKTUSB),
            passband: 2400u64,
        };
        let actual = parse(input);
        assert_eq!(actual.is_ok(), true);
        assert_eq!(actual.unwrap(), expected);
    }

    #[test]
    fn test_get_vfo_split_disabled() {
        let input = r"get_split_mode: VFOA|TX Mode: |TX Passband: 0|RPRT 0";
        let expected = Response {
            query_vfo: VFO::VFOA,
            mode: None,
            passband: 0u64,
        };
        let actual = parse(input);
        assert!(actual.is_ok());
        assert_eq!(actual.unwrap(), expected);
    }
}