From 7218cb2a06913454bb22ec43d0589e10ae17a0c3 Mon Sep 17 00:00:00 2001 From: Ondrej Babec Date: Sun, 20 Feb 2022 14:18:31 +0100 Subject: [PATCH] Encoding --- src/packet/auth_packet.rs | 6 ++---- src/packet/connack_packet.rs | 16 +++++++++++++++- src/packet/disconnect_packet.rs | 15 ++++++++++++++- src/packet/mod.rs | 9 +++++---- src/packet/pingreq_packet.rs | 7 ++++++- src/packet/pingresp_packet.rs | 7 ++++++- src/packet/puback_packet.rs | 18 +++++++++++++++++- src/packet/pubcomp_packet.rs | 18 +++++++++++++++++- src/packet/publish_packet.rs | 20 +++++++++++++++++++- src/packet/pubrec_packet.rs | 18 +++++++++++++++++- src/packet/pubrel_packet.rs | 18 +++++++++++++++++- src/packet/suback_packet.rs | 6 +++++- src/packet/subscription_packet.rs | 21 +++++++++++++++++++-- src/packet/unsuback_packet.rs | 4 +++- src/packet/unsubscription_packet.rs | 21 +++++++++++++++++++-- src/utils/buffer_reader.rs | 4 +--- src/utils/buffer_writer.rs | 20 +++++++++++++++++++- 17 files changed, 201 insertions(+), 27 deletions(-) diff --git a/src/packet/auth_packet.rs b/src/packet/auth_packet.rs index b3d417f..3176b31 100644 --- a/src/packet/auth_packet.rs +++ b/src/packet/auth_packet.rs @@ -58,13 +58,11 @@ impl<'a, const MAX_PROPERTIES: usize> Packet<'a> for AuthPacket<'a, MAX_PROPERTI let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); rm_ln = rm_ln + property_len_len as u32; rm_ln = rm_ln + 1; - let rm_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(rm_ln).unwrap(); - let rm_len_len = VariableByteIntegerEncoder::len(rm_len_enc); buff_writer.write_u8(self.fixed_header); - buff_writer.insert_ref(rm_len_len, &rm_len_enc); + buff_writer.write_variable_byte_int(rm_ln); buff_writer.write_u8(self.auth_reason); - buff_writer.insert_ref(property_len_len, &property_len_enc); + buff_writer.write_variable_byte_int(self.property_len); buff_writer.encode_properties::(&self.properties); } diff --git a/src/packet/connack_packet.rs b/src/packet/connack_packet.rs index f82ddbf..8ab6191 100644 --- a/src/packet/connack_packet.rs +++ b/src/packet/connack_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -32,7 +34,19 @@ impl<'a> ConnackPacket<'a> { } impl<'a> Packet<'a> for ConnackPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + buff_writer.write_u8(self.fixed_header); + let mut property_len_enc = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + + let rm_len: u32 = 2 + self.property_len + property_len_len as u32; + buff_writer.write_variable_byte_int(rm_len); + buff_writer.write_u8(self.ack_flags); + buff_writer.write_u8(self.connect_reason_code); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_connack_packet(buff_reader); } diff --git a/src/packet/disconnect_packet.rs b/src/packet/disconnect_packet.rs index df07b52..f6a4f5b 100644 --- a/src/packet/disconnect_packet.rs +++ b/src/packet/disconnect_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -31,7 +33,18 @@ impl<'a, const MAX_PROPERTIES: usize> DisconnectPacket<'a, MAX_PROPERTIES> { } impl<'a, const MAX_PROPERTIES: usize> Packet<'a> for DisconnectPacket<'a, MAX_PROPERTIES> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + buff_writer.write_u8(self.fixed_header); + let mut property_len_enc = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + + let rm_len: u32 = 1 + self.property_len + property_len_len as u32; + buff_writer.write_variable_byte_int(rm_len); + buff_writer.write_u8(self.disconnect_reason); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_auth_packet(buff_reader); diff --git a/src/packet/mod.rs b/src/packet/mod.rs index 7208f60..0a7ede3 100644 --- a/src/packet/mod.rs +++ b/src/packet/mod.rs @@ -1,10 +1,11 @@ -/*pub mod connack_packet; -pub mod control_packet;*/ + +//pub mod control_packet; pub mod mqtt_packet; pub mod packet_type; pub mod property; pub mod auth_packet; -/*pub mod puback_packet; +pub mod connack_packet; +pub mod puback_packet; pub mod pubcomp_packet; pub mod publish_packet; pub mod pubrec_packet; @@ -17,4 +18,4 @@ pub mod disconnect_packet; pub mod pingreq_packet; pub mod pingresp_packet; pub mod suback_packet; -pub mod unsuback_packet;*/ +pub mod unsuback_packet; diff --git a/src/packet/pingreq_packet.rs b/src/packet/pingreq_packet.rs index b2f81dc..78a34ee 100644 --- a/src/packet/pingreq_packet.rs +++ b/src/packet/pingreq_packet.rs @@ -1,5 +1,6 @@ use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -16,7 +17,11 @@ pub struct PingreqPacket { impl PingreqPacket {} impl<'a> Packet<'a> for PingreqPacket { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(0 as u32); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { log::error!("PingreqPacket packet does not support decode funtion on client!"); diff --git a/src/packet/pingresp_packet.rs b/src/packet/pingresp_packet.rs index ec64e37..1f57323 100644 --- a/src/packet/pingresp_packet.rs +++ b/src/packet/pingresp_packet.rs @@ -1,5 +1,6 @@ use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -21,7 +22,11 @@ impl<'a> PingrespPacket { } impl<'a> Packet<'a> for PingrespPacket { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(0 as u32); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_pingresp_packet(buff_reader); diff --git a/src/packet/puback_packet.rs b/src/packet/puback_packet.rs index c9ab5ae..9683b8a 100644 --- a/src/packet/puback_packet.rs +++ b/src/packet/puback_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -36,7 +38,21 @@ impl<'a> PubackPacket<'a> { } impl<'a> Packet<'a> for PubackPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 3; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_u8(self.reason_code); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_puback_packet(buff_reader); diff --git a/src/packet/pubcomp_packet.rs b/src/packet/pubcomp_packet.rs index c908770..864befe 100644 --- a/src/packet/pubcomp_packet.rs +++ b/src/packet/pubcomp_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -37,7 +39,21 @@ impl<'a> PubcompPacket<'a> { } impl<'a> Packet<'a> for PubcompPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 3; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_u8(self.reason_code); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_puback_packet(buff_reader); diff --git a/src/packet/publish_packet.rs b/src/packet/publish_packet.rs index c7ea25a..b71ed03 100644 --- a/src/packet/publish_packet.rs +++ b/src/packet/publish_packet.rs @@ -1,8 +1,10 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; use crate::utils::buffer_reader::EncodedString; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -40,7 +42,23 @@ impl<'a> PublishPacket<'a> { } impl<'a> Packet<'a> for PublishPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + let mut msg_len = self.message.len() as u32; + rm_ln = rm_ln + property_len_len as u32 + 2 + msg_len + self.topic_name.len as u32 + 2; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_string_ref(& self.topic_name); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + buff_writer.insert_ref(msg_len as usize, self.message) + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_publish_packet(buff_reader); diff --git a/src/packet/pubrec_packet.rs b/src/packet/pubrec_packet.rs index bfa7885..43cb52c 100644 --- a/src/packet/pubrec_packet.rs +++ b/src/packet/pubrec_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -37,7 +39,21 @@ impl<'a> PubrecPacket<'a> { } impl<'a> Packet<'a> for PubrecPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 3; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_u8(self.reason_code); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_pubrec_packet(buff_reader); diff --git a/src/packet/pubrel_packet.rs b/src/packet/pubrel_packet.rs index a79c0b0..10569c4 100644 --- a/src/packet/pubrel_packet.rs +++ b/src/packet/pubrel_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -37,7 +39,21 @@ impl<'a> PubrelPacket<'a> { } impl<'a> Packet<'a> for PubrelPacket<'a> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 3; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_u8(self.reason_code); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_puback_packet(buff_reader); diff --git a/src/packet/suback_packet.rs b/src/packet/suback_packet.rs index c6a9a43..6b12aa4 100644 --- a/src/packet/suback_packet.rs +++ b/src/packet/suback_packet.rs @@ -1,7 +1,9 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -49,7 +51,9 @@ impl<'a, const MAX_REASONS: usize> SubackPacket<'a, MAX_REASONS> { } impl<'a, const MAX_REASONS: usize> Packet<'a> for SubackPacket<'a, MAX_REASONS> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + log::error!("SUBACK packet does not support encoding!"); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_suback_packet(buff_reader); diff --git a/src/packet/subscription_packet.rs b/src/packet/subscription_packet.rs index 44855bf..eb15677 100644 --- a/src/packet/subscription_packet.rs +++ b/src/packet/subscription_packet.rs @@ -1,8 +1,10 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; use crate::utils::buffer_reader::TopicFilter; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -23,7 +25,7 @@ pub struct SubscriptionPacket<'a, const MAX_FILTERS: usize> { pub properties: Vec, MAX_PROPERTIES>, // topic filter len - pub topic_filter_let: u16, + pub topic_filter_len: u16, // payload pub topic_filters: Vec, MAX_FILTERS>, @@ -36,7 +38,22 @@ impl<'a, const MAX_FILTERS: usize> SubscriptionPacket<'a, MAX_FILTERS> { } impl<'a, const MAX_FILTERS: usize> Packet<'a> for SubscriptionPacket<'a, MAX_FILTERS> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 4 + self.topic_filter_len as u32; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + buff_writer.write_u16(self.topic_filter_len); + buff_writer.encode_topic_filters_ref(false, self.topic_filter_len as usize, & self.topic_filters); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { log::error!("Subscribe packet does not support decode funtion on client!"); diff --git a/src/packet/unsuback_packet.rs b/src/packet/unsuback_packet.rs index 3719b11..291d808 100644 --- a/src/packet/unsuback_packet.rs +++ b/src/packet/unsuback_packet.rs @@ -49,7 +49,9 @@ impl<'a, const MAX_REASONS: usize> UnsubackPacket<'a, MAX_REASONS> { } impl<'a, const MAX_REASONS: usize> Packet<'a> for UnsubackPacket<'a, MAX_REASONS> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + log::error!("UNSUBACK packet does not support encoding!"); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { self.decode_suback_packet(buff_reader); diff --git a/src/packet/unsubscription_packet.rs b/src/packet/unsubscription_packet.rs index 92b6962..9fbd81f 100644 --- a/src/packet/unsubscription_packet.rs +++ b/src/packet/unsubscription_packet.rs @@ -1,8 +1,10 @@ use heapless::Vec; +use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder; use crate::packet::mqtt_packet::Packet; use crate::utils::buffer_reader::BuffReader; use crate::utils::buffer_reader::TopicFilter; +use crate::utils::buffer_writer::BuffWriter; use super::packet_type::PacketType; use super::property::Property; @@ -23,7 +25,7 @@ pub struct UnsubscriptionPacket<'a, const MAX_FILTERS: usize> { pub properties: Vec, MAX_PROPERTIES>, // topic filter len - pub topic_filter_let: u16, + pub topic_filter_len: u16, // payload pub topic_filters: Vec, MAX_FILTERS>, @@ -36,7 +38,22 @@ impl<'a, const MAX_FILTERS: usize> UnsubscriptionPacket<'a, MAX_FILTERS> { } impl<'a, const MAX_FILTERS: usize> Packet<'a> for UnsubscriptionPacket<'a, MAX_FILTERS> { - fn encode(&mut self, buffer: &mut [u8]) {} + fn encode(&mut self, buffer: &mut [u8]) { + let mut buff_writer = BuffWriter::new(buffer); + + let mut rm_ln = self.property_len; + let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap(); + let property_len_len = VariableByteIntegerEncoder::len(property_len_enc); + rm_ln = rm_ln + property_len_len as u32 + 4 + self.topic_filter_len as u32; + + buff_writer.write_u8(self.fixed_header); + buff_writer.write_variable_byte_int(rm_ln); + buff_writer.write_u16(self.packet_identifier); + buff_writer.write_variable_byte_int(self.property_len); + buff_writer.encode_properties::(&self.properties); + buff_writer.write_u16(self.topic_filter_len); + buff_writer.encode_topic_filters_ref(false, self.topic_filter_len as usize, & self.topic_filters); + } fn decode(&mut self, buff_reader: &mut BuffReader<'a>) { log::error!("Unsubscribe packet does not support decode funtion on client!"); diff --git a/src/utils/buffer_reader.rs b/src/utils/buffer_reader.rs index 19d49f0..0b8c272 100644 --- a/src/utils/buffer_reader.rs +++ b/src/utils/buffer_reader.rs @@ -50,7 +50,6 @@ impl StringPair<'_> { #[derive(Debug)] pub struct TopicFilter<'a> { - pub len: u16, pub filter: EncodedString<'a>, pub sub_options: u8, } @@ -58,14 +57,13 @@ pub struct TopicFilter<'a> { impl TopicFilter<'_> { pub fn new() -> Self { Self { - len: 0, filter: EncodedString::new(), sub_options: 0, } } pub fn len(&self) -> u16 { - return self.len + 2; + return self.filter.len + 3; } } diff --git a/src/utils/buffer_writer.rs b/src/utils/buffer_writer.rs index c68bcac..ed6abb1 100644 --- a/src/utils/buffer_writer.rs +++ b/src/utils/buffer_writer.rs @@ -1,4 +1,4 @@ -use crate::utils::buffer_reader::{BinaryData, EncodedString, StringPair}; +use crate::utils::buffer_reader::{BinaryData, EncodedString, StringPair, TopicFilter}; use core::str; use heapless::Vec; use crate::encoding::variable_byte_integer::{VariableByteInteger, VariableByteIntegerEncoder}; @@ -116,4 +116,22 @@ impl<'a> BuffWriter<'a> { } } } + + fn encode_topic_filter_ref(& mut self, sub: bool, topic_filter: & TopicFilter<'a>) { + self.write_string_ref(&topic_filter.filter); + if sub { + self.write_u8(topic_filter.sub_options) + } + } + + pub fn encode_topic_filters_ref(& mut self, sub: bool, len: usize, filters: & Vec, MAX>) { + let mut i = 0; + loop { + let topic_filter: & TopicFilter<'a> = filters.get(i).unwrap(); + self.encode_topic_filter_ref(sub, topic_filter); + if i == len { + break; + } + } + } } \ No newline at end of file