opcua/types/service_types/
writer_group_data_type.rs1#![allow(unused_attributes)]
9#[allow(unused_imports)]
10use crate::types::{
11 basic_types::*, encoding::*, extension_object::ExtensionObject,
12 service_types::enums::MessageSecurityMode, service_types::DataSetWriterDataType,
13 service_types::EndpointDescription, service_types::KeyValuePair, string::UAString,
14};
15use std::io::{Read, Write};
16
17#[derive(Debug, Clone, PartialEq)]
18pub struct WriterGroupDataType {
19 pub name: UAString,
20 pub enabled: bool,
21 pub security_mode: MessageSecurityMode,
22 pub security_group_id: UAString,
23 pub security_key_services: Option<Vec<EndpointDescription>>,
24 pub max_network_message_size: u32,
25 pub group_properties: Option<Vec<KeyValuePair>>,
26 pub writer_group_id: u16,
27 pub publishing_interval: f64,
28 pub keep_alive_time: f64,
29 pub priority: u8,
30 pub locale_ids: Option<Vec<UAString>>,
31 pub header_layout_uri: UAString,
32 pub transport_settings: ExtensionObject,
33 pub message_settings: ExtensionObject,
34 pub data_set_writers: Option<Vec<DataSetWriterDataType>>,
35}
36
37impl BinaryEncoder<WriterGroupDataType> for WriterGroupDataType {
38 fn byte_len(&self) -> usize {
39 let mut size = 0;
40 size += self.name.byte_len();
41 size += self.enabled.byte_len();
42 size += self.security_mode.byte_len();
43 size += self.security_group_id.byte_len();
44 size += byte_len_array(&self.security_key_services);
45 size += self.max_network_message_size.byte_len();
46 size += byte_len_array(&self.group_properties);
47 size += self.writer_group_id.byte_len();
48 size += self.publishing_interval.byte_len();
49 size += self.keep_alive_time.byte_len();
50 size += self.priority.byte_len();
51 size += byte_len_array(&self.locale_ids);
52 size += self.header_layout_uri.byte_len();
53 size += self.transport_settings.byte_len();
54 size += self.message_settings.byte_len();
55 size += byte_len_array(&self.data_set_writers);
56 size
57 }
58
59 #[allow(unused_variables)]
60 fn encode<S: Write>(&self, stream: &mut S) -> EncodingResult<usize> {
61 let mut size = 0;
62 size += self.name.encode(stream)?;
63 size += self.enabled.encode(stream)?;
64 size += self.security_mode.encode(stream)?;
65 size += self.security_group_id.encode(stream)?;
66 size += write_array(stream, &self.security_key_services)?;
67 size += self.max_network_message_size.encode(stream)?;
68 size += write_array(stream, &self.group_properties)?;
69 size += self.writer_group_id.encode(stream)?;
70 size += self.publishing_interval.encode(stream)?;
71 size += self.keep_alive_time.encode(stream)?;
72 size += self.priority.encode(stream)?;
73 size += write_array(stream, &self.locale_ids)?;
74 size += self.header_layout_uri.encode(stream)?;
75 size += self.transport_settings.encode(stream)?;
76 size += self.message_settings.encode(stream)?;
77 size += write_array(stream, &self.data_set_writers)?;
78 Ok(size)
79 }
80
81 #[allow(unused_variables)]
82 fn decode<S: Read>(stream: &mut S, decoding_options: &DecodingOptions) -> EncodingResult<Self> {
83 let name = UAString::decode(stream, decoding_options)?;
84 let enabled = bool::decode(stream, decoding_options)?;
85 let security_mode = MessageSecurityMode::decode(stream, decoding_options)?;
86 let security_group_id = UAString::decode(stream, decoding_options)?;
87 let security_key_services: Option<Vec<EndpointDescription>> =
88 read_array(stream, decoding_options)?;
89 let max_network_message_size = u32::decode(stream, decoding_options)?;
90 let group_properties: Option<Vec<KeyValuePair>> = read_array(stream, decoding_options)?;
91 let writer_group_id = u16::decode(stream, decoding_options)?;
92 let publishing_interval = f64::decode(stream, decoding_options)?;
93 let keep_alive_time = f64::decode(stream, decoding_options)?;
94 let priority = u8::decode(stream, decoding_options)?;
95 let locale_ids: Option<Vec<UAString>> = read_array(stream, decoding_options)?;
96 let header_layout_uri = UAString::decode(stream, decoding_options)?;
97 let transport_settings = ExtensionObject::decode(stream, decoding_options)?;
98 let message_settings = ExtensionObject::decode(stream, decoding_options)?;
99 let data_set_writers: Option<Vec<DataSetWriterDataType>> =
100 read_array(stream, decoding_options)?;
101 Ok(WriterGroupDataType {
102 name,
103 enabled,
104 security_mode,
105 security_group_id,
106 security_key_services,
107 max_network_message_size,
108 group_properties,
109 writer_group_id,
110 publishing_interval,
111 keep_alive_time,
112 priority,
113 locale_ids,
114 header_layout_uri,
115 transport_settings,
116 message_settings,
117 data_set_writers,
118 })
119 }
120}