urlyy commented on code in PR #2765:
URL: https://github.com/apache/fory/pull/2765#discussion_r2428598772
##########
rust/fory-core/src/buffer.rs:
##########
@@ -394,215 +419,254 @@ impl Reader {
}
#[inline(always)]
- pub fn read_bool(&mut self) -> bool {
- let result = unsafe { *self.ptr_at(self.cursor) };
- self.move_next(1);
- result != 0
+ pub fn read_bool(&mut self) -> Result<bool, Error> {
+ let ptr = self.ptr_at(self.cursor)?;
+ self.move_next(1)?;
+ let result = unsafe { *ptr };
+ Ok(result != 0)
}
#[inline(always)]
- pub fn read_u8(&mut self) -> u8 {
- let result = unsafe { *self.ptr_at(self.cursor) };
- self.move_next(1);
- result
+ pub fn read_u8(&mut self) -> Result<u8, Error> {
+ let ptr = self.ptr_at(self.cursor)?;
+ self.move_next(1)?;
+ let result = unsafe { *ptr };
+ Ok(result)
}
#[inline(always)]
- pub fn read_i8(&mut self) -> i8 {
- self.read_u8() as i8
+ pub fn read_i8(&mut self) -> Result<i8, Error> {
+ Ok(self.read_u8()? as i8)
}
#[inline(always)]
- pub fn read_u16(&mut self) -> u16 {
- let result = LittleEndian::read_u16(self.slice_after_cursor());
- self.move_next(2);
- result
+ pub fn read_u16(&mut self) -> Result<u16, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_u16(slice);
+ self.move_next(2)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_i16(&mut self) -> i16 {
- let result = LittleEndian::read_i16(self.slice_after_cursor());
- self.move_next(2);
- result
+ pub fn read_i16(&mut self) -> Result<i16, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_i16(slice);
+ self.move_next(2)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_u32(&mut self) -> u32 {
- let result = LittleEndian::read_u32(self.slice_after_cursor());
- self.move_next(4);
- result
+ pub fn read_u32(&mut self) -> Result<u32, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_u32(slice);
+ self.move_next(4)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_i32(&mut self) -> i32 {
- let result = LittleEndian::read_i32(self.slice_after_cursor());
- self.move_next(4);
- result
+ pub fn read_i32(&mut self) -> Result<i32, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_i32(slice);
+ self.move_next(4)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_u64(&mut self) -> u64 {
- let result = LittleEndian::read_u64(self.slice_after_cursor());
- self.move_next(8);
- result
+ pub fn read_u64(&mut self) -> Result<u64, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_u64(slice);
+ self.move_next(8)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_i64(&mut self) -> i64 {
- let result = LittleEndian::read_i64(self.slice_after_cursor());
- self.move_next(8);
- result
+ pub fn read_i64(&mut self) -> Result<i64, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_i64(slice);
+ self.move_next(8)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_f32(&mut self) -> f32 {
- let result = LittleEndian::read_f32(self.slice_after_cursor());
- self.move_next(4);
- result
+ pub fn read_f32(&mut self) -> Result<f32, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_f32(slice);
+ self.move_next(4)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_f64(&mut self) -> f64 {
- let result = LittleEndian::read_f64(self.slice_after_cursor());
- self.move_next(8);
- result
+ pub fn read_f64(&mut self) -> Result<f64, Error> {
+ let slice = self.slice_after_cursor()?;
+ let result = LittleEndian::read_f64(slice);
+ self.move_next(8)?;
+ Ok(result)
}
#[inline(always)]
- pub fn read_varuint32(&mut self) -> u32 {
- let start = self.cursor;
- let b0 = unsafe { *self.bf.add(start) as u32 };
+ pub fn read_varuint32(&mut self) -> Result<u32, Error> {
+ let slice = self.slice_after_cursor()?;
+
+ let b0 = *slice
+ .first()
+ .ok_or_else(|| Error::msg("unexpected end of buffer"))? as u32;
Review Comment:
I made a simple demo:
```rust
use anyhow::Error;
use rand::Rng;
#[inline(never)]
fn test_ok_or_else(slice: &[u8]) -> Result<u32, Error> {
let b0 = *slice
.first()
.ok_or_else(|| Error::msg("unexpected end of buffer"))? as u32;
Ok(b0)
}
fn main() {
let mut rng = rand::rng();
let empty = rng.random_bool(0.5);
let slice: &[u8] = if empty { &[] } else { &[42] };
let _ = test_ok_or_else(slice);
}
```
<img width="796" height="466" alt="image"
src="https://github.com/user-attachments/assets/2a6de230-4638-43a7-90e5-d0820ba8a7b5";
/>
So `let b0 = *slice.first().ok_or_else(|| Error::msg("unexpected end of
buffer"))?;` is equivalent to
```rust
let b0 = match slice.first() {
Some(&byte) => byte as u32,
None => return Err(Error::msg("unexpected end of buffer")),
};
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
