open_dis_rust/simulation_management_with_reliability/
data_reliable_pdu.rs

1//     open-dis-rust - Rust implementation of the IEEE 1278.1-2012 Distributed Interactive
2//                     Simulation (DIS) application protocol
3//     Copyright (C) 2023 Cameron Howell
4//
5//     Licensed under the BSD 2-Clause License
6
7use crate::common::{
8    dis_error::DISError,
9    entity_id::EntityId,
10    pdu::Pdu,
11    pdu_header::{PduHeader, PduType, ProtocolFamily},
12};
13use bytes::{Buf, BufMut, BytesMut};
14use std::any::Any;
15
16#[derive(Copy, Clone, Debug)]
17/// Implemented according to IEEE 1278.1-2012 §7.11.11
18pub struct DataReliablePdu {
19    pub pdu_header: PduHeader,
20    pub originating_entity_id: EntityId,
21    pub receiving_entity_id: EntityId,
22    pub request_id: u32,
23    pub required_reliability_service: u8,
24    pub pad1: u16,
25    pub pad2: u8,
26    pub number_of_fixed_datum_records: u32,
27    pub number_of_variable_datum_records: u32,
28    pub fixed_datum_records: u64,
29    pub variable_datum_records: u64,
30}
31
32impl Default for DataReliablePdu {
33    fn default() -> Self {
34        DataReliablePdu {
35            pdu_header: PduHeader::default(
36                PduType::DataReliable,
37                ProtocolFamily::SimulationManagementWithReliability,
38                56,
39            ),
40            originating_entity_id: EntityId::default(1),
41            receiving_entity_id: EntityId::default(2),
42            request_id: 0,
43            required_reliability_service: 0,
44            pad1: 0,
45            pad2: 0,
46            number_of_fixed_datum_records: 0,
47            number_of_variable_datum_records: 0,
48            fixed_datum_records: 0,
49            variable_datum_records: 0,
50        }
51    }
52}
53
54impl Pdu for DataReliablePdu {
55    fn serialize(&mut self, buf: &mut BytesMut) {
56        self.pdu_header.length = u16::try_from(std::mem::size_of_val(self))
57            .expect("The length of the PDU should fit in a u16.");
58        self.pdu_header.serialize(buf);
59        self.originating_entity_id.serialize(buf);
60        self.receiving_entity_id.serialize(buf);
61        buf.put_u32(self.request_id);
62        buf.put_u8(self.required_reliability_service);
63        buf.put_u16(self.pad1);
64        buf.put_u8(self.pad2);
65        buf.put_u32(self.number_of_fixed_datum_records);
66        buf.put_u32(self.number_of_variable_datum_records);
67        buf.put_u64(self.fixed_datum_records);
68        buf.put_u64(self.variable_datum_records);
69    }
70
71    fn deserialize(mut buffer: BytesMut) -> Result<Self, DISError>
72    where
73        Self: Sized,
74    {
75        let pdu_header = PduHeader::deserialize(&mut buffer);
76        if pdu_header.pdu_type == PduType::DataReliable {
77            let originating_entity_id = EntityId::deserialize(&mut buffer);
78            let receiving_entity_id = EntityId::deserialize(&mut buffer);
79            let request_id = buffer.get_u32();
80            let required_reliability_service = buffer.get_u8();
81            let pad1 = buffer.get_u16();
82            let pad2 = buffer.get_u8();
83            let number_of_fixed_datum_records = buffer.get_u32();
84            let number_of_variable_datum_records = buffer.get_u32();
85            let mut fixed_datum_records: u64 = 0;
86            for _record in 0..number_of_fixed_datum_records as usize {
87                fixed_datum_records += buffer.get_u64();
88            }
89            let mut variable_datum_records: u64 = 0;
90            for _record in 0..number_of_variable_datum_records as usize {
91                variable_datum_records += buffer.get_u64();
92            }
93
94            Ok(DataReliablePdu {
95                pdu_header,
96                originating_entity_id,
97                receiving_entity_id,
98                request_id,
99                required_reliability_service,
100                pad1,
101                pad2,
102                number_of_fixed_datum_records,
103                number_of_variable_datum_records,
104                fixed_datum_records,
105                variable_datum_records,
106            })
107        } else {
108            Err(DISError::invalid_header(
109                format!(
110                    "Expected PDU type DataReliable, got {:?}",
111                    pdu_header.pdu_type
112                ),
113                None,
114            ))
115        }
116    }
117
118    fn as_any(&self) -> &dyn Any {
119        self
120    }
121
122    fn deserialize_without_header(
123        mut buffer: BytesMut,
124        pdu_header: PduHeader,
125    ) -> Result<Self, DISError>
126    where
127        Self: Sized,
128    {
129        let originating_entity_id = EntityId::deserialize(&mut buffer);
130        let receiving_entity_id = EntityId::deserialize(&mut buffer);
131        let request_id = buffer.get_u32();
132        let required_reliability_service = buffer.get_u8();
133        let pad1 = buffer.get_u16();
134        let pad2 = buffer.get_u8();
135        let number_of_fixed_datum_records = buffer.get_u32();
136        let number_of_variable_datum_records = buffer.get_u32();
137        let mut fixed_datum_records: u64 = 0;
138        for _record in 0..number_of_fixed_datum_records as usize {
139            fixed_datum_records += buffer.get_u64();
140        }
141        let mut variable_datum_records: u64 = 0;
142        for _record in 0..number_of_variable_datum_records as usize {
143            variable_datum_records += buffer.get_u64();
144        }
145
146        Ok(DataReliablePdu {
147            pdu_header,
148            originating_entity_id,
149            receiving_entity_id,
150            request_id,
151            required_reliability_service,
152            pad1,
153            pad2,
154            number_of_fixed_datum_records,
155            number_of_variable_datum_records,
156            fixed_datum_records,
157            variable_datum_records,
158        })
159    }
160}
161
162#[cfg(test)]
163mod tests {
164    use super::DataReliablePdu;
165    use crate::common::{
166        pdu::Pdu,
167        pdu_header::{PduHeader, PduType, ProtocolFamily},
168    };
169    use bytes::BytesMut;
170
171    #[test]
172    fn create_header() {
173        let data_reliable_pdu = DataReliablePdu::default();
174        let pdu_header = PduHeader::default(
175            PduType::DataReliable,
176            ProtocolFamily::SimulationManagementWithReliability,
177            448 / 8,
178        );
179
180        assert_eq!(
181            pdu_header.protocol_version,
182            data_reliable_pdu.pdu_header.protocol_version
183        );
184        assert_eq!(
185            pdu_header.exercise_id,
186            data_reliable_pdu.pdu_header.exercise_id
187        );
188        assert_eq!(pdu_header.pdu_type, data_reliable_pdu.pdu_header.pdu_type);
189        assert_eq!(
190            pdu_header.protocol_family,
191            data_reliable_pdu.pdu_header.protocol_family
192        );
193        assert_eq!(pdu_header.length, data_reliable_pdu.pdu_header.length);
194        assert_eq!(
195            pdu_header.status_record,
196            data_reliable_pdu.pdu_header.status_record
197        );
198    }
199
200    #[test]
201    fn deserialize_header() {
202        let mut data_reliable_pdu = DataReliablePdu::default();
203        let mut buffer = BytesMut::new();
204        data_reliable_pdu.serialize(&mut buffer);
205
206        let new_data_reliable_pdu = DataReliablePdu::deserialize(buffer).unwrap();
207        assert_eq!(
208            new_data_reliable_pdu.pdu_header,
209            data_reliable_pdu.pdu_header
210        );
211    }
212}
open_dis_rust/simulation_management_with_reliability/data_reliable_pdu.rs

open_dis_rust/simulation_management_with_reliability/
data_reliable_pdu.rs
