jt_util/
bytes_bcd.rs

1use std::{fmt, usize};
2
3use bytes::{BufMut, Bytes, BytesMut};
4
5use serde::{de::Visitor, Deserialize, Serialize};
6#[derive(Clone, Debug, Default)]
7pub struct BytesBCD {
8    bytes: Bytes,
9    fixed_len: usize,
10}
11impl BytesBCD {
12    pub fn new() -> Self {
13        BytesBCD {
14            bytes: Bytes::new(),
15            fixed_len: 0,
16        }
17    }
18    fn trim0(&mut self) -> usize {
19        if self.bytes_len() > 0 {
20            match self.bytes.iter().position(|b| *b > 0) {
21                Some(i) => {
22                    if i > 0 {
23                        let _ = self.bytes.split_to(i);
24                    }
25                }
26                None => self.bytes.clear(),
27            }
28        }
29        self.bytes_len()
30    }
31    pub fn bytes_len(&self) -> usize {
32        self.bytes.len()
33    }
34    pub fn set_bytes_len(&mut self, fixed_len: usize) {
35        let mut len = self.bytes.len();
36        self.fixed_len = fixed_len;
37        if fixed_len > 0 && len != fixed_len {
38            len = self.trim0();
39            if len > fixed_len {
40                self.bytes.split_at(fixed_len);
41            } else if len < fixed_len {
42                let mut buf = BytesMut::with_capacity(fixed_len);
43
44                while buf.len() + len < fixed_len {
45                    buf.put_u8(0u8);
46                }
47                buf.put(self.bytes.clone());
48
49                self.bytes = buf.freeze();
50            }
51        }
52    }
53    pub fn get_bytes(&self) -> Bytes {
54        self.bytes.clone()
55    }
56    pub fn set_bytes(&mut self, bytes: Bytes) {
57        self.bytes = bytes;
58    }
59    pub fn get_val(&self) -> String {
60        hex::encode(self.bytes.as_ref())
61    }
62    pub fn set_val(&mut self, val: &str, mut strlen: usize) {
63        let ret_hex;
64        if strlen % 2 > 0 {
65            strlen = strlen + 1;
66        }
67        if val.len() != strlen {
68            ret_hex = hex::decode(Self::fixsimlen(val.to_string(), strlen));
69        } else {
70            ret_hex = hex::decode(val);
71        }
72        match ret_hex {
73            Ok(b) => {
74                self.bytes = Bytes::from(b);
75                self.set_bytes_len(strlen / 2);
76            }
77            Err(_) => {
78                self.bytes.clear();
79            }
80        }
81    }
82    pub fn fixsimlen(sim: String, len: usize) -> String {
83        let mut sim = sim;
84        if sim.len() > len {
85            sim.truncate(len);
86        } else {
87            while sim.len() < len {
88                sim.insert_str(0, "0")
89            }
90        }
91        sim
92    }
93
94    pub fn get_string(bytes: Bytes) -> String {
95        hex::encode(bytes.as_ref())
96    }
97}
98
99impl fmt::Display for BytesBCD {
100    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
101        write!(f, "{}", self.get_val())
102    }
103}
104
105struct BytesBCDVisitor;
106
107impl<'de> Visitor<'de> for BytesBCDVisitor {
108    type Value = BytesBCD;
109
110    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
111        formatter.write_str("expecting")
112    }
113    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
114    where
115        E: serde::de::Error,
116    {
117        let mut b = BytesBCD::new();
118        b.set_val(v, v.len());
119        Ok(b)
120    }
121}
122impl<'de> Deserialize<'de> for BytesBCD {
123    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
124    where
125        D: serde::Deserializer<'de>,
126    {
127        let s = deserializer.deserialize_str(BytesBCDVisitor {})?;
128        Ok(s)
129    }
130}
131impl Serialize for BytesBCD {
132    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
133    where
134        S: serde::Serializer,
135    {
136        self.get_val().serialize(serializer)
137    }
138}
jt_util/bytes_bcd.rs

jt_util/
bytes_bcd.rs
