jt_util 0.1.1

jt808 jt1078等基础库实现
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
131
132
133
134
135
136
137
138

use std::{fmt, usize};

use bytes::{BufMut, Bytes, BytesMut};

use serde::{de::Visitor, Deserialize, Serialize};
#[derive(Clone, Debug, Default)]
pub struct BytesBCD {
    bytes: Bytes,
    fixed_len: usize,
}
impl BytesBCD {
    pub fn new() -> Self {
        BytesBCD {
            bytes: Bytes::new(),
            fixed_len: 0,
        }
    }
    fn trim0(&mut self) -> usize {
        if self.bytes_len() > 0 {
            match self.bytes.iter().position(|b| *b > 0) {
                Some(i) => {
                    if i > 0 {
                        let _ = self.bytes.split_to(i);
                    }
                }
                None => self.bytes.clear(),
            }
        }
        self.bytes_len()
    }
    pub fn bytes_len(&self) -> usize {
        self.bytes.len()
    }
    pub fn set_bytes_len(&mut self, fixed_len: usize) {
        let mut len = self.bytes.len();
        self.fixed_len = fixed_len;
        if fixed_len > 0 && len != fixed_len {
            len = self.trim0();
            if len > fixed_len {
                self.bytes.split_at(fixed_len);
            } else if len < fixed_len {
                let mut buf = BytesMut::with_capacity(fixed_len);

                while buf.len() + len < fixed_len {
                    buf.put_u8(0u8);
                }
                buf.put(self.bytes.clone());

                self.bytes = buf.freeze();
            }
        }
    }
    pub fn get_bytes(&self) -> Bytes {
        self.bytes.clone()
    }
    pub fn set_bytes(&mut self, bytes: Bytes) {
        self.bytes = bytes;
    }
    pub fn get_val(&self) -> String {
        hex::encode(self.bytes.as_ref())
    }
    pub fn set_val(&mut self, val: &str, mut strlen: usize) {
        let ret_hex;
        if strlen % 2 > 0 {
            strlen = strlen + 1;
        }
        if val.len() != strlen {
            ret_hex = hex::decode(Self::fixsimlen(val.to_string(), strlen));
        } else {
            ret_hex = hex::decode(val);
        }
        match ret_hex {
            Ok(b) => {
                self.bytes = Bytes::from(b);
                self.set_bytes_len(strlen / 2);
            }
            Err(_) => {
                self.bytes.clear();
            }
        }
    }
    pub fn fixsimlen(sim: String, len: usize) -> String {
        let mut sim = sim;
        if sim.len() > len {
            sim.truncate(len);
        } else {
            while sim.len() < len {
                sim.insert_str(0, "0")
            }
        }
        sim
    }

    pub fn get_string(bytes: Bytes) -> String {
        hex::encode(bytes.as_ref())
    }
}

impl fmt::Display for BytesBCD {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.get_val())
    }
}

struct BytesBCDVisitor;

impl<'de> Visitor<'de> for BytesBCDVisitor {
    type Value = BytesBCD;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("expecting")
    }
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        let mut b = BytesBCD::new();
        b.set_val(v, v.len());
        Ok(b)
    }
}
impl<'de> Deserialize<'de> for BytesBCD {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = deserializer.deserialize_str(BytesBCDVisitor {})?;
        Ok(s)
    }
}
impl Serialize for BytesBCD {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.get_val().serialize(serializer)
    }
}