flake.lock

@@ -1,27 +0,0 @@
-{
-  "nodes": {
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1714906307,
-        "narHash": "sha256-UlRZtrCnhPFSJlDQE7M0eyhgvuuHBTe1eJ9N9AQlJQ0=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "25865a40d14b3f9cf19f19b924e2ab4069b09588",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,23 +0,0 @@
-{
-  description = "Rust setup";
-
-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-  };
-
-  outputs = { self, nixpkgs, ... }:
-    let
-      system = "x86_64-linux";
-      pkgs = nixpkgs.legacyPackages.${system};
-    in {
-      devShells.${system}.default = pkgs.mkShell {
-
-        buildInputs = with pkgs; [
-          cargo
-          clippy
-          rustfmt
-        ];
-
-      };
-    };
-}

src/r701.rs

@@ -65,28 +65,26 @@ impl R701 {
 
         // If the response length is right but the header is `01 00 00 00 00 00
         // 00 00` then the request is been succesful but the name was not found
-        if response.len() == 34
+        if response[..12] == [0xaa, 0x55, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
-            && response[..12] == [0xaa, 0x55, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
+            && response.len() == 34
         {
             return Ok(None);
         }
 
         // If one between the response length or the response header is wrong
         // return an error
-        if response.len() != 34
+        if response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
-            || response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
+            || response.len() != 34
         {
             return Err(Error::new(InvalidData, "Malformed response"));
         }
 
         // Get the name as a UTF-8 string and delete the `\0` at the end
-        let name = String::from_utf8_lossy(&response[12..22])
+        Ok(Some(
-            .trim_end_matches('\0')
+            String::from_utf8_lossy(&response[12..22])
-            .to_string();
+                .trim_end_matches(char::from(0))
-
+                .to_string(),
-        // Return None if the name is empty, else return the name wrapped into a
+        ))
-        // Some
-        Ok(Some(name).filter(|name| !name.is_empty()))
     }
 
     pub fn get_total_record_count(&mut self) -> Result<u16> {
@@ -96,9 +94,9 @@ impl R701 {
 
         // If one between the response length or the response header is wrong
         // return an error
-        if response.len() != 10
+        if response[..4] != [0xaa, 0x55, 0x01, 0x01]
-            || response[..4] != [0xaa, 0x55, 0x01, 0x01]
             || response[6..] != [0u8; 4]
+            || response.len() != 10
         {
             return Err(Error::new(InvalidData, "Malformed response"));
         }
@@ -135,15 +133,15 @@ impl R701 {
 
         // If one between the response length, the response header or the last
         // two bits is wrong return an error
-        if response.len() != 1038
+        if response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
-            || response[..12] != [0xaa, 0x55, 0x01, 0x01, 0, 0, 0, 0, 0, 0, 0x55, 0xaa]
             || response[1036..] != [0, 0]
+            || response.len() != 1038
         {
             return Err(Error::new(InvalidData, "Malformed response"));
         }
 
         // Return only the payload bits as a vector
-        Ok(response[12..1036].to_vec())
+        Ok(response[12..response.len() - 2].to_vec())
     }
 
     pub fn iter(&mut self) -> Result<RecordIterator> {

src/record_iterator.rs

@@ -6,36 +6,25 @@ pub struct RecordIterator<'a> {
     r701: &'a mut R701,
     input_buffer: Vec<u8>,
     sequence_number: u16,
-    total_records: u16,
     record_count: u16,
+    total_records: u16,
 }
 
 impl<'a> RecordIterator<'a> {
     pub fn from(r701: &'a mut R701) -> Result<Self> {
+        // Ping the endpoint
+        r701.ping()?;
+
         // Get the total number of records
         let total_records = r701.get_total_record_count()?;
 
-        // Calculate the sequence number on which the last record resides and
-        // the index of the first `ff` byte, avoiding overflows
-        let sequence_number = (total_records as u32 * 12 / 1024) as u16;
-        let first_useless_byte_index = total_records as usize * 12 % 1024;
-
-        // The endpoint expects the first block of records to be sent first
-        r701.get_record_bytes(total_records, 0)?;
-
-        // Get the last records and cut out all the trailing `ff` bytes
-        let input_buffer = r701
-            .get_record_bytes(total_records, sequence_number)?
-            .drain(..first_useless_byte_index)
-            .collect::<Vec<u8>>();
-
         // Return a new Iterator
         Ok(Self {
             r701,
-            input_buffer,
+            input_buffer: Vec::new(),
-            sequence_number,
+            record_count: 0,
+            sequence_number: 0,
             total_records,
-            record_count: total_records,
         })
     }
 }
@@ -44,39 +33,32 @@ impl<'a> Iterator for RecordIterator<'a> {
     type Item = Record;
 
     fn next(&mut self) -> Option<Self::Item> {
-        // Stop iterating when there are no more records
+        self.record_count += 1;
-        if self.record_count == 0 {
+
+        // If we exceeded the total number of records, return None
+        if self.record_count > self.total_records {
             return None;
         }
 
-        self.record_count -= 1;
+        // If the buffer is empty, make another request to the endpoint asking
-
+        // for more data
-        // If the input buffer is almost empty, make another request to the
-        // endpoint asking for more data
         if self.input_buffer.len() < 12 {
-            // If the buffer is almost empty but the sequence number is already
+            let bytes = &mut self
-            // zero, stop iterating
-            if self.sequence_number == 0 {
-                return None;
-            }
-
-            self.sequence_number -= 1;
-
-            // Request new bytes
-            let bytes = self
                 .r701
                 .get_record_bytes(self.total_records, self.sequence_number)
                 .ok()?;
 
-            // Put the bytes at the start of the vector
+            self.input_buffer.append(bytes);
-            self.input_buffer.splice(0..0, bytes.iter().copied());
+            self.sequence_number += 1;
+        }
+
+        // If the record bytes are set to `ff ff ff ff ff ff ff ff ff ff ff ff`,
+        // return None
+        if self.input_buffer[..12] == [0xff_u8; 12] {
+            return None;
         }
 
         // Return a new Record
-        self.input_buffer
+        self.input_buffer.drain(..12).as_slice().try_into().ok()
-            .drain(self.input_buffer.len() - 12..)
-            .as_slice()
-            .try_into()
-            .ok()
     }
 }