BigfootDev/flatbuffers-bigfoot
1
0
Fork 0
forked from BigfootDev/flatbuffers
Code Pull Requests Activity

bulk code format fix (#8707)

Browse Source
This commit is contained in:
Derek Bailey
2025-09-23 21:50:27 -07:00
committed by GitHub
parent 0e047869da
commit caf3b494db
559 changed files with 38871 additions and 31276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
rust/flatbuffers/src/verifier.rs
View File

@@ -20,18 +20,9 @@ use std::error::Error;
/// the other errors should not be producible by correct flatbuffers implementations.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ErrorTraceDetail {
VectorElement {
index: usize,
position: usize,
},
TableField {
field_name: Cow<'static, str>,
position: usize,
},
UnionVariant {
variant: Cow<'static, str>,
position: usize,
},
VectorElement { index: usize, position: usize },
TableField { field_name: Cow<'static, str>, position: usize },
UnionVariant { variant: Cow<'static, str>, position: usize },
}
#[derive(PartialEq, Eq, Default, Debug, Clone)]
@@ -100,33 +91,18 @@ impl Error for InvalidFlatbuffer {
impl core::fmt::Display for InvalidFlatbuffer {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
match self {
InvalidFlatbuffer::MissingRequiredField {
required,
error_trace,
} => {
InvalidFlatbuffer::MissingRequiredField { required, error_trace } => {
writeln!(f, "Missing required field `{}`.\n{}", required, error_trace)?;
}
InvalidFlatbuffer::InconsistentUnion {
field,
field_type,
error_trace,
} => {
InvalidFlatbuffer::InconsistentUnion { field, field_type, error_trace } => {
writeln!(
f,
"Exactly one of union discriminant (`{}`) and value (`{}`) are present.\n{}",
field_type, field, error_trace
)?;
}
InvalidFlatbuffer::Utf8Error {
error,
range,
error_trace,
} => {
writeln!(
f,
"Utf8 error for string in {:?}: {}\n{}",
range, error, error_trace
)?;
InvalidFlatbuffer::Utf8Error { error, range, error_trace } => {
writeln!(f, "Utf8 error for string in {:?}: {}\n{}", range, error, error_trace)?;
}
InvalidFlatbuffer::MissingNullTerminator { range, error_trace } => {
writeln!(
@@ -135,11 +111,7 @@ impl core::fmt::Display for InvalidFlatbuffer {
range.start, range.end, error_trace
)?;
}
InvalidFlatbuffer::Unaligned {
position,
unaligned_type,
error_trace,
} => {
InvalidFlatbuffer::Unaligned { position, unaligned_type, error_trace } => {
writeln!(
f,
"Type `{}` at position {} is unaligned.\n{}",
@@ -153,11 +125,7 @@ impl core::fmt::Display for InvalidFlatbuffer {
range.start, range.end, error_trace
)?;
}
InvalidFlatbuffer::SignedOffsetOutOfBounds {
soffset,
position,
error_trace,
} => {
InvalidFlatbuffer::SignedOffsetOutOfBounds { soffset, position, error_trace } => {
writeln!(
f,
"Signed offset at position {} has value {} which points out of bounds.\n{}",
@@ -190,10 +158,7 @@ impl core::fmt::Display for ErrorTrace {
index, position
)?;
}
TableField {
field_name,
position,
} => {
TableField { field_name, position } => {
writeln!(
f,
"\twhile verifying table field `{}` at position {:?}",
@@ -217,10 +182,7 @@ pub type Result<T> = core::result::Result<T, InvalidFlatbuffer>;
impl InvalidFlatbuffer {
fn new_range_oob<T>(start: usize, end: usize) -> Result<T> {
Err(Self::RangeOutOfBounds {
range: Range { start, end },
error_trace: Default::default(),
})
Err(Self::RangeOutOfBounds { range: Range { start, end }, error_trace: Default::default() })
}
pub fn new_inconsistent_union<T>(
field: impl Into<Cow<'static, str>>,
@@ -260,13 +222,7 @@ fn append_trace<T>(mut res: Result<T>, d: ErrorTraceDetail) -> Result<T> {
/// Adds a TableField trace detail if `res` is a data error.
fn trace_field<T>(res: Result<T>, field_name: Cow<'static, str>, position: usize) -> Result<T> {
append_trace(
res,
ErrorTraceDetail::TableField {
field_name,
position,
},
)
append_trace(res, ErrorTraceDetail::TableField { field_name, position })
}
/// Adds a TableField trace detail if `res` is a data error.
@@ -315,13 +271,7 @@ pub struct Verifier<'opts, 'buf> {
impl<'opts, 'buf> Verifier<'opts, 'buf> {
pub fn new(opts: &'opts VerifierOptions, buffer: &'buf [u8]) -> Self {
Self {
opts,
buffer,
depth: 0,
num_tables: 0,
apparent_size: 0,
}
Self { opts, buffer, depth: 0, num_tables: 0, apparent_size: 0 }
}
/// Resets verifier internal state.
#[inline]
@@ -435,12 +385,7 @@ impl<'opts, 'buf> Verifier<'opts, 'buf> {
if self.depth > self.opts.max_depth {
return Err(InvalidFlatbuffer::DepthLimitReached);
}
Ok(TableVerifier {
pos: table_pos,
vtable: vtable_pos,
vtable_len,
verifier: self,
})
Ok(TableVerifier { pos: table_pos, vtable: vtable_pos, vtable_len, verifier: self })
}
/// Runs the union variant's type's verifier assuming the variant is at the given position,
@@ -451,13 +396,7 @@ impl<'opts, 'buf> Verifier<'opts, 'buf> {
position: usize,
) -> Result<()> {
let res = T::run_verifier(self, position);
append_trace(
res,
ErrorTraceDetail::UnionVariant {
variant: variant.into(),
position,
},
)
append_trace(res, ErrorTraceDetail::UnionVariant { variant: variant.into(), position })
}
}
@@ -501,11 +440,7 @@ impl<'ver, 'opts, 'buf> TableVerifier<'ver, 'opts, 'buf> {
required: bool,
) -> Result<Self> {
if let Some(field_pos) = self.deref(field)? {
trace_field(
T::run_verifier(self.verifier, field_pos),
field_name.into(),
field_pos,
)?;
trace_field(T::run_verifier(self.verifier, field_pos), field_name.into(), field_pos)?;
return Ok(self);
}
if required {
@@ -545,11 +480,7 @@ impl<'ver, 'opts, 'buf> TableVerifier<'ver, 'opts, 'buf> {
}
}
(Some(k), Some(v)) => {
trace_field(
Key::run_verifier(self.verifier, k),
key_field_name.into(),
k,
)?;
trace_field(Key::run_verifier(self.verifier, k), key_field_name.into(), k)?;
// Safety:
// Run verifier on `k` above
let discriminant = unsafe { Key::follow(self.verifier.buffer, k) };
@@ -560,7 +491,10 @@ impl<'ver, 'opts, 'buf> TableVerifier<'ver, 'opts, 'buf> {
)?;
Ok(self)
}
_ => InvalidFlatbuffer::new_inconsistent_union(key_field_name.into(), val_field_name.into()),
_ => InvalidFlatbuffer::new_inconsistent_union(
key_field_name.into(),
val_field_name.into(),
),
}
}
pub fn finish(self) -> &'ver mut Verifier<'opts, 'buf> {
@@ -642,11 +576,7 @@ impl<T: Verifiable> Verifiable for Vector<'_, ForwardsUOffset<T>> {
let range = verify_vector_range::<ForwardsUOffset<T>>(v, pos)?;
let size = core::mem::size_of::<ForwardsUOffset<T>>();
for (i, element_pos) in range.step_by(size).enumerate() {
trace_elem(
<ForwardsUOffset<T>>::run_verifier(v, element_pos),
i,
element_pos,
)?;
trace_elem(<ForwardsUOffset<T>>::run_verifier(v, element_pos), i, element_pos)?;
}
Ok(())
}