seripack 0.1.0

Easy routing for packet/message like structs
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

// Relative Modules
pub mod encoder;

// Standard Uses
use std::collections::HashMap;

// Crate Uses
use crate::packet::Packet;
use crate::router::encoder::Encoder;

// External Uses
// use pyo3::*;


pub type PacketId = u8;

// #[pyclass]
pub struct Router {
    mutators: Vec<Box<dyn Encoder>>,
    builders: HashMap<PacketId, fn(Vec<u8>) -> Box<dyn Packet>>,
    receivers: HashMap<PacketId, Vec<fn(&Box<dyn Packet>)>>
}

// #[pymethods]
impl Router {
    pub fn new(&self, mutators: Vec<Box<dyn Encoder>>) -> Self {
        Self {
            mutators,
            builders: Default::default(),
            receivers: Default::default()
        }
    }

    pub fn add_mutator(&mut self, mutator: Box<dyn Encoder>) {
        self.mutators.push(mutator);
    }

    pub fn route(&self, message: Vec<u8>) -> String {
        if message.len() < 1 {
            return format!("Message needs to contain at least {} bytes, which is the packet id",
                std::mem::size_of::<PacketId>()
            )
        }

        let id = &message[0];

        if !self.builders.contains_key(id) {
            return format!("Received message with packet id {}, which is not registered to route",
                id
            )
        }

        let packet = self.builders[id](message[1..].to_owned());

        for receiver in &self.receivers[id] {
            receiver(&packet)
        }

        "".to_owned()
    }
}