someip_parse 0.6.2

A library for parsing the SOME/IP network protocol (without payload interpretation).
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

use super::*;

/// Error when decoding an SOMEIP header via a `std::io::Read` source.
#[derive(Debug)]
pub enum SomeipHeaderReadError {
    /// IO error was encoutered while reading header.
    Io(std::io::Error),

    /// Error caused by the contents of the header.
    Content(SomeipHeaderError),
}

impl SomeipHeaderReadError {
    /// Returns the `std::io::Error` value if the `SomeipHeaderReadError` is `Io`.
    /// Otherwise `None` is returned.
    #[inline]
    pub fn io_error(self) -> Option<std::io::Error> {
        use SomeipHeaderReadError::*;
        match self {
            Io(value) => Some(value),
            _ => None,
        }
    }

    /// Returns the [`crate::err::SomeipHeaderError`] value if the `SomeipHeaderReadError` is `Content`.
    /// Otherwise `None` is returned.
    #[inline]
    pub fn content_error(self) -> Option<SomeipHeaderError> {
        use SomeipHeaderReadError::*;
        match self {
            Content(value) => Some(value),
            _ => None,
        }
    }
}

impl core::fmt::Display for SomeipHeaderReadError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        use SomeipHeaderReadError::*;
        match self {
            Io(err) => write!(f, "SOMEIP Header IO Error: {}", err),
            Content(value) => value.fmt(f),
        }
    }
}

impl std::error::Error for SomeipHeaderReadError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        use SomeipHeaderReadError::*;
        match self {
            Io(err) => Some(err),
            Content(err) => Some(err),
        }
    }
}

#[cfg(test)]
mod test {
    use super::{SomeipHeaderReadError::*, *};

    #[test]
    fn debug() {
        let err = SomeipHeaderError::UnsupportedProtocolVersion(0);
        assert_eq!(
            format!("Content({:?})", err.clone()),
            format!("{:?}", Content(err))
        );
    }

    #[test]
    fn fmt() {
        {
            let err = std::io::Error::new(
                std::io::ErrorKind::UnexpectedEof,
                "failed to fill whole buffer",
            );
            assert_eq!(
                format!("SOMEIP Header IO Error: {}", err),
                format!("{}", Io(err))
            );
        }
        {
            let err = SomeipHeaderError::UnsupportedProtocolVersion(0);
            assert_eq!(format!("{}", &err), format!("{}", Content(err.clone())));
        }
    }

    #[test]
    fn source() {
        use std::error::Error;
        assert!(Io(std::io::Error::new(
            std::io::ErrorKind::UnexpectedEof,
            "failed to fill whole buffer",
        ))
        .source()
        .is_some());
        assert!(Content(SomeipHeaderError::UnsupportedProtocolVersion(0))
            .source()
            .is_some());
    }

    #[test]
    fn io_error() {
        assert!(Io(std::io::Error::new(
            std::io::ErrorKind::UnexpectedEof,
            "failed to fill whole buffer",
        ))
        .io_error()
        .is_some());
        assert!(Content(SomeipHeaderError::UnsupportedProtocolVersion(0))
            .io_error()
            .is_none());
    }

    #[test]
    fn content_error() {
        assert_eq!(
            None,
            Io(std::io::Error::new(
                std::io::ErrorKind::UnexpectedEof,
                "failed to fill whole buffer",
            ))
            .content_error()
        );
        {
            let err = SomeipHeaderError::UnsupportedProtocolVersion(0);
            assert_eq!(Some(err.clone()), Content(err.clone()).content_error());
        }
    }
}