Method load_node

src/structures/mmap_tree/storage.rs:231–314

(&mut self, offset: usize)

    }

    pub fn load_node(&mut self, offset: usize) -> io::Result<Node<K, V>> {
        let original_offset = offset.clone();
        let mut offset = offset.clone();

        // println!("Loading node at offset: {}", offset);

        let mut serialized = Vec::new();

        let mut is_primary;

        let mut serialized_len;

        let mut bytes_read = 0;

        self.acquire_block_lock(original_offset)?;

        loop {
            let block_is_primary =
                u8::from_le_bytes(self.read_from_offset(offset, 1).try_into().unwrap());

            if block_is_primary == 0 {
                is_primary = false;
            } else if block_is_primary == 1 {
                is_primary = true;
            } else {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    "Invalid block type",
                ));
            }

            if !is_primary && bytes_read == 0 {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    "Primary block not found",
                ));
            }

            offset += 1; // one for the primary byte

            serialized_len = usize::from_le_bytes(
                self.read_from_offset(offset, SIZE_OF_USIZE)
                    .try_into()
                    .unwrap(),
            );

            offset += SIZE_OF_USIZE;

            // println!("Serialized len: {}", serialized_len);

            let bytes_to_read = std::cmp::min(serialized_len - bytes_read, BLOCK_DATA_SIZE);
            // println!(
            //     "Bytes read: {}, bytes to read: {}",
            //     bytes_read, bytes_to_read
            // );

            bytes_read += bytes_to_read;