escvpnet 0.3.3

ESC/VP.net protocol library
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::{ pin::Pin, str::FromStr};

use async_trait::async_trait;
use tokio::io::{AsyncReadExt, AsyncBufReadExt, BufReader, AsyncWriteExt};

use crate::{
    error::ErrorKind,
    io::{DecodeFrom, EncodeTo},
};
#[derive(Debug, Clone, PartialEq)]
pub enum Command {
    Get { name: String },
    Set { name: String, value: String },
}

impl FromStr for Command {
    type Err = crate::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.trim_end();
        if s.contains("?") {
            let mut parts = s.split('?');
            let name = parts.next().ok_or(crate::Error::new(
                ErrorKind::Decoding,
                "Failed to decode command".to_string(),
            ))?;
            Ok(Self::Get {
                name: name.to_string(),
            })
        } else {
            let mut parts = s.split(' ');
            let name = parts.next().ok_or(crate::Error::new(
                ErrorKind::Decoding,
                "Failed to decode command".to_string(),
            ))?;
            let value = parts.next().ok_or(crate::Error::new(
                ErrorKind::Decoding,
                "Failed to decode command".to_string(),
            ))?;
            Ok(Self::Set {
                name: name.to_string(),
                value: value.to_string(),
            })
        }
    }
}
#[async_trait]
impl<R: AsyncReadExt+Send> DecodeFrom<R> for Command {
    type Error = crate::Error;
    async fn decode_from(reader: &mut Pin<&mut R>) -> Result<Self, Self::Error> {
        let mut reader = BufReader::new(reader);
        let mut buf = String::new();
        reader.read_line(&mut buf).await?;
        buf.parse()

    }
}
#[async_trait]
impl<W: AsyncWriteExt+Send> EncodeTo<W> for Command {
    type Error = crate::Error;
    async fn encode_to(self, writer: &mut Pin<&mut W>) -> Result<usize, Self::Error> {
        let command = match self {
            Self::Get { name } => {
                format!("{name}?\n")
            }
            Self::Set { name, value } => {
                format!("{name} {value}\n")
            }
        };
        writer.write_all(command.as_bytes()).await?;
        Ok(command.len())
    }
}

pub struct Response {
    name: String,
    value: String,
}

impl Response {
    pub fn name(&self) -> &str {
        self.name.as_ref()
    }

    pub fn value(&self) -> &str {
        self.value.as_ref()
    }
}
#[async_trait]
impl<R: AsyncReadExt+ Send> DecodeFrom<R> for Response {
    type Error = crate::Error;
    async fn decode_from(reader: &mut Pin<&mut R>) -> Result<Self, Self::Error> {
        let mut buf_reader = BufReader::new(reader);
        let mut buf = String::new();
        buf_reader.read_line(&mut buf).await?;
        let mut parts = buf.split("=");
        let name = parts
            .next()
            .ok_or(crate::Error::new(
                ErrorKind::Decoding,
                "Failed to decode response".to_string(),
            ))?
            .to_string();
        let value = parts
            .next()
            .ok_or(crate::Error::new(
                ErrorKind::Decoding,
                "Failed to decode response".to_string(),
            ))?
            .to_string();

        Ok(Self { name, value })
    }
}
#[cfg(test)]
mod tests {
use super::*;
    #[test]
    fn command() {
        let data = "PWR?\n";
        let command = Command::Get { name: "PWR".to_string() };
        let decoded_command:Command = data.parse().unwrap();
        assert_eq!(decoded_command, command);

        let data = "PWR ON\n";
        let command = Command::Set { name: "PWR".to_string(), value: "ON".to_string() } ;
        let decoded_command:Command = data.parse().unwrap();
        assert_eq!(decoded_command, command)

    }
}