opcua_types/service_types/
create_subscription_request.rs1#![allow(unused_attributes)]
9use std::io::{Read, Write};
10#[allow(unused_imports)]
11use crate::{
12 encoding::*,
13 basic_types::*,
14 service_types::impls::MessageInfo,
15 node_ids::ObjectId,
16 request_header::RequestHeader,
17};
18
19#[derive(Debug, Clone, PartialEq)]
20pub struct CreateSubscriptionRequest {
21 pub request_header: RequestHeader,
22 pub requested_publishing_interval: f64,
23 pub requested_lifetime_count: u32,
24 pub requested_max_keep_alive_count: u32,
25 pub max_notifications_per_publish: u32,
26 pub publishing_enabled: bool,
27 pub priority: u8,
28}
29
30impl MessageInfo for CreateSubscriptionRequest {
31 fn object_id(&self) -> ObjectId {
32 ObjectId::CreateSubscriptionRequest_Encoding_DefaultBinary
33 }
34}
35
36impl BinaryEncoder<CreateSubscriptionRequest> for CreateSubscriptionRequest {
37 fn byte_len(&self) -> usize {
38 let mut size = 0;
39 size += self.request_header.byte_len();
40 size += self.requested_publishing_interval.byte_len();
41 size += self.requested_lifetime_count.byte_len();
42 size += self.requested_max_keep_alive_count.byte_len();
43 size += self.max_notifications_per_publish.byte_len();
44 size += self.publishing_enabled.byte_len();
45 size += self.priority.byte_len();
46 size
47 }
48
49 #[allow(unused_variables)]
50 fn encode<S: Write>(&self, stream: &mut S) -> EncodingResult<usize> {
51 let mut size = 0;
52 size += self.request_header.encode(stream)?;
53 size += self.requested_publishing_interval.encode(stream)?;
54 size += self.requested_lifetime_count.encode(stream)?;
55 size += self.requested_max_keep_alive_count.encode(stream)?;
56 size += self.max_notifications_per_publish.encode(stream)?;
57 size += self.publishing_enabled.encode(stream)?;
58 size += self.priority.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 request_header = RequestHeader::decode(stream, decoding_options)?;
65 let requested_publishing_interval = f64::decode(stream, decoding_options)?;
66 let requested_lifetime_count = u32::decode(stream, decoding_options)?;
67 let requested_max_keep_alive_count = u32::decode(stream, decoding_options)?;
68 let max_notifications_per_publish = u32::decode(stream, decoding_options)?;
69 let publishing_enabled = bool::decode(stream, decoding_options)?;
70 let priority = u8::decode(stream, decoding_options)?;
71 Ok(CreateSubscriptionRequest {
72 request_header,
73 requested_publishing_interval,
74 requested_lifetime_count,
75 requested_max_keep_alive_count,
76 max_notifications_per_publish,
77 publishing_enabled,
78 priority,
79 })
80 }
81}