BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-07 22:03:40 +00:00
Code Issues Packages Projects Releases Wiki 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

35
rust/flatbuffers/src/builder.rs
View File

@@ -223,9 +223,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
/// new object.
pub fn reset(&mut self) {
// memset only the part of the buffer that could be dirty:
self.allocator[self.head.range_to_end()]
.iter_mut()
.for_each(|x| *x = 0);
self.allocator[self.head.range_to_end()].iter_mut().for_each(|x| *x = 0);
self.head = ReverseIndex::end();
self.written_vtable_revpos.clear();
@@ -627,15 +625,13 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
}
}
let new_vt_bytes = &self.allocator[vt_start_pos.range_to(vt_end_pos)];
let found = self
.written_vtable_revpos
.binary_search_by(|old_vtable_revpos: &UOffsetT| {
let old_vtable_pos = self.allocator.len() - *old_vtable_revpos as usize;
// Safety:
// Already written vtables are valid by construction
let old_vtable = unsafe { VTable::init(&self.allocator, old_vtable_pos) };
new_vt_bytes.cmp(old_vtable.as_bytes())
});
let found = self.written_vtable_revpos.binary_search_by(|old_vtable_revpos: &UOffsetT| {
let old_vtable_pos = self.allocator.len() - *old_vtable_revpos as usize;
// Safety:
// Already written vtables are valid by construction
let old_vtable = unsafe { VTable::init(&self.allocator, old_vtable_pos) };
new_vt_bytes.cmp(old_vtable.as_bytes())
});
let final_vtable_revpos = match found {
Ok(i) => {
// The new vtable is a duplicate so clear it.
@@ -680,9 +676,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
#[inline]
fn grow_allocator(&mut self) {
let starting_active_size = self.used_space();
self.allocator
.grow_downwards()
.expect("Flatbuffer allocation failure");
self.allocator.grow_downwards().expect("Flatbuffer allocation failure");
let ending_active_size = self.used_space();
debug_assert_eq!(starting_active_size, ending_active_size);
@@ -708,11 +702,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
// for the size prefix:
let b = if size_prefixed { SIZE_UOFFSET } else { 0 };
// for the file identifier (a string that is not zero-terminated):
let c = if file_identifier.is_some() {
FILE_IDENTIFIER_LENGTH
} else {
0
};
let c = if file_identifier.is_some() { FILE_IDENTIFIER_LENGTH } else { 0 };
a + b + c
};
@@ -767,10 +757,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
if self.unused_ready_space() >= want {
return want;
}
assert!(
want <= FLATBUFFERS_MAX_BUFFER_SIZE,
"cannot grow buffer beyond 2 gigabytes"
);
assert!(want <= FLATBUFFERS_MAX_BUFFER_SIZE, "cannot grow buffer beyond 2 gigabytes");
while self.unused_ready_space() < want {
self.grow_allocator();

4
rust/flatbuffers/src/lib.rs
View File

@@ -56,8 +56,8 @@ pub use crate::push::{Push, PushAlignment};
pub use crate::table::{buffer_has_identifier, Table};
pub use crate::vector::{follow_cast_ref, Vector, VectorIter};
pub use crate::verifier::{
ErrorTraceDetail, InvalidFlatbuffer, SimpleToVerifyInSlice, TableVerifier, Verifiable, Verifier,
VerifierOptions,
ErrorTraceDetail, InvalidFlatbuffer, SimpleToVerifyInSlice, TableVerifier, Verifiable,
Verifier, VerifierOptions,
};
pub use crate::vtable::field_index_to_field_offset;
pub use bitflags;

23
rust/flatbuffers/src/vector.rs
View File

@@ -31,11 +31,7 @@ impl<'a, T: 'a> Default for Vector<'a, T> {
fn default() -> Self {
// Static, length 0 vector.
// Note that derived default causes UB due to issues in read_scalar_at /facepalm.
Self(
&[0; core::mem::size_of::<UOffsetT>()],
0,
Default::default(),
)
Self(&[0; core::mem::size_of::<UOffsetT>()], 0, Default::default())
}
}
@@ -123,11 +119,11 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
Ordering::Equal => return Some(value),
Ordering::Less => left = mid + 1,
Ordering::Greater => {
if mid == 0 {
return None;
}
right = mid - 1;
},
if mid == 0 {
return None;
}
right = mid - 1;
}
}
}
@@ -209,12 +205,7 @@ impl<'a, T: 'a> VectorIter<'a, T> {
///
#[inline]
pub unsafe fn from_slice(buf: &'a [u8], items_num: usize) -> Self {
VectorIter {
buf,
loc: 0,
remaining: items_num,
phantom: PhantomData,
}
VectorIter { buf, loc: 0, remaining: items_num, phantom: PhantomData }
}
}

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(())
}