Merge pull request #102 from XuJiandong/refactor-lazy-reader

Refactor lazy reader

Author: quake

.github/workflows/ci.yaml

@@ -20,7 +20,7 @@ jobs:
       - name: Setup
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.75.0
+          toolchain: 1.85.1
           components: rustfmt
       - name: Run
         run: make fmt
@@ -32,7 +32,7 @@ jobs:
       - name: Setup
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.75.0
+          toolchain: 1.85.1
           components: clippy
       - name: Run
         run: make clippy
@@ -45,7 +45,7 @@ jobs:
       - name: Setup
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.75.0 # MSRV
+          toolchain: 1.85.1 # MSRV
       - name: Run
         run: make ci-msrv
   test-crates:
@@ -57,7 +57,7 @@ jobs:
       - name: Setup
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.75.0
+          toolchain: 1.85.1
       - name: Run
         run: make ci-crates
   test-examples:
@@ -69,7 +69,7 @@ jobs:
       - name: Setup
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.75.0
+          toolchain: 1.85.1
       - name: Run
         run: make ci-examples
   success:

README.md

@@ -84,7 +84,7 @@ Implementations in other languages are maintained by respective authors.
 
 ## Supported Rust Versions
 
-The minimum supported version is 1.75.0.
+The minimum supported version is 1.85.1.
 The current Molecule version is not guaranteed to build on Rust versions earlier than the
 minimum supported version.
 

bindings/rust/src/lazy_reader.rs

@@ -21,16 +21,7 @@
 //!    load_func: F,
 //!    buf: &mut [u8],
 //!    offset: usize,
-//!    total_size: usize,
 //!) -> Result<usize, Error> {
-//!    if offset >= total_size {
-//!        return Err(Error::OutOfBound(offset, total_size));
-//!    }
-//!    let remaining_len = total_size - offset;
-//!    let min_len = min(remaining_len, buf.len());
-//!    if (offset + min_len) > total_size {
-//!        return Err(Error::OutOfBound(offset + min_len, total_size));
-//!    }
 //!    let actual_len = match load_func(buf, offset) {
 //!        Ok(l) => l,
 //!        Err(err) => match err {
@@ -52,27 +43,26 @@
 //!    }
 //!}
 //!pub struct TransactionReader {
-//!    pub total_size: usize,
+//!    pub size: usize,
 //!}
 //!impl TransactionReader {
 //!    pub fn new() -> Self {
-//!        let total_size = read_size(|buf| syscalls::load_transaction(buf, 0)).unwrap();
-//!        Self { total_size }
+//!        let size = read_size(|buf| syscalls::load_transaction(buf, 0)).unwrap();
+//!        Self { size }
 //!    }
 //!}
 //!impl Read for TransactionReader {
 //!    fn read(&self, buf: &mut [u8], offset: usize) -> Result<usize, Error> {
 //!        read_data(
 //!            |buf, offset| syscalls::load_transaction(buf, offset),
 //!            buf,
-//!            offset,
-//!            self.total_size,
+//!            offset
 //!        )
 //!    }
 //!}
 //!impl From<TransactionReader> for Cursor {
 //!    fn from(data: TransactionReader) -> Self {
-//!        Cursor::new(data.total_size, Box::new(data))
+//!        Cursor::new(data.size, Box::new(data))
 //!    }
 //!}
 //!pub fn new_transaction() -> blockchain::Transaction {
