libacc 0.1.0

Library for the ACC protocol
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

use std::io::{Error, ErrorKind};

use bson::Document;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
pub struct AccVersion1 {
    v: i32,
    //other stuff
    // TODO: evaluate switching this to a getter instead of a pub
    pub d: bson::Binary,
}
impl AccVersion1 {
    pub fn new(data: &[u8]) -> AccVersion1 {
        AccVersion1 {
            v: 1,
            d: bson::Binary {
                subtype: bson::spec::BinarySubtype::Generic,
                bytes: Vec::from(data),
            },
        }
    }
}/*
impl Serialize for AccVersion1 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("AccVersion1", 2)?;
        state.serialize_field("v", &self.v)?;
        state.serialize_field("d", &self.d)?;
        state.end()
    }
}*/
#[derive(PartialEq, Debug)]
pub enum PacketVersion {
    V1(AccVersion1),
}

pub(crate) fn encapsulate(acc_enum: &PacketVersion) -> Result<Vec<u8>, std::io::Error> {
    let acc_struct = match acc_enum {
        PacketVersion::V1(structure) => structure,
    };
    Ok(bson::to_vec(&acc_struct).unwrap())
}

pub(crate) fn reveal(bson_vec: &[u8]) -> Result<PacketVersion, std::io::Error> {
    let doc: Document = bson::from_slice(bson_vec).unwrap();
    let version = doc.get_i32("v");
    let result = match version {
        Ok(0) | Ok(1) => {
            let acc_struct: AccVersion1 = bson::from_document(doc).unwrap();
            PacketVersion::V1(acc_struct)
        }
        Ok(_) => return Err(Error::from(ErrorKind::Unsupported)),
        Err(error) => panic!("Error: {}", error),
    };
    Ok(result)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bson_test() {
        let pkt = PacketVersion::V1(AccVersion1::new(
            b"somebody once told me the world was gonna roll me",
        ));
        let result = reveal(&encapsulate(&pkt).unwrap()).unwrap();
        assert_eq!(pkt, result)
    }
}