dis-rs 0.13.0

An implementation of the Distributed Interactive Simulation protocol (IEEE-1278.1) in Rust. This main crate contains PDU implementations and facilities to read/write PDUs from Rust data structures to the wire format and vice versa. It supports versions 6 and 7 of the protocol.
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

use crate::common::BodyInfo;
use crate::underwater_acoustic::model::{
    AcousticEmitterSystem, PropulsionPlantConfiguration, Shaft, UABeam, UAEmitterSystem,
    UAFundamentalParameterData, UnderwaterAcoustic, APA,
};
use crate::{Serialize, SerializePdu, SupportedVersion};
use bytes::{BufMut, BytesMut};

impl SerializePdu for UnderwaterAcoustic {
    #[allow(clippy::cast_possible_truncation)]
    fn serialize_pdu(&self, _version: SupportedVersion, buf: &mut BytesMut) -> u16 {
        let _emitter_bytes = self.emitting_entity_id.serialize(buf);
        let _event_id_bytes = self.event_id.serialize(buf);
        buf.put_u8(self.state_change_update_indicator.into());
        buf.put_u8(0u8);
        buf.put_u16(self.passive_parameter_index.into());
        let _ppc_bytes = self.propulsion_plant_configuration.serialize(buf);

        buf.put_u8(self.shafts.len() as u8);
        buf.put_u8(self.apas.len() as u8);
        buf.put_u8(self.emitter_systems.len() as u8);

        let _shafts = self
            .shafts
            .iter()
            .map(|shaft| shaft.serialize(buf))
            .sum::<u16>();

        let _apas = self.apas.iter().map(|apa| apa.serialize(buf)).sum::<u16>();

        let _systems = self
            .emitter_systems
            .iter()
            .map(|system| system.serialize(buf))
            .sum::<u16>();

        self.body_length()
    }
}

impl Serialize for PropulsionPlantConfiguration {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        let configuration: u8 = self.configuration.into();
        let hull_mounted_masker_on = u8::from(self.hull_mounted_masker);
        let final_field = (configuration << 1) | hull_mounted_masker_on;
        buf.put_u8(final_field);

        self.record_length()
    }
}

impl Serialize for Shaft {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        buf.put_i16(self.current_rpm);
        buf.put_i16(self.ordered_rpm);
        buf.put_i32(self.rpm_rate_of_change);

        self.record_length()
    }
}

impl Serialize for APA {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        let parameter: u16 = self.parameter.into();
        let parameter_status: u8 = self.status.into();
        let parameter_index = (parameter << 2) & u16::from(parameter_status);
        buf.put_u16(parameter_index);
        buf.put_i16(self.value);

        self.record_length()
    }
}

impl Serialize for UAEmitterSystem {
    #[allow(clippy::cast_possible_truncation)]
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        buf.put_u8(self.record_length() as u8);
        buf.put_u8(self.beams.len() as u8);
        buf.put_u16(0u16);
        self.acoustic_emitter_system.serialize(buf);
        self.location.serialize(buf);
        self.beams
            .iter()
            .map(|beam| beam.serialize(buf))
            .sum::<u16>();

        self.record_length()
    }
}

impl Serialize for AcousticEmitterSystem {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        buf.put_u16(self.acoustic_system_name.into());
        buf.put_u8(self.function.into());
        buf.put_u8(self.acoustic_id_number);

        self.record_length()
    }
}

impl Serialize for UABeam {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        buf.put_u8(self.beam_data_length);
        buf.put_u8(self.beam_id_number);
        buf.put_u16(0u16);
        self.fundamental_parameters.serialize(buf);

        self.record_length()
    }
}

impl Serialize for UAFundamentalParameterData {
    fn serialize(&self, buf: &mut BytesMut) -> u16 {
        buf.put_u16(self.active_emission_parameter_index.into());
        buf.put_u16(self.scan_pattern.into());
        buf.put_f32(self.beam_center_azimuth);
        buf.put_f32(self.azimuthal_beamwidth);
        buf.put_f32(self.beam_center_depression_elevation);
        buf.put_f32(self.depression_elevation_beamwidth);

        self.record_length()
    }
}