@@ -133,7 +123,6 @@ pub const NUMBER_SIZE: usize = 4;
 ///
 pub struct DataSource {
     reader: Box<dyn Read>,
-    total_size: usize,
     cache_start_point: usize,
     // cache actual size may be smaller than cache.len()
     cache_actual_size: usize,
@@ -142,12 +131,11 @@ pub struct DataSource {
 
 impl DataSource {
     ///
-    /// Create a data source from `reader` and corresponding `total_size`
+    /// Create a data source from `reader`
     ///
-    pub fn new(total_size: usize, reader: Box<dyn Read>) -> Self {
+    pub fn new(reader: Box<dyn Read>) -> Self {
         DataSource {
             reader,
-            total_size,
             cache_start_point: 0,
             cache_actual_size: 0,
             cache: vec![0u8; MAX_CACHE_SIZE],
@@ -208,13 +196,13 @@ pub struct Union {
 
 impl Cursor {
     ///
-    /// Create a cursor from `reader` and its corresponding total size
+    /// Create a cursor from `reader` and its corresponding size
     ///
-    pub fn new(total_size: usize, reader: Box<dyn Read>) -> Self {
-        let data_source = DataSource::new(total_size, reader);
+    pub fn new(size: usize, reader: Box<dyn Read>) -> Self {
+        let data_source = DataSource::new(reader);
         Cursor {
             offset: 0,
-            size: total_size,
+            size,
             data_source: Rc::new(RefCell::new(data_source)),
         }
     }
@@ -241,22 +229,6 @@ impl Cursor {
         self.size = self.size.checked_sub(shrink_size).ok_or(Error::Overflow)?;
         Ok(())
     }
-
-    ///
-    /// Validate a cursor to ensure that size and offset are not out of bounds.
-    ///
-    pub fn validate(&self) -> Result<(), Error> {
-        if let Some(size) = self.offset.checked_add(self.size) {
-            if size > self.data_source.borrow().total_size {
-                Err(Error::TotalSize(size, self.data_source.borrow().total_size))
-            } else {
-                Ok(())
-            }
-        } else {
-            Err(Error::Overflow)
-        }
-    }
-
     ///
     /// Read the first 4 bytes and unpack them into a u32 in little endian format.
     ///
@@ -283,15 +255,22 @@ impl Cursor {
     /// Verify that a cursor is a valid molecule `table` with
     /// `expected_field_count` fields. if `compatible` is true, actual fields
     /// count can be larger than `expected_field_count`.
-    ///  
+    ///
     pub fn verify_table(&self, expected_field_count: usize, compatible: bool) -> Result<(), Error> {
         self.verify_dynvec()?;
+        let total_size = self.unpack_number()?;
+        // Handle empty table case
+        if total_size == NUMBER_SIZE {
+            // An empty table (only header) can only be valid if expected_field_count is 0
+            // This applies regardless of the compatible flag
+            if expected_field_count == 0 {
+                return Ok(());
+            } else {
+                return Err(Error::Verify);
+            }
+        }
         let mut cur = self.clone();
         cur.add_offset(NUMBER_SIZE)?;
-        if self.size == cur.size {
-            // empty table
-            return Ok(());
-        }
         let first_offset = cur.unpack_number()?;
         let field_count = first_offset / NUMBER_SIZE - 1;
         if field_count < expected_field_count || !compatible && field_count > expected_field_count {
@@ -379,10 +358,7 @@ impl Cursor {
         if self.size == NUMBER_SIZE {
             Ok(0)
         } else {
-            let mut cur2 = self.clone();
-            cur2.add_offset(NUMBER_SIZE)?;
-            cur2.sub_size(NUMBER_SIZE)?;
-            cur2.validate()?;
+            let cur2 = self.slice_by_start(NUMBER_SIZE)?;
             cur2.get_item_count()
         }
     }
@@ -419,14 +395,16 @@ impl Cursor {
 
     ///
     /// Create a new cursor by adding an `offset` and setting the `size` to that
-    /// of the original cursor.    
+    /// of the original cursor.
     ///
     pub fn slice_by_offset(&self, offset: usize, size: usize) -> Result<Cursor, Error> {
-        let mut cur2 = self.clone();
-        cur2.add_offset(offset)?;
-        cur2.size = size;
-        cur2.validate()?;
-        Ok(cur2)
+        if (offset + size) > self.size {
+            return Err(Error::TotalSize(offset, size));
+        }
+        let mut cur = self.clone();
+        cur.add_offset(offset)?;
+        cur.size = size;
+        Ok(cur)
     }
     ///
     /// Create a new cursor by adding an offset and shrinking the size to that
@@ -436,7 +414,6 @@ impl Cursor {
         let mut cur2 = self.clone();
         cur2.add_offset(delta)?;
         cur2.sub_size(delta)?;
-        cur2.validate()?;
         Ok(cur2)
     }
 
@@ -449,16 +426,12 @@ impl Cursor {
         item_size: usize,
         item_index: usize,
     ) -> Result<Cursor, Error> {
-        let mut cur2 = self.clone();
         let item_count = self.unpack_number()?;
         if item_index >= item_count {
             Err(Error::OutOfBound(item_index, item_count))
         } else {
             let offset = calculate_offset(item_size, item_index, NUMBER_SIZE)?;
-            cur2.add_offset(offset)?;
-            cur2.size = item_size;
-            cur2.validate()?;
-            Ok(cur2)
+            Ok(self.slice_by_offset(offset, item_size)?)
         }
     }
     ///
@@ -493,7 +466,6 @@ impl Cursor {
             res.size = item_end;
             res.sub_size(item_start)?;
         }
-        res.validate()?;
         Ok(res)
     }
 
@@ -504,11 +476,7 @@ impl Cursor {
 
     /// Assuming a cursor is `fixvec`, return raw data without header.
     pub fn fixvec_slice_raw_bytes(&self) -> Result<Cursor, Error> {
-        let mut res = self.clone();
-        res.add_offset(NUMBER_SIZE)?;
-        res.size = self.unpack_number()?;
-        res.validate()?;
-        Ok(res)
+        self.slice_by_offset(NUMBER_SIZE, self.unpack_number()?)
     }
 
     /// helper function for generated code
@@ -523,10 +491,7 @@ impl Cursor {
     /// Assuming a cursor is `union`. Return a `union`.
     pub fn union_unpack(&self) -> Result<Union, Error> {
         let item_id = self.unpack_number()?;
-        let mut cursor = self.clone();
-        cursor.add_offset(NUMBER_SIZE)?;
-        cursor.sub_size(NUMBER_SIZE)?;
-        cursor.validate()?;
+        let cursor = self.slice_by_start(NUMBER_SIZE)?;
         Ok(Union { item_id, cursor })
     }
 }

bindings/rust/src/primitive.rs

@@ -16,7 +16,7 @@ impl fmt::Debug for Byte {
     }
 }
 
-impl<'r> fmt::Debug for ByteReader<'r> {
+impl fmt::Debug for ByteReader<'_> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}(0x{:02x})", Self::NAME, self.0[0])
@@ -30,7 +30,7 @@ impl fmt::Display for Byte {
     }
 }
 
-impl<'r> fmt::Display for ByteReader<'r> {
+impl fmt::Display for ByteReader<'_> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}(0x{:02x})", Self::NAME, self.0[0])

examples/lazy-reader-tests/src/types_all_data.rs

@@ -1140,3 +1140,43 @@ fn test_struct_verify() {
     .verify(false)
     .expect_err("");
 }
+
+#[test]
+fn test_verify_table() {
+    // table with 2 fields
+    let data = vec![14, 0, 0, 0, 12, 0, 0, 0, 13, 0, 0, 0, 100, 200];
+    types_api2::Table1 {
+        cursor: new_cursor(&data),
+    }
+    .verify(false)
+    .expect_err("");
+    types_api2::Table1 {
+        cursor: new_cursor(&data),
+    }
+    .verify(true)
+    .expect("");
+    // table with 0 field
+    let data = vec![4, 0, 0, 0];
+    types_api2::Table1 {
+        cursor: new_cursor(&data),
+    }
+    .verify(false)
+    .expect_err("");
+    types_api2::Table1 {
+        cursor: new_cursor(&data),
+    }
+    .verify(true)
+    .expect_err("");
+
+    // empty table can accept it
+    types_api2::Table0 {
+        cursor: new_cursor(&data),
+    }
+    .verify(true)
+    .expect("");
+    types_api2::Table0 {
+        cursor: new_cursor(&data),
+    }
+    .verify(false)
+    .expect("");
+}

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.85.1"

tools/codegen/src/ast/raw/utils.rs

@@ -12,7 +12,7 @@ use crate::{
     utils::{self, PairsUtils as _},
 };
 
-impl<'i> utils::PairsUtils for Pairs<'i, parser::Rule> {
+impl utils::PairsUtils for Pairs<'_, parser::Rule> {
     fn next_string(&mut self) -> String {
         self.next().unwrap().as_str().to_owned()
     }

tools/codegen/src/ast/verified/mod.rs

@@ -164,7 +164,7 @@ impl TopDecl {
 
     fn imported_depth(&self) -> usize {
         match self {
-            Self::Primitive(_) => usize::max_value(),
+            Self::Primitive(_) => usize::MAX,
             Self::Option_(inner) => inner.imported_depth,
             Self::Union(inner) => inner.imported_depth,
             Self::Array(inner) => inner.imported_depth,