erdos 0.4.0

ERDOS is a platform for developing self-driving cars and robotics applications.
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

use abomonation::{decode, encode, measure, Abomonation};
use bytes::{BufMut, BytesMut};
use serde::{Deserialize, Serialize};
use std::{
    fmt::Debug,
    io::{Error, ErrorKind},
};

use crate::communication::CommunicationError;

/// Wrapper around a deserialized message. The wrapper can either own the deserialized
/// message or store a reference to it.
pub enum DeserializedMessage<'a, T> {
    Ref(&'a T),
    Owned(T),
}

/// Trait automatically derived for all messages that derive `Serialize`.
pub trait Serializable {
    fn encode(&self) -> Result<BytesMut, CommunicationError>;
    fn encode_into(&self, buffer: &mut BytesMut) -> Result<(), CommunicationError>;
    fn serialized_size(&self) -> Result<usize, CommunicationError>;
}

impl<D> Serializable for D
where
    D: Debug + Clone + Send + Serialize,
{
    default fn encode(&self) -> Result<BytesMut, CommunicationError> {
        let serialized_msg = bincode::serialize(self).map_err(CommunicationError::from)?;
        let serialized_msg: BytesMut = BytesMut::from(&serialized_msg[..]);
        Ok(serialized_msg)
    }

    default fn encode_into(&self, buffer: &mut BytesMut) -> Result<(), CommunicationError> {
        let mut writer = buffer.writer();
        bincode::serialize_into(&mut writer, self).map_err(CommunicationError::from)
    }

    default fn serialized_size(&self) -> Result<usize, CommunicationError> {
        bincode::serialized_size(&self)
            .map(|x| x as usize)
            .map_err(CommunicationError::from)
    }
}

/// Specialized version used when messages derive `Abomonation`.
impl<D> Serializable for D
where
    D: Debug + Clone + Send + Serialize + Abomonation,
{
    fn encode(&self) -> Result<BytesMut, CommunicationError> {
        let mut serialized_msg: Vec<u8> = Vec::with_capacity(measure(self));
        unsafe {
            encode(self, &mut serialized_msg).map_err(CommunicationError::AbomonationError)?;
        }
        let serialized_msg: BytesMut = BytesMut::from(&serialized_msg[..]);
        Ok(serialized_msg)
    }

    fn encode_into(&self, buffer: &mut BytesMut) -> Result<(), CommunicationError> {
        let mut writer = buffer.writer();
        unsafe { encode(self, &mut writer).map_err(CommunicationError::AbomonationError) }
    }

    fn serialized_size(&self) -> Result<usize, CommunicationError> {
        Ok(abomonation::measure(self))
    }
}

/// Trait automatically derived for all messages that derive `Deserialize`.
pub trait Deserializable<'a>: Sized {
    fn decode(buf: &'a mut BytesMut) -> Result<DeserializedMessage<'a, Self>, CommunicationError>;
}

impl<'a, D> Deserializable<'a> for D
where
    D: Debug + Clone + Send + Deserialize<'a>,
{
    default fn decode(
        buf: &'a mut BytesMut,
    ) -> Result<DeserializedMessage<'a, D>, CommunicationError> {
        let msg: D = bincode::deserialize(buf).map_err(CommunicationError::from)?;
        Ok(DeserializedMessage::Owned(msg))
    }
}

/// Specialized version used when messages derive `Abomonation`.
impl<'a, D> Deserializable<'a> for D
where
    D: Debug + Clone + Send + Deserialize<'a> + Abomonation,
{
    fn decode(buf: &'a mut BytesMut) -> Result<DeserializedMessage<'a, D>, CommunicationError> {
        let (msg, _) = {
            unsafe {
                match decode::<D>(buf.as_mut()) {
                    Some(msg) => msg,
                    None => {
                        return Err(CommunicationError::AbomonationError(Error::new(
                            ErrorKind::Other,
                            "Deserialization failed",
                        )))
                    }
                }
            }
        };
        Ok(DeserializedMessage::Ref(msg))
    }
}