Minimize copy for MqttString and MqttBinary.

Author: redboltz

src/mqtt/packet/mod.rs

@@ -20,9 +20,9 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 mod mqtt_string;
-pub use self::mqtt_string::MqttString;
+pub use self::mqtt_string::{IntoMqttString, MqttString};
 mod mqtt_binary;
-pub use self::mqtt_binary::MqttBinary;
+pub use self::mqtt_binary::{IntoMqttBinary, MqttBinary};
 
 mod enum_packet;
 mod enum_store_packet;

src/mqtt/packet/mqtt_binary.rs

@@ -300,6 +300,47 @@ impl core::fmt::Debug for MqttBinary {
     }
 }
 
+/// Trait for types that can be converted into `MqttBinary`
+pub trait IntoMqttBinary {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError>;
+}
+
+impl IntoMqttBinary for &[u8] {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        MqttBinary::new(self)
+    }
+}
+
+impl<const N: usize> IntoMqttBinary for &[u8; N] {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        MqttBinary::new(&self[..])
+    }
+}
+
+impl IntoMqttBinary for &str {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        MqttBinary::new(self.as_bytes())
+    }
+}
+
+impl IntoMqttBinary for Vec<u8> {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        MqttBinary::new(&self)
+    }
+}
+
+impl IntoMqttBinary for &Vec<u8> {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        MqttBinary::new(self)
+    }
+}
+
+impl IntoMqttBinary for MqttBinary {
+    fn into_mqtt_binary(self) -> Result<MqttBinary, MqttError> {
+        Ok(self)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/mqtt/packet/mqtt_string.rs

@@ -681,6 +681,59 @@ impl TryFrom<String> for MqttString {
     }
 }
 
+/// Trait for types that can be converted into `MqttString`
+///
+/// This trait provides a flexible way to create `MqttString` instances from various string types.
+/// It allows you to pass pre-constructed `MqttString` objects directly without additional
+/// heap allocations, which is particularly useful in multi-threaded scenarios.
+///
+/// # Examples
+///
+/// ```ignore
+/// use mqtt_protocol_core::mqtt::packet::{IntoMqttString, MqttString};
+///
+/// // From &str
+/// let s1 = "test".into_mqtt_string().unwrap();
+/// assert_eq!(s1.as_str(), "test");
+///
+/// // From String
+/// let s2 = String::from("test").into_mqtt_string().unwrap();
+/// assert_eq!(s2.as_str(), "test");
+///
+/// // From MqttString (no additional allocation)
+/// let mqtt_str = MqttString::new("test").unwrap();
+/// let s3 = mqtt_str.into_mqtt_string().unwrap();
+/// assert_eq!(s3.as_str(), "test");
+/// ```
+pub trait IntoMqttString {
+    /// Convert self into an MqttString
+    fn into_mqtt_string(self) -> Result<MqttString, MqttError>;
+}
+
+impl IntoMqttString for &str {
+    fn into_mqtt_string(self) -> Result<MqttString, MqttError> {
+        MqttString::new(self)
+    }
+}
+
+impl IntoMqttString for String {
+    fn into_mqtt_string(self) -> Result<MqttString, MqttError> {
+        MqttString::new(self)
+    }
+}
+
+impl IntoMqttString for &String {
+    fn into_mqtt_string(self) -> Result<MqttString, MqttError> {
+        MqttString::new(self)
+    }
+}
+
+impl IntoMqttString for MqttString {
+    fn into_mqtt_string(self) -> Result<MqttString, MqttError> {
+        Ok(self)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/mqtt/packet/property.rs

@@ -21,8 +21,8 @@
 // SOFTWARE.
 
 use crate::mqtt::packet::escape_binary_json_string;
-use crate::mqtt::packet::mqtt_binary::MqttBinary;
-use crate::mqtt::packet::mqtt_string::MqttString;
+use crate::mqtt::packet::mqtt_binary::{IntoMqttBinary, MqttBinary};
+use crate::mqtt::packet::mqtt_string::{IntoMqttString, MqttString};
 use crate::mqtt::packet::DecodeResult;
 use crate::mqtt::packet::VariableByteInteger;
 use crate::mqtt::result_code::MqttError;
@@ -372,9 +372,9 @@ macro_rules! mqtt_property_binary {
             /// ```
             pub fn new<T>(v: T) -> Result<Self, MqttError>
             where
-                T: AsRef<[u8]>,
+                T: IntoMqttBinary,
             {
-                let binary = MqttBinary::new(v)?;
+                let binary = v.into_mqtt_binary()?;
 
                 Ok(Self {
                     id_bytes: [$id as u8],
@@ -553,9 +553,9 @@ macro_rules! mqtt_property_string {
             /// ```
             pub fn new<T>(s: T) -> Result<Self, MqttError>
             where
-                T: AsRef<str>,
+                T: IntoMqttString,
             {
-                let value = MqttString::new(s)?;
+                let value = s.into_mqtt_string()?;
 
                 Ok(Self {
                     id_bytes: [$id as u8],
@@ -716,11 +716,11 @@ macro_rules! mqtt_property_string_pair {
             /// ```
             pub fn new<K, V>(key: K, val: V) -> Result<Self, MqttError>
             where
-                K: AsRef<str>,
-                V: AsRef<str>,
+                K: IntoMqttString,
+                V: IntoMqttString,
             {
-                let key_mqtt = MqttString::new(key)?;
-                let val_mqtt = MqttString::new(val)?;
+                let key_mqtt = key.into_mqtt_string()?;
+                let val_mqtt = val.into_mqtt_string()?;
 
                 Ok(Self {
                     id_bytes: [$id as u8],

src/mqtt/packet/sub_entry.rs

@@ -20,9 +20,9 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-use crate::mqtt::packet::MqttString;
 use crate::mqtt::packet::Qos;
 use crate::mqtt::packet::RetainHandling;
+use crate::mqtt::packet::{IntoMqttString, MqttString};
 use crate::mqtt::result_code::MqttError;
 use alloc::string::ToString;
 use alloc::{string::String, vec::Vec};
@@ -564,8 +564,11 @@ impl SubEntry {
     /// let opts = mqtt::packet::SubOpts::new().set_qos(mqtt::packet::Qos::AtLeastOnce);
     /// let entry = mqtt::packet::SubEntry::new("home/+/status", opts).unwrap();
     /// ```
-    pub fn new(topic_filter: impl AsRef<str>, sub_opts: SubOpts) -> Result<Self, MqttError> {
-        let topic_filter = MqttString::new(topic_filter)?;
+    pub fn new<T>(topic_filter: T, sub_opts: SubOpts) -> Result<Self, MqttError>
+    where
+        T: IntoMqttString,
+    {
+        let topic_filter = topic_filter.into_mqtt_string()?;
         Ok(Self {
             topic_filter,
             sub_opts,

src/mqtt/packet/v3_1_1/connect.rs

@@ -32,8 +32,8 @@ use serde::Serialize;
 use getset::{CopyGetters, Getters};
 
 use crate::mqtt::packet::json_bin_encode::escape_binary_json_string;
-use crate::mqtt::packet::mqtt_binary::MqttBinary;
-use crate::mqtt::packet::mqtt_string::MqttString;
+use crate::mqtt::packet::mqtt_binary::{IntoMqttBinary, MqttBinary};
+use crate::mqtt::packet::mqtt_string::{IntoMqttString, MqttString};
 use crate::mqtt::packet::packet_type::{FixedHeader, PacketType};
 use crate::mqtt::packet::qos::Qos;
 use crate::mqtt::packet::variable_byte_integer::VariableByteInteger;
@@ -679,8 +679,11 @@ impl ConnectBuilder {
     ///     .client_id("device-001")
     ///     .unwrap();
     /// ```
-    pub fn client_id(mut self, id: impl AsRef<str>) -> Result<Self, MqttError> {
-        let mqtt_str = MqttString::new(id.as_ref())?;
+    pub fn client_id<T>(mut self, id: T) -> Result<Self, MqttError>
+    where
+        T: IntoMqttString,
+    {
+        let mqtt_str = id.into_mqtt_string()?;
         self.client_id_buf = Some(mqtt_str);
         Ok(self)
     }
@@ -766,15 +769,19 @@ impl ConnectBuilder {
     ///     .build()
     ///     .unwrap();
     /// ```
-    pub fn will_message(
+    pub fn will_message<T, B>(
         mut self,
-        topic: impl AsRef<str>,
-        payload: impl AsRef<[u8]>,
+        topic: T,
+        payload: B,
         qos: Qos,
         retain: bool,
-    ) -> Result<Self, MqttError> {
-        let will_topic = MqttString::new(topic.as_ref())?;
-        let will_payload = MqttBinary::new(payload.as_ref().to_vec())?;
+    ) -> Result<Self, MqttError>
+    where
+        T: IntoMqttString,
+        B: IntoMqttBinary,
+    {
+        let will_topic = topic.into_mqtt_string()?;
+        let will_payload = payload.into_mqtt_binary()?;
 
         self.will_topic_buf = Some(will_topic);
         self.will_payload_buf = Some(will_payload);
@@ -815,8 +822,11 @@ impl ConnectBuilder {
     ///     .build()
     ///     .unwrap();
     /// ```
-    pub fn user_name(mut self, name: impl AsRef<str>) -> Result<Self, MqttError> {
-        let mqtt_str = MqttString::new(name.as_ref())?;
+    pub fn user_name<T>(mut self, name: T) -> Result<Self, MqttError>
+    where
+        T: IntoMqttString,
+    {
+        let mqtt_str = name.into_mqtt_string()?;
         self.user_name_buf = Some(mqtt_str);
 
         let mut flags = self.connect_flags_buf.unwrap_or([0b0000_0010])[0];
@@ -862,8 +872,11 @@ impl ConnectBuilder {
     ///     .build()
     ///     .unwrap();
     /// ```
-    pub fn password(mut self, pwd: impl AsRef<[u8]>) -> Result<Self, MqttError> {
-        let mqtt_bin = MqttBinary::new(pwd.as_ref().to_vec())?;
+    pub fn password<B>(mut self, pwd: B) -> Result<Self, MqttError>
+    where
+        B: IntoMqttBinary,
+    {
+        let mqtt_bin = pwd.into_mqtt_binary()?;
         self.password_buf = Some(mqtt_bin);
 
         let mut flags = self.connect_flags_buf.unwrap_or([0b0000_0010])[0];

src/mqtt/packet/v3_1_1/publish.rs

@@ -39,7 +39,7 @@ use crate::mqtt::packet::qos::Qos;
 use crate::mqtt::packet::variable_byte_integer::VariableByteInteger;
 use crate::mqtt::packet::GenericPacketDisplay;
 use crate::mqtt::packet::GenericPacketTrait;
-use crate::mqtt::packet::{IntoPacketId, IsPacketId};
+use crate::mqtt::packet::{IntoMqttString, IntoPacketId, IsPacketId};
 use crate::mqtt::result_code::MqttError;
 use crate::mqtt::{Arc, ArcPayload, IntoPayload};
 
@@ -690,9 +690,16 @@ where
     /// is published. Topic names must be valid UTF-8 strings and cannot contain
     /// wildcard characters (+ or #) which are reserved for subscription filters.
     ///
+    /// This method accepts both string types (&str, String) and pre-constructed
+    /// `MqttString` instances. When passing a pre-constructed `MqttString`, no
+    /// additional heap allocation occurs, making it efficient for cross-thread
+    /// message passing scenarios.
+    ///
     /// # Parameters
     ///
-    /// * `topic` - The topic name as a string reference
+    /// * `topic` - The topic name. Can be:
+    ///   - `&str` or `String` (will be converted to `MqttString`)
+    ///   - `MqttString` (passed by value without additional allocation)
     ///
     /// # Returns
     ///
@@ -711,17 +718,27 @@ where
     /// ```ignore
     /// use mqtt_protocol_core::mqtt;
     ///
+    /// // From &str (backward compatible)
     /// let builder = mqtt::packet::v3_1_1::Publish::builder()
     ///     .topic_name("sensors/temperature/room1")
     ///     .unwrap();
     ///
+    /// // From pre-constructed MqttString (no additional allocation)
+    /// let topic = mqtt::packet::MqttString::new("sensors/temperature/room1").unwrap();
+    /// let builder = mqtt::packet::v3_1_1::Publish::builder()
+    ///     .topic_name(topic)
+    ///     .unwrap();
+    ///
     /// // This would fail due to wildcard
     /// // let invalid = mqtt::packet::v3_1_1::Publish::builder()
     /// //     .topic_name("sensors/+/temperature")
     /// //     .unwrap();
     /// ```
-    pub fn topic_name<T: AsRef<str>>(mut self, topic: T) -> Result<Self, MqttError> {
-        let mqtt_str = MqttString::new(topic)?;
+    pub fn topic_name<T>(mut self, topic: T) -> Result<Self, MqttError>
+    where
+        T: IntoMqttString,
+    {
+        let mqtt_str = topic.into_mqtt_string()?;
         if mqtt_str.as_str().contains('#') || mqtt_str.as_str().contains('+') {
             return Err(MqttError::MalformedPacket);
         }