chaokunyang commented on code in PR #2765:
URL: https://github.com/apache/fory/pull/2765#discussion_r2428585574
##########
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:
> It is actually equivalent to:
>
> ```rust
> match option {
> Some(v) => Ok(v),
> None => Err((|| E)()),
> }
> ```
>
> When the Option is Some, the closure is never called or even allocated —
it’s just a zero-cost inline conditional branch.
I don't think so, the closure will always be allocated, it just don't get
executed when match to `Some`
--
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]
