meadow 0.4.0

Robotics-focused middleware for embedded Linux
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#![allow(unused_variables)]

mod host_operation;
pub use crate::error::host_operation::*;
#[cfg(feature = "quic")]
mod quic;
#[cfg(feature = "quic")]
pub use crate::error::quic::*;

use core::fmt::{Display, Formatter};
use serde::*;
use std::str::{FromStr, Utf8Error};
use thiserror::Error;

/// Meadow's Error type
#[derive(Debug, Clone, Error, Serialize, Deserialize, PartialEq)]
pub enum Error {
    /// Errors based on Host operations
    #[error(transparent)]
    HostOperation(crate::error::host_operation::HostError),
    /// No subscription value exists
    #[error("No subscription value exists")]
    NoSubscriptionValue,
    /// Couldn't achieve lock on shared resource
    #[error("Couldn't achieve lock on shared resource")]
    LockFailure,
    /// Unable to produce IP address from specified interface
    #[error("Unable to produce IP address from specified interface")]
    InvalidInterface,
    /// Transparent `sled` error
    #[error("`sled::Error`-derived error")]
    Sled(SledError),
    /// Unable to create a Tokio runtime
    #[error("Unable to create a Tokio runtime")]
    RuntimeCreation,
    /// Transparent `postcard`
    #[error(transparent)]
    Postcard(#[from] postcard::Error),
    /// Transparent std `Utf-8` error
    #[error("`std::str::Utf8Error`-derived error")]
    Utf8,
    /// Error accessing an owned `TcpStream`
    #[error("Error accessing an owned TcpStream")]
    AccessStream,
    /// Error accessing an owned `UdpSocket`
    #[error("Error accessing an owned UdpSocket")]
    AccessSocket,
    /// `TcpStream` connection attempt failure
    #[error("TcpStream connection attempt failure")]
    StreamConnection,
    /// Transparent QUIC-related errors
    #[cfg(feature = "quic")]
    #[error(transparent)]
    Quic(#[from] crate::error::quic::Quic),
    /// Transparent `std::io` error
    #[error("std::io::Error-derived error")]
    Io {
        error_kind: String,
        raw_os_error: Option<i32>,
    },
    #[error("Unable to access Tokio runtime handle")]
    HandleAccess,
    /// Topic does not exist on Host
    #[error("Topic `{0}` does not exist")]
    NonExistentTopic(String),
    /// Topic does not have value at specific n'th position
    #[error("Topic does not have value at specific n'th position")]
    NoNthValue,
    #[error("Undefined error")]
    Undefined,
}

/// This is the Result type used by meadow.
pub type Result<T> = ::core::result::Result<T, Error>;

#[derive(Debug, Clone, Serialize, Deserialize, Error, PartialEq, Eq)]
pub enum Sled {
    #[error("Collection not found")]
    CollectionNotFound,
    #[error("Unspecified sled-related error")]
    Other,
}

impl From<sled::Error> for Sled {
    fn from(value: sled::Error) -> Self {
        match value {
            sled::Error::CollectionNotFound(ivec) => Sled::CollectionNotFound,
            _ => Sled::Other,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Error, PartialEq, Eq)]
pub enum Postcard {
    #[error("Serde serialization error")]
    SerdeSerCustom,
    #[error("Serde deserialization error")]
    SerdeDeCustom,
    #[error("Other Postcard error")]
    Other,
}

impl From<postcard::Error> for Postcard {
    fn from(value: postcard::Error) -> Self {
        match value {
            postcard::Error::SerdeDeCustom => Postcard::SerdeDeCustom,
            postcard::Error::SerdeSerCustom => Postcard::SerdeSerCustom,
            _ => Postcard::Other,
        }
    }
}

impl From<std::io::Error> for Error {
    fn from(error: std::io::Error) -> Self {
        let error_kind = error.kind().to_string();

        Error::Io {
            error_kind,
            raw_os_error: error.raw_os_error(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct IoError {
    kind: String,
    raw_os_error: i32,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum SledError {
    CollectionNotFound(Vec<u8>),
    Other,
}

impl From<sled::Error> for Error {
    fn from(error: sled::Error) -> Self {
        match error {
            sled::Error::CollectionNotFound(ivec) => {
                let bytes: Vec<u8> = ivec.to_vec();
                Error::Sled(SledError::CollectionNotFound(bytes))
            }
            _ => Error::Sled(SledError::Other),
        }
    }
}

impl From<Utf8Error> for Error {
    fn from(error: Utf8Error) -> Self {
        Error::Utf8
    }
}