all valid pedantic clippy warnings fixed

src/database.rs

@@ -61,7 +61,7 @@ pub fn write<W: Write>(database: Database, mut writer: BufWriter<W>) -> Result<(
     }
 
     let table_root_page = current_top_layer.get_mut(0).unwrap();
-    writer.write_all(&create_header_page(n_pages + 1, database.schema).data)?; // 1 for header page
+    writer.write_all(&create_header_page((n_pages + 1) as u32, database.schema).data)?; // 1 for header page
 
     assign_pagenumbers(table_root_page, 2);
     set_page_references(table_root_page);
@@ -73,7 +73,7 @@ pub fn write<W: Write>(database: Database, mut writer: BufWriter<W>) -> Result<(
 fn assign_pagenumbers(page: &mut Page, page_counter: u32) {
     page.number = page_counter;
     let mut counter = page_counter;
-    for child in page.children.iter_mut() {
+    for child in &mut page.children {
         counter += 1;
         assign_pagenumbers(child, counter);
     }
@@ -87,34 +87,33 @@ fn set_page_references(page: &mut Page) {
         page.fw_position = page::POSITION_RIGHTMOST_POINTER_LEAFPAGES;
         page.put_u32(page.get_page_nr_last_child());
 
-        let index = 0;
         let before_last = page.children.len() - 1;
         let child_numbers: Vec<u32> = page.children.iter().map(|child| child.number).collect();
 
-        for child_page_number in child_numbers {
+        for (index, child_page_number) in child_numbers.iter().enumerate() {
             if index < before_last {
                 page.fw_position = page::START_OF_INTERIOR_PAGE + (index as u16) * 2;
                 page.fw_position = page.get_u16();
-                page.put_u32(child_page_number);
+                page.put_u32(*child_page_number);
             }
         }
     }
-    for child in page.children.iter_mut() {
+    for child in &mut page.children {
         set_page_references(child);
     }
 }
 
 fn write_pages<W: Write>(writer: &mut BufWriter<W>, page: &Page) -> Result<(), Error> {
     writer.write_all(&page.data)?;
-    for child in page.children.iter() {
+    for child in &page.children {
         write_pages(writer, child)?;
     }
     Ok(())
 }
 
-fn create_header_page(n_pages: usize, schema: SchemaRecord) -> Page {
+fn create_header_page(n_pages: u32, schema: SchemaRecord) -> Page {
     let mut header_page = Page::new_root();
-    write_header(&mut header_page, n_pages as u32);
+    write_header(&mut header_page, n_pages);
 
     let payload_location_write_location = header_page.fw_position; // mark current position
 

src/page.rs

@@ -13,7 +13,7 @@ pub enum PageType {
     Other,
 }
 
-/// Represents an SQLite page
+/// Represents an `SQLite` page
 pub struct Page {
     pub data: Vec<u8>,
     pub fw_position: u16,
@@ -116,7 +116,7 @@ impl Page {
 
     pub fn get_u16(&self) -> u16 {
         let position = self.fw_position as usize;
-        ((self.data[position] as u16) << 8) + (self.data[position + 1]) as u16
+        (u16::from(self.data[position]) << 8) + u16::from(self.data[position + 1])
         // does not increase the fw pointerr
     }
 }

src/record.rs

@@ -1,5 +1,5 @@
 use crate::database::SchemaRecord;
-use crate::values::*;
+use crate::values::{Value, integer, string};
 use crate::varint;
 
 pub struct Record {
@@ -23,7 +23,7 @@ impl Record {
 
     /// length of the byte representation
     pub fn bytes_len(&self) -> u16 {
-        let record_length: u16 = self.values.iter().map(|v| v.len()).sum();
+        let record_length: u16 = self.values.iter().map(Value::len).sum();
         record_length + 1
     }
 }
@@ -31,7 +31,7 @@ impl Record {
 impl From<Record> for Vec<u8> {
     fn from(mut record: Record) -> Vec<u8> {
         let record_length = record.bytes_len();
-        let mut length_bytes = varint::write(record_length as u64);
+        let mut length_bytes = varint::write(u64::from(record_length));
         let mut rowid_bytes = varint::write(record.rowid);
 
         let mut buffer =
@@ -47,13 +47,13 @@ impl From<Record> for Vec<u8> {
         ));
 
         //write all types
-        for v in record.values.iter_mut() {
+        for v in &mut record.values {
-            buffer.append(&mut v.datatype)
+            buffer.append(&mut v.datatype);
         }
 
         //  write all values
-        for v in record.values.iter_mut() {
+        for v in &mut record.values {
-            buffer.append(&mut v.data)
+            buffer.append(&mut v.data);
         }
         buffer
     }
@@ -65,7 +65,7 @@ impl From<SchemaRecord> for Record {
         record.add_value(string("table"));
         record.add_value(string(&s.table_name.to_ascii_lowercase()));
         record.add_value(string(&s.table_name.to_ascii_lowercase()));
-        record.add_value(integer(s.root_page as i64));
+        record.add_value(integer(i64::from(s.root_page)));
         record.add_value(string(&s.sql));
         record
     }

src/values.rs

@@ -57,10 +57,10 @@ fn sqlite_integer_to_bytes(value: i64) -> Vec<u8> {
     }
 }
 
-fn i64_to_bytes(n: i64, nbytes: u8) -> Vec<u8> {
+fn i64_to_bytes(value: i64, len: u8) -> Vec<u8> {
     let mut bytes = vec![];
-    for i in 0..nbytes {
+    for i in 0..len {
-        bytes.push(((n >> ((nbytes - i - 1) * 8)) & 0xFF) as u8);
+        bytes.push(((value >> ((len - i - 1) * 8)) & 0xFF) as u8);
     }
 
     bytes
@@ -74,7 +74,7 @@ fn get_int_type(value: i64) -> Vec<u8> {
     } else {
         let length = get_length_of_byte_encoding(value);
         if length < 5 {
-            varint::write(length as u64)
+            varint::write(u64::from(length))
         } else if length < 7 {
             varint::write(5)
         } else {
@@ -87,13 +87,13 @@ fn get_length_of_byte_encoding(value: i64) -> u8 {
     let u = if value < 0 { !value } else { value };
     if u <= 127 {
         1
-    } else if u <= 32767 {
+    } else if u <= 32_767 {
         2
-    } else if u <= 8388607 {
+    } else if u <= 8_388_607 {
         3
-    } else if u <= 2147483647 {
+    } else if u <= 2_147_483_647 {
         4
-    } else if u <= 140737488355327 {
+    } else if u <= 140_737_488_355_327 {
         6
     } else {
         8

src/varint.rs

@@ -1,16 +1,7 @@
-/// varints as implemented in SQLite
+/// varints as implemented in `SQLite`
 pub fn write(value: u64) -> Vec<u8> {
     let mut v = value;
-    if (v & ((0xff000000) << 32)) != 0 {
+    if (v & ((0xff00_0000) << 32)) == 0 {
-        let mut result = vec![0_u8; 9];
-        result[8] = v as u8;
-        v >>= 8;
-        for i in (0..=7).rev() {
-            result[i] = ((v & 0x7f) | 0x80) as u8;
-            v >>= 7;
-        }
-        result
-    } else {
         if v == 0 {
             return vec![0];
         }
@@ -23,6 +14,15 @@ pub fn write(value: u64) -> Vec<u8> {
 
         result.reverse();
         result
+    } else {
+        let mut result = vec![0_u8; 9];
+        result[8] = v as u8;
+        v >>= 8;
+        for i in (0..=7).rev() {
+            result[i] = ((v & 0x7f) | 0x80) as u8;
+            v >>= 7;
+        }
+        result
     }
 }