opcua_types/service_types/
uadp_data_set_reader_message_data_type.rs1#![allow(unused_attributes)]
9use std::io::{Read, Write};
10#[allow(unused_imports)]
11use crate::{
12 encoding::*,
13 basic_types::*,
14 guid::Guid,
15 service_types::enums::UadpNetworkMessageContentMask,
16 service_types::enums::UadpDataSetMessageContentMask,
17};
18
19#[derive(Debug, Clone, PartialEq)]
20pub struct UadpDataSetReaderMessageDataType {
21 pub group_version: u32,
22 pub network_message_number: u16,
23 pub data_set_offset: u16,
24 pub data_set_class_id: Guid,
25 pub network_message_content_mask: UadpNetworkMessageContentMask,
26 pub data_set_message_content_mask: UadpDataSetMessageContentMask,
27 pub publishing_interval: f64,
28 pub receive_offset: f64,
29 pub processing_offset: f64,
30}
31
32impl BinaryEncoder<UadpDataSetReaderMessageDataType> for UadpDataSetReaderMessageDataType {
33 fn byte_len(&self) -> usize {
34 let mut size = 0;
35 size += self.group_version.byte_len();
36 size += self.network_message_number.byte_len();
37 size += self.data_set_offset.byte_len();
38 size += self.data_set_class_id.byte_len();
39 size += self.network_message_content_mask.byte_len();
40 size += self.data_set_message_content_mask.byte_len();
41 size += self.publishing_interval.byte_len();
42 size += self.receive_offset.byte_len();
43 size += self.processing_offset.byte_len();
44 size
45 }
46
47 #[allow(unused_variables)]
48 fn encode<S: Write>(&self, stream: &mut S) -> EncodingResult<usize> {
49 let mut size = 0;
50 size += self.group_version.encode(stream)?;
51 size += self.network_message_number.encode(stream)?;
52 size += self.data_set_offset.encode(stream)?;
53 size += self.data_set_class_id.encode(stream)?;
54 size += self.network_message_content_mask.encode(stream)?;
55 size += self.data_set_message_content_mask.encode(stream)?;
56 size += self.publishing_interval.encode(stream)?;
57 size += self.receive_offset.encode(stream)?;
58 size += self.processing_offset.encode(stream)?;
59 Ok(size)
60 }
61
62 #[allow(unused_variables)]
63 fn decode<S: Read>(stream: &mut S, decoding_options: &DecodingOptions) -> EncodingResult<Self> {
64 let group_version = u32::decode(stream, decoding_options)?;
65 let network_message_number = u16::decode(stream, decoding_options)?;
66 let data_set_offset = u16::decode(stream, decoding_options)?;
67 let data_set_class_id = Guid::decode(stream, decoding_options)?;
68 let network_message_content_mask = UadpNetworkMessageContentMask::decode(stream, decoding_options)?;
69 let data_set_message_content_mask = UadpDataSetMessageContentMask::decode(stream, decoding_options)?;
70 let publishing_interval = f64::decode(stream, decoding_options)?;
71 let receive_offset = f64::decode(stream, decoding_options)?;
72 let processing_offset = f64::decode(stream, decoding_options)?;
73 Ok(UadpDataSetReaderMessageDataType {
74 group_version,
75 network_message_number,
76 data_set_offset,
77 data_set_class_id,
78 network_message_content_mask,
79 data_set_message_content_mask,
80 publishing_interval,
81 receive_offset,
82 processing_offset,
83 })
84 }
85}