dash7 0.7.3

Implementation of a DASH7 ALP protocol codec.
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

use deku::bitvec::{BitSlice, BitVec, Msb0};
use deku::prelude::*;

use super::operand::{Status, StatusOperand};
use crate::session::{InterfaceFinalStatus, InterfaceTxStatus};
use crate::utils::{read_length_prefixed, write_length_prefixed};

#[derive(DekuRead, DekuWrite, Debug, Clone, PartialEq)]
pub struct InterfaceFinalStatusOperand {
    pub interface_id: u8,

    #[deku(
        reader = "InterfaceFinalStatusOperand::read(deku::rest, *interface_id)",
        writer = "InterfaceFinalStatusOperand::write(deku::output, &self.status, self.interface_id)"
    )]
    pub status: InterfaceFinalStatus,
}

impl From<InterfaceFinalStatus> for InterfaceFinalStatusOperand {
    fn from(status: InterfaceFinalStatus) -> Self {
        Self {
            interface_id: status.deku_id().unwrap().deku_id().unwrap(),
            status,
        }
    }
}

impl Into<StatusOperand> for InterfaceFinalStatusOperand {
    fn into(self) -> StatusOperand {
        Status::InterfaceFinal(self).into()
    }
}

impl InterfaceFinalStatusOperand {
    pub fn read<'a>(
        rest: &'a BitSlice<u8, Msb0>,
        interface_id: u8,
    ) -> Result<(&'a BitSlice<u8, Msb0>, InterfaceFinalStatus), DekuError> {
        return read_length_prefixed(rest, interface_id);
    }

    pub fn write(
        output: &mut BitVec<u8, Msb0>,
        status: &InterfaceFinalStatus,
        interface_id: u8,
    ) -> Result<(), DekuError> {
        let vec_size = match status {
            InterfaceFinalStatus::Other(val) => val.len() as u32,
            _ => 0,
        };
        return write_length_prefixed(output, status, interface_id, vec_size);
    }
}

#[derive(DekuRead, DekuWrite, Clone, Copy, Debug, PartialEq)]
#[deku(bits = 2, type = "u8")]
pub enum TxStatusType {
    #[deku(id = "1")]
    Interface,
}

#[derive(DekuRead, DekuWrite, Debug, Clone, PartialEq)]
pub struct TxStatusOperand {
    #[deku(update = "self.status.deku_id().unwrap()", pad_bits_after = "6")]
    status_type: TxStatusType,

    #[deku(ctx = "*status_type")]
    pub status: TxStatus,
}

#[derive(DekuRead, DekuWrite, Debug, Clone, PartialEq)]
#[deku(ctx = "status_type: TxStatusType", id = "status_type")]
pub enum TxStatus {
    #[deku(id = "TxStatusType::Interface")]
    Interface(InterfaceTxStatusOperand),
}

#[derive(DekuRead, DekuWrite, Debug, Clone, PartialEq)]
pub struct InterfaceTxStatusOperand {
    pub interface_id: u8,

    #[deku(
        reader = "InterfaceTxStatusOperand::read(deku::rest, *interface_id)",
        writer = "InterfaceTxStatusOperand::write(deku::output, &self.status, self.interface_id)"
    )]
    pub status: InterfaceTxStatus,
}

impl From<InterfaceTxStatus> for InterfaceTxStatusOperand {
    fn from(status: InterfaceTxStatus) -> Self {
        Self {
            interface_id: status.deku_id().unwrap().deku_id().unwrap(),
            status,
        }
    }
}

impl InterfaceTxStatusOperand {
    pub fn read<'a>(
        rest: &'a BitSlice<u8, Msb0>,
        interface_id: u8,
    ) -> Result<(&'a BitSlice<u8, Msb0>, InterfaceTxStatus), DekuError> {
        return read_length_prefixed(rest, interface_id);
    }

    pub fn write(
        output: &mut BitVec<u8, Msb0>,
        status: &InterfaceTxStatus,
        interface_id: u8,
    ) -> Result<(), DekuError> {
        let vec_size = match status {
            InterfaceTxStatus::Other(val) => val.len() as u32,
            _ => 0,
        };
        return write_length_prefixed(output, status, interface_id, vec_size);
    }
}