spvirit-client 0.1.9

PVAccess client library — search, connect, get, put, monitor.
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

use std::net::SocketAddr;
use std::time::Duration;

use spvirit_codec::spvd_decode::{DecodedValue, StructureDesc};

/// Configuration for PV operations (get, put, monitor, info).
#[derive(Clone, Debug)]
pub struct PvOptions {
    pub pv_name: String,
    pub timeout: Duration,
    pub server_addr: Option<SocketAddr>,
    pub search_addr: Option<std::net::IpAddr>,
    pub bind_addr: Option<std::net::IpAddr>,
    pub name_servers: Vec<SocketAddr>,
    pub udp_port: u16,
    pub tcp_port: u16,
    pub debug: bool,
    pub no_broadcast: bool,
    pub authnz_user: Option<String>,
    pub authnz_host: Option<String>,
}

/// Backwards-compatible alias — prefer [`PvOptions`].
pub type PvGetOptions = PvOptions;

impl PvOptions {
    pub fn new(pv_name: String) -> Self {
        Self {
            pv_name,
            timeout: Duration::from_secs(5),
            server_addr: None,
            search_addr: None,
            bind_addr: None,
            name_servers: Vec::new(),
            udp_port: 5076,
            tcp_port: 5075,
            debug: false,
            no_broadcast: false,
            authnz_user: None,
            authnz_host: None,
        }
    }
}

/// A single monitor update delivered by [`PvaClient::pvmonitor`](crate::pva_client::PvaClient::pvmonitor).
#[derive(Debug, Clone)]
pub struct PvMonitorEvent {
    pub pv_name: String,
    pub value: DecodedValue,
}

#[derive(Debug)]
pub struct PvGetResult {
    pub pv_name: String,
    pub value: DecodedValue,
    pub raw_pva: Vec<u8>,
    pub raw_pvd: Vec<u8>,
    pub introspection: StructureDesc,
}

#[derive(Debug)]
pub enum PvGetError {
    Io(std::io::Error),
    Timeout(&'static str),
    Search(&'static str),
    Protocol(String),
    Decode(String),
}

impl std::fmt::Display for PvGetError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PvGetError::Io(e) => write!(f, "io error: {}", e),
            PvGetError::Timeout(ctx) => write!(f, "timeout: {}", ctx),
            PvGetError::Search(ctx) => write!(f, "search error: {}", ctx),
            PvGetError::Protocol(ctx) => write!(f, "protocol error: {}", ctx),
            PvGetError::Decode(ctx) => write!(f, "decode error: {}", ctx),
        }
    }
}

impl std::error::Error for PvGetError {}

impl From<std::io::Error> for PvGetError {
    fn from(value: std::io::Error) -> Self {
        Self::Io(value)
    }
}