Futures

src/client/client_v5.rs

@@ -11,7 +11,7 @@ pub struct MqttClientV5<T, const MAX_PROPERTIES: usize> {
     network_driver: T,
 }
 
-impl<T, const MAX_PROPERTIES: usize> MqttClientV5<T, MAX_PROPERTIES>
+impl<'a, T, const MAX_PROPERTIES: usize> MqttClientV5<T, MAX_PROPERTIES>
 where
     T: Network
 {
@@ -21,11 +21,11 @@ where
         }
     }
     // connect -> connack -> publish -> QoS ? -> disconn
-    pub async fn send_message(& mut self, topic_name: & str, message: & str, buffer: & mut [u8], qos: QualityOfService) -> Result<(), NetworkError> {
+    pub async fn send_message(& mut self, topic_name: & str, message: & str, buffer: &'a mut [u8], qos: QualityOfService) -> Result<(), NetworkError> {
         //connect
-        self.network_driver.create_connection() ?;
+        self.network_driver.create_connection().await ?;
 
-        let mut connect = ConnectPacket::clean();
+        let mut connect = ConnectPacket::<3, 0>::clean();
         let mut len = connect.encode(buffer);
         self.network_driver.send(buffer, len).await ?;
         //connack
@@ -35,23 +35,23 @@ where
         }
 
         // publish
-        let mut packet = PublishPacket::new(topic_name, message);
+        let mut packet = PublishPacket::<5>::new(topic_name, message);
         len = packet.encode(buffer);
-        let result = self.network_driver.send(buffer, len).await ?;
+        self.network_driver.send(buffer, len).await ?;
 
         //QoS1
-        if qos.into() == QoS1.into() {
+        if <QualityOfService as Into<u8>>::into(qos) == <QualityOfService as Into<u8>>::into(QoS1) {
             todo!();
         }
 
         //Disconnect
-        let mut disconnect = DisconnectPacket::new();
+        let mut disconnect = DisconnectPacket::<5>::new();
         len = disconnect.encode(buffer);
         self.network_driver.send(buffer, len);
-        return result;
+        Ok(())
     }
 
-    pub async fn receive<P: Packet<'a>>(& mut self, buffer: & mut [u8]) -> Result<P, ()> {
+    pub async fn receive<P: Packet<'a>>(& mut self, buffer: &'a mut [u8]) -> Result<P, NetworkError> {
         self.network_driver.receive(buffer).await ?;
         let mut packet = P::new();
         packet.decode(&mut BuffReader::new(buffer));
@@ -59,6 +59,6 @@ where
     }
 
     pub async fn receive_message(& mut self, buffer: & mut [u8]) -> Result<(), NetworkError> {
-
+        return Ok(());
     }
 }