oca 0.2.0

An experiment with no_std
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

use crate::{
    ocp1::pdu::Parameters,
    types::{OcaEvent, OcaMethod},
};

pub mod ev1 {
    use super::*;

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub struct Notification1<'a> {
        pub target: OcaMethod,
        pub parameters: Notification1Parameters<'a>,
    }

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub struct Notification1Parameters<'a> {
        pub context: &'a [u8],
        pub event_data: Notification1EventData<'a>,
    }

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub struct Notification1EventData<'a> {
        pub event: OcaEvent,
        pub parameters: Parameters<'a>,
    }
}

pub mod ev2 {
    use super::*;

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub struct Notification2<'a> {
        pub event: OcaEvent,
        pub r#type: Notification2Type<'a>,
    }

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub enum Notification2Type<'a> {
        Event(&'a [u8]),
        Exception(Notification2ExceptionData<'a>),
    }

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub struct Notification2ExceptionData<'a> {
        pub r#type: Notification2ExceptionType,
        pub try_again: bool,
        pub data: &'a [u8],
    }

    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
    pub enum Notification2ExceptionType {
        Unspecified,
        CancelledByDevice,
        ObjectDeleted,
        DeviceError,
        Other(u8),
    }

    impl From<u8> for Notification2ExceptionType {
        fn from(value: u8) -> Notification2ExceptionType {
            match value {
                0 => Notification2ExceptionType::Unspecified,
                1 => Notification2ExceptionType::CancelledByDevice,
                2 => Notification2ExceptionType::ObjectDeleted,
                3 => Notification2ExceptionType::DeviceError,
                _ => Notification2ExceptionType::Other(value),
            }
        }
    }

    impl From<Notification2ExceptionType> for u8 {
        fn from(value: Notification2ExceptionType) -> u8 {
            match value {
                Notification2ExceptionType::Unspecified => 0,
                Notification2ExceptionType::CancelledByDevice => 1,
                Notification2ExceptionType::ObjectDeleted => 2,
                Notification2ExceptionType::DeviceError => 3,
                Notification2ExceptionType::Other(v) => v,
            }
        }
    }
}