open-dis-rust 0.4.2

A Rust implementation of the IEEE 1278.1-2012 DIS Standard.
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

//     open-dis-rust - Rust implementation of the IEEE 1278.1-2012 Distributed Interactive
//                     Simulation (DIS) application protocol
//     Copyright (C) 2025 Cameron Howell
//
//     Licensed under the BSD 2-Clause License

//! The Information Operations protocol family

use crate::common::enums::{
    IOActionIOActionPhase, IOActionIOActionType, IOActionIOSimulationSource, IOActionIOWarfareType,
    IOReportIOReportType, PduType, ProtocolFamily,
};
use crate::common::generic_header::GenericHeader;
use crate::common::{
    SerializedLength,
    data_types::{
        SimulationIdentifier, entity_id::EntityId,
        standard_variable_specification::StandardVariableSpecification,
    },
    pdu::Pdu,
    pdu_header::PduHeader,
};
use crate::define_pdu;

define_pdu! {
    #[derive(Debug)]
    /// Implemented according to IEEE 1278.1-2012 §7.12.3
    pub struct InformationOperationsReportPdu {
        header: PduHeader,
        pdu_type: PduType::InformationOperationsReport,
        protocol_family: ProtocolFamily::InformationOperations,
        fields: {
            pub originating_simulation_id: SimulationIdentifier,
            pub io_simulation_source: IOActionIOSimulationSource,
            pub io_report_type: IOReportIOReportType,
            padding: u8,
            pub io_attacker_entity_id: EntityId,
            pub primary_target_entity_id: EntityId,
            padding2: u16,
            padding3: u16,
            pub io_records: StandardVariableSpecification,
        }
    }
}

define_pdu! {
    #[derive(Debug)]
    /// Implemented according to IEEE 1278.1-2012 §7.12.2
    pub struct InformationOperationsActionPdu {
        header: PduHeader,
        pdu_type: PduType::InformationOperationsAction,
        protocol_family: ProtocolFamily::InformationOperations,
        fields: {
            pub originating_simulation_id: SimulationIdentifier,
            pub receiving_simulation_id: SimulationIdentifier,
            pub request_id: u32,
            pub io_warfare_type: IOActionIOWarfareType,
            pub io_simulation_source: IOActionIOSimulationSource,
            pub io_action_type: IOActionIOActionType,
            pub io_action_phase: IOActionIOActionPhase,
            padding: u32,
            pub io_attacker_entity_id: EntityId,
            pub io_primary_target_entity_id: EntityId,
            padding2: u16,
            pub io_records: StandardVariableSpecification,
        }
    }
}

#[cfg(test)]
mod tests {
    mod information_operations_actions_pdu {
        use crate::{
            common::{constants::BITS_PER_BYTE, pdu::Pdu},
            information_operations::InformationOperationsActionPdu,
        };
        use bytes::BytesMut;
        #[test]
        fn cast_to_any() {
            let pdu = InformationOperationsActionPdu::new();
            let any_pdu = pdu.as_any();

            assert!(any_pdu.is::<InformationOperationsActionPdu>());
        }

        #[test]
        fn serialize_then_deserialize() {
            let mut pdu = InformationOperationsActionPdu::new();
            let mut serialize_buf = BytesMut::new();
            let _ = pdu.serialize(&mut serialize_buf);

            let mut deserialize_buf = serialize_buf.freeze();
            let new_pdu =
                InformationOperationsActionPdu::deserialize(&mut deserialize_buf).expect("Some");
            assert_eq!(new_pdu.header, pdu.header);
        }

        #[test]
        fn check_default_pdu_length() {
            const DEFAULT_LENGTH: u16 = 448 / BITS_PER_BYTE;
            let pdu = InformationOperationsActionPdu::new();
            assert_eq!(pdu.header().length, DEFAULT_LENGTH);
        }
    }

    mod information_operations_report_pdu {
        use crate::{
            common::{constants::BITS_PER_BYTE, pdu::Pdu},
            information_operations::InformationOperationsReportPdu,
        };
        use bytes::BytesMut;

        #[test]
        fn cast_to_any() {
            let pdu = InformationOperationsReportPdu::new();
            let any_pdu = pdu.as_any();

            assert!(any_pdu.is::<InformationOperationsReportPdu>());
        }

        #[test]
        fn serialize_then_deserialize() {
            let mut pdu = InformationOperationsReportPdu::new();
            let mut serialize_buf = BytesMut::new();
            let _ = pdu.serialize(&mut serialize_buf);

            let mut deserialize_buf = serialize_buf.freeze();
            let new_pdu =
                InformationOperationsReportPdu::deserialize(&mut deserialize_buf).expect("Some");
            assert_eq!(new_pdu.header, pdu.header);
        }

        #[test]
        fn check_default_pdu_length() {
            const DEFAULT_LENGTH: u16 = 320 / BITS_PER_BYTE;
            let pdu = InformationOperationsReportPdu::new();
            assert_eq!(pdu.header().length, DEFAULT_LENGTH);
        }
    }
}