mwc_bch/messages/
filter_add.rs

1use hex;
2use messages::message::Payload;
3use std::fmt;
4use std::io;
5use std::io::{Read, Write};
6use util::{var_int, Error, Result, Serializable};
7
8/// Maximum size of a data element in the FilterAdd message
9pub const MAX_FILTER_ADD_DATA_SIZE: usize = 520;
10
11/// Adds a data element to the bloom filter
12#[derive(Default, PartialEq, Eq, Hash, Clone)]
13pub struct FilterAdd {
14    /// Data element to be added
15    pub data: Vec<u8>,
16}
17
18impl FilterAdd {
19    /// Returns whether the FilterAdd message is valid
20    pub fn validate(&self) -> Result<()> {
21        if self.data.len() > MAX_FILTER_ADD_DATA_SIZE {
22            return Err(Error::BadData("Data too long".to_string()));
23        }
24        Ok(())
25    }
26}
27
28impl Serializable<FilterAdd> for FilterAdd {
29    fn read(reader: &mut dyn Read) -> Result<FilterAdd> {
30        let data_len = var_int::read(reader)?;
31        let mut data = vec![0; data_len as usize];
32        reader.read(&mut data)?;
33        Ok(FilterAdd { data })
34    }
35
36    fn write(&self, writer: &mut dyn Write) -> io::Result<()> {
37        var_int::write(self.data.len() as u64, writer)?;
38        writer.write(&self.data)?;
39        Ok(())
40    }
41}
42
43impl Payload<FilterAdd> for FilterAdd {
44    fn size(&self) -> usize {
45        var_int::size(self.data.len() as u64) + self.data.len()
46    }
47}
48
49impl fmt::Debug for FilterAdd {
50    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
51        f.debug_struct("FilterAdd")
52            .field("data", &hex::encode(&self.data))
53            .finish()
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60    use std::io::Cursor;
61
62    #[test]
63    fn read_bytes() {
64        let b = hex::decode(
65            "20fdacf9b3eb077412e7a968d2e4f11b9a9dee312d666187ed77ee7d26af16cb0b".as_bytes(),
66        ).unwrap();
67        let f = FilterAdd::read(&mut Cursor::new(&b)).unwrap();
68        assert!(f.data.len() == 32);
69    }
70
71    #[test]
72    fn write_read() {
73        let mut v = Vec::new();
74        let p = FilterAdd { data: vec![20; 20] };
75        p.write(&mut v).unwrap();
76        assert!(v.len() == p.size());
77        assert!(FilterAdd::read(&mut Cursor::new(&v)).unwrap() == p);
78    }
79
80    #[test]
81    fn validate() {
82        let p = FilterAdd { data: vec![21; 21] };
83        assert!(p.validate().is_ok());
84
85        let p = FilterAdd {
86            data: vec![21; MAX_FILTER_ADD_DATA_SIZE + 1],
87        };
88        assert!(p.validate().is_err());
89    }
90}