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

10
rust/flexbuffers/src/builder/map.rs
View File

@@ -48,10 +48,7 @@ impl<'a> MapBuilder<'a> {
self.builder.push_key(key);
// Nested vector.
let start = Some(self.builder.values.len());
VectorBuilder {
builder: self.builder,
start,
}
VectorBuilder { builder: self.builder, start }
}
/// Starts a nested map which that will be pushed onto this map
/// with key `key` when it is dropped.
@@ -63,10 +60,7 @@ impl<'a> MapBuilder<'a> {
self.builder.push_key(key);
// Nested map.
let start = Some(self.builder.values.len());
MapBuilder {
builder: self.builder,
start,
}
MapBuilder { builder: self.builder, start }
}
/// `end_map` sorts the map by key and writes it to the buffer. This happens anyway
/// when the map builder is dropped.

41
rust/flexbuffers/src/builder/mod.rs
View File

@@ -35,12 +35,8 @@ macro_rules! push_slice {
S: AsRef<[T]>,
{
let mut value = Value::$new_vec(xs.as_ref().len());
let mut width = xs
.as_ref()
.iter()
.map(|x| BitWidth::from((*x).into()))
.max()
.unwrap_or_default();
let mut width =
xs.as_ref().iter().map(|x| BitWidth::from((*x).into())).max().unwrap_or_default();
if !value.is_fixed_length_vector() {
let length = Value::UInt(xs.as_ref().len() as u64);
width = std::cmp::max(width, length.width_or_child_width());
@@ -135,16 +131,8 @@ impl Default for Builder {
impl<'a> Builder {
pub fn new(opts: BuilderOptions) -> Self {
let key_pool = if opts.contains(BuilderOptions::SHARE_KEYS) {
Some(vec![])
} else {
None
};
Builder {
key_pool,
values: Vec::new(),
buffer: Vec::new(),
}
let key_pool = if opts.contains(BuilderOptions::SHARE_KEYS) { Some(vec![]) } else { None };
Builder { key_pool, values: Vec::new(), buffer: Vec::new() }
}
/// Shows the internal flexbuffer. It will either be empty or populated with the most
/// recently built flexbuffer.
@@ -167,10 +155,7 @@ impl<'a> Builder {
}
}
fn push_key(&mut self, key: &str) {
debug_assert!(
key.bytes().all(|b| b != b'\0'),
"Keys must not have internal nulls."
);
debug_assert!(key.bytes().all(|b| b != b'\0'), "Keys must not have internal nulls.");
// Search key pool if there is one.
let found = self.key_pool.as_ref().map(|pool| {
pool.binary_search_by(|&CachedKey(addr)| {
@@ -217,11 +202,7 @@ impl<'a> Builder {
store_value(&mut self.buffer, length, width);
let address = self.buffer.len();
self.buffer.extend_from_slice(xs);
Value::Reference {
fxb_type: FlexBufferType::Blob,
address,
child_width: width,
}
Value::Reference { fxb_type: FlexBufferType::Blob, address, child_width: width }
}
fn push_str(&mut self, x: &str) {
let mut string = self.store_blob(x.as_bytes());
@@ -261,18 +242,12 @@ impl<'a> Builder {
/// The exact Flexbuffer vector type is dynamically inferred.
pub fn start_vector(&'a mut self) -> VectorBuilder<'a> {
self.reset();
VectorBuilder {
builder: self,
start: None,
}
VectorBuilder { builder: self, start: None }
}
/// Resets the builder and builds a new flexbuffer with a map at the root.
pub fn start_map(&'a mut self) -> MapBuilder<'a> {
self.reset();
MapBuilder {
builder: self,
start: None,
}
MapBuilder { builder: self, start: None }
}
/// Resets the builder and builds a new flexbuffer with the pushed value at the root.
pub fn build_singleton<P: Pushable>(&mut self, p: P) {

14
rust/flexbuffers/src/builder/ser.rs
View File

@@ -49,19 +49,13 @@ impl FlexbufferSerializer {
Ok(())
}
fn start_vector(&mut self) {
let previous_end = if self.nesting.is_empty() {
None
} else {
Some(self.builder.values.len())
};
let previous_end =
if self.nesting.is_empty() { None } else { Some(self.builder.values.len()) };
self.nesting.push(previous_end);
}
fn start_map(&mut self) {
let previous_end = if self.nesting.is_empty() {
None
} else {
Some(self.builder.values.len())
};
let previous_end =
if self.nesting.is_empty() { None } else { Some(self.builder.values.len()) };
self.nesting.push(previous_end);
}
fn end_vector(&mut self) -> Result<(), Error> {

71
rust/flexbuffers/src/builder/value.rs
View File

@@ -47,26 +47,10 @@ macro_rules! new_typed_vector {
let address = 0;
let child_width = W8;
match n {
2 => Value::Reference {
address,
child_width,
fxb_type: $v2,
},
3 => Value::Reference {
address,
child_width,
fxb_type: $v3,
},
4 => Value::Reference {
address,
child_width,
fxb_type: $v4,
},
_ => Value::Reference {
address,
child_width,
fxb_type: $vn,
},
2 => Value::Reference { address, child_width, fxb_type: $v2 },
3 => Value::Reference { address, child_width, fxb_type: $v3 },
4 => Value::Reference { address, child_width, fxb_type: $v4 },
_ => Value::Reference { address, child_width, fxb_type: $vn },
}
}
};
@@ -74,40 +58,14 @@ macro_rules! new_typed_vector {
impl Value {
pub fn new_vector() -> Self {
Value::Reference {
address: 0,
child_width: W8,
fxb_type: Vector,
}
Value::Reference { address: 0, child_width: W8, fxb_type: Vector }
}
pub fn new_map() -> Self {
Value::Reference {
address: 0,
child_width: W8,
fxb_type: Map,
}
Value::Reference { address: 0, child_width: W8, fxb_type: Map }
}
new_typed_vector!(
new_int_vector,
VectorInt2,
VectorInt3,
VectorInt4,
VectorInt
);
new_typed_vector!(
new_uint_vector,
VectorUInt2,
VectorUInt3,
VectorUInt4,
VectorUInt
);
new_typed_vector!(
new_float_vector,
VectorFloat2,
VectorFloat3,
VectorFloat4,
VectorFloat
);
new_typed_vector!(new_int_vector, VectorInt2, VectorInt3, VectorInt4, VectorInt);
new_typed_vector!(new_uint_vector, VectorUInt2, VectorUInt3, VectorUInt4, VectorUInt);
new_typed_vector!(new_float_vector, VectorFloat2, VectorFloat3, VectorFloat4, VectorFloat);
pub fn fxb_type(&self) -> FlexBufferType {
match *self {
Value::Null => Null,
@@ -264,11 +222,7 @@ where
// Note that VectorString is deprecated for writing
_ => return Value::new_vector(),
};
Value::Reference {
address: 0,
child_width: W8,
fxb_type: vector_type,
}
Value::Reference { address: 0, child_width: W8, fxb_type: vector_type }
}
#[inline]
@@ -299,9 +253,6 @@ pub fn store_value(buffer: &mut Vec<u8>, mut value: Value, width: BitWidth) {
_ => unreachable!("Variant not considered: {:?}", value),
};
write_result.unwrap_or_else(|err| {
panic!(
"Error writing value {:?} with width {:?}: {:?}",
value, width, err
)
panic!("Error writing value {:?} with width {:?}: {:?}", value, width, err)
});
}

10
rust/flexbuffers/src/builder/vector.rs
View File

@@ -38,19 +38,13 @@ impl<'a> VectorBuilder<'a> {
#[inline]
pub fn start_vector(&mut self) -> VectorBuilder {
let start = Some(self.builder.values.len());
VectorBuilder {
builder: self.builder,
start,
}
VectorBuilder { builder: self.builder, start }
}
/// Starts a nested map that will be pushed onto this vector when it is dropped.
#[inline]
pub fn start_map(&mut self) -> MapBuilder {
let start = Some(self.builder.values.len());
MapBuilder {
builder: self.builder,
start,
}
MapBuilder { builder: self.builder, start }
}
/// `end_vector` determines the type of the vector and writes it to the buffer.
/// This will happen automatically if the VectorBuilder is dropped.

11
rust/flexbuffers/src/reader/de.rs
View File

@@ -153,10 +153,7 @@ impl<'de> VariantAccess<'de> for Reader<&'de [u8]> {
V: Visitor<'de>,
{
let m = self.get_map()?;
visitor.visit_map(MapAccessor {
keys: m.keys_vector().iter(),
vals: m.iter_values(),
})
visitor.visit_map(MapAccessor { keys: m.keys_vector().iter(), vals: m.iter_values() })
}
}
@@ -190,10 +187,8 @@ impl<'de> Deserializer<'de> for Reader<&'de [u8]> {
(Blob, _) => visitor.visit_borrowed_bytes(self.get_blob()?.0),
(Map, _) => {
let m = self.get_map()?;
visitor.visit_map(MapAccessor {
keys: m.keys_vector().iter(),
vals: m.iter_values(),
})
visitor
.visit_map(MapAccessor { keys: m.keys_vector().iter(), vals: m.iter_values() })
}
(ty, _) if ty.is_vector() => visitor.visit_seq(self.as_vector().iter()),
(ty, bw) => unreachable!("TODO deserialize_any {:?} {:?}.", ty, bw),

6
rust/flexbuffers/src/reader/iter.rs
View File

@@ -27,11 +27,7 @@ pub struct ReaderIterator<B> {
impl<B: Buffer> ReaderIterator<B> {
pub(super) fn new(reader: VectorReader<B>) -> Self {
let end = reader.len();
ReaderIterator {
reader,
front: 0,
end,
}
ReaderIterator { reader, front: 0, end }
}
}

13
rust/flexbuffers/src/reader/map.rs
View File

@@ -34,10 +34,7 @@ pub struct MapReader<B> {
impl<B: Buffer> Clone for MapReader<B> {
fn clone(&self) -> Self {
MapReader {
buffer: self.buffer.shallow_copy(),
..*self
}
MapReader { buffer: self.buffer.shallow_copy(), ..*self }
}
}
@@ -125,13 +122,7 @@ impl<B: Buffer> MapReader<B> {
.get(type_address)
.ok_or(Error::FlexbufferOutOfBounds)
.and_then(|&b| unpack_type(b))?;
Reader::new(
self.buffer.shallow_copy(),
data_address,
fxb_type,
width,
self.values_width,
)
Reader::new(self.buffer.shallow_copy(), data_address, fxb_type, width, self.values_width)
}
fn key_index(&self, k: &str) -> Result<Reader<B>, Error> {

119
rust/flexbuffers/src/reader/mod.rs
View File

@@ -217,12 +217,7 @@ impl<B: Buffer> Reader<B> {
fxb_type = t;
}
}
Ok(Reader {
address,
fxb_type,
width,
buffer,
})
Ok(Reader { address, fxb_type, width, buffer })
}
/// Parses the flexbuffer from the given buffer. Assumes the flexbuffer root is the last byte
@@ -263,11 +258,7 @@ impl<B: Buffer> Reader<B> {
if let Some(len) = self.fxb_type.fixed_length_vector_length() {
len
} else if self.fxb_type.has_length_slot() && self.address >= self.width.n_bytes() {
read_usize(
&self.buffer,
self.address - self.width.n_bytes(),
self.width,
)
read_usize(&self.buffer, self.address - self.width.n_bytes(), self.width)
} else {
0
}
@@ -287,20 +278,14 @@ impl<B: Buffer> Reader<B> {
if self.fxb_type == ty {
Ok(())
} else {
Err(Error::UnexpectedFlexbufferType {
expected: ty,
actual: self.fxb_type,
})
Err(Error::UnexpectedFlexbufferType { expected: ty, actual: self.fxb_type })
}
}
fn expect_bw(&self, bw: BitWidth) -> Result<(), Error> {
if self.width == bw {
Ok(())
} else {
Err(Error::UnexpectedBitWidth {
expected: bw,
actual: self.width,
})
Err(Error::UnexpectedBitWidth { expected: bw, actual: self.width })
}
}
@@ -320,10 +305,8 @@ impl<B: Buffer> Reader<B> {
self.expect_bw(T::WIDTH)?;
}
let end = self.address + self.length() * std::mem::size_of::<T>();
let slice: &[u8] = self
.buffer
.get(self.address..end)
.ok_or(Error::FlexbufferOutOfBounds)?;
let slice: &[u8] =
self.buffer.get(self.address..end).ok_or(Error::FlexbufferOutOfBounds)?;
// `align_to` is required because the point of this function is to directly hand back a
// slice of scalars. This can fail because Rust's default allocator is not 16byte aligned
@@ -340,11 +323,7 @@ impl<B: Buffer> Reader<B> {
/// Otherwise Returns error.
pub fn get_bool(&self) -> Result<bool, Error> {
self.expect_type(FlexBufferType::Bool)?;
Ok(
self.buffer[self.address..self.address + self.width.n_bytes()]
.iter()
.any(|&b| b != 0),
)
Ok(self.buffer[self.address..self.address + self.width.n_bytes()].iter().any(|&b| b != 0))
}
/// Gets the length of the key if this type is a key.
@@ -387,9 +366,7 @@ impl<B: Buffer> Reader<B> {
/// is out of bounds.
pub fn get_str(&self) -> Result<B::BufferString, Error> {
self.expect_type(FlexBufferType::String)?;
let bytes = self
.buffer
.slice(self.address..self.address + self.length());
let bytes = self.buffer.slice(self.address..self.address + self.length());
Ok(bytes.ok_or(Error::ReadUsizeOverflowed)?.buffer_str()?)
}
@@ -425,22 +402,16 @@ impl<B: Buffer> Reader<B> {
/// address is out of bounds.
pub fn get_u64(&self) -> Result<u64, Error> {
self.expect_type(FlexBufferType::UInt)?;
let cursor = self
.buffer
.get(self.address..self.address + self.width.n_bytes());
let cursor = self.buffer.get(self.address..self.address + self.width.n_bytes());
match self.width {
BitWidth::W8 => cursor.map(|s| s[0] as u8).map(Into::into),
BitWidth::W16 => cursor
.and_then(|s| s.try_into().ok())
.map(<u16>::from_le_bytes)
.map(Into::into),
BitWidth::W32 => cursor
.and_then(|s| s.try_into().ok())
.map(<u32>::from_le_bytes)
.map(Into::into),
BitWidth::W64 => cursor
.and_then(|s| s.try_into().ok())
.map(<u64>::from_le_bytes),
BitWidth::W16 => {
cursor.and_then(|s| s.try_into().ok()).map(<u16>::from_le_bytes).map(Into::into)
}
BitWidth::W32 => {
cursor.and_then(|s| s.try_into().ok()).map(<u32>::from_le_bytes).map(Into::into)
}
BitWidth::W64 => cursor.and_then(|s| s.try_into().ok()).map(<u64>::from_le_bytes),
}
.ok_or(Error::FlexbufferOutOfBounds)
}
@@ -448,22 +419,16 @@ impl<B: Buffer> Reader<B> {
/// address is out of bounds.
pub fn get_i64(&self) -> Result<i64, Error> {
self.expect_type(FlexBufferType::Int)?;
let cursor = self
.buffer
.get(self.address..self.address + self.width.n_bytes());
let cursor = self.buffer.get(self.address..self.address + self.width.n_bytes());
match self.width {
BitWidth::W8 => cursor.map(|s| s[0] as i8).map(Into::into),
BitWidth::W16 => cursor
.and_then(|s| s.try_into().ok())
.map(<i16>::from_le_bytes)
.map(Into::into),
BitWidth::W32 => cursor
.and_then(|s| s.try_into().ok())
.map(<i32>::from_le_bytes)
.map(Into::into),
BitWidth::W64 => cursor
.and_then(|s| s.try_into().ok())
.map(<i64>::from_le_bytes),
BitWidth::W16 => {
cursor.and_then(|s| s.try_into().ok()).map(<i16>::from_le_bytes).map(Into::into)
}
BitWidth::W32 => {
cursor.and_then(|s| s.try_into().ok()).map(<i32>::from_le_bytes).map(Into::into)
}
BitWidth::W64 => cursor.and_then(|s| s.try_into().ok()).map(<i64>::from_le_bytes),
}
.ok_or(Error::FlexbufferOutOfBounds)
}
@@ -471,18 +436,13 @@ impl<B: Buffer> Reader<B> {
/// address is out of bounds, or if its a f16 or f8 (not currently supported).
pub fn get_f64(&self) -> Result<f64, Error> {
self.expect_type(FlexBufferType::Float)?;
let cursor = self
.buffer
.get(self.address..self.address + self.width.n_bytes());
let cursor = self.buffer.get(self.address..self.address + self.width.n_bytes());
match self.width {
BitWidth::W8 | BitWidth::W16 => return Err(Error::InvalidPackedType),
BitWidth::W32 => cursor
.and_then(|s| s.try_into().ok())
.map(f32_from_le_bytes)
.map(Into::into),
BitWidth::W64 => cursor
.and_then(|s| s.try_into().ok())
.map(f64_from_le_bytes),
BitWidth::W32 => {
cursor.and_then(|s| s.try_into().ok()).map(f32_from_le_bytes).map(Into::into)
}
BitWidth::W64 => cursor.and_then(|s| s.try_into().ok()).map(f64_from_le_bytes),
}
.ok_or(Error::FlexbufferOutOfBounds)
}
@@ -505,11 +465,9 @@ impl<B: Buffer> Reader<B> {
pub fn as_u64(&self) -> u64 {
match self.fxb_type {
FlexBufferType::UInt => self.get_u64().unwrap_or_default(),
FlexBufferType::Int => self
.get_i64()
.unwrap_or_default()
.try_into()
.unwrap_or_default(),
FlexBufferType::Int => {
self.get_i64().unwrap_or_default().try_into().unwrap_or_default()
}
FlexBufferType::Float => self.get_f64().unwrap_or_default() as u64,
FlexBufferType::String => {
if let Ok(s) = self.get_str() {
@@ -532,11 +490,9 @@ impl<B: Buffer> Reader<B> {
pub fn as_i64(&self) -> i64 {
match self.fxb_type {
FlexBufferType::Int => self.get_i64().unwrap_or_default(),
FlexBufferType::UInt => self
.get_u64()
.unwrap_or_default()
.try_into()
.unwrap_or_default(),
FlexBufferType::UInt => {
self.get_u64().unwrap_or_default().try_into().unwrap_or_default()
}
FlexBufferType::Float => self.get_f64().unwrap_or_default() as i64,
FlexBufferType::String => {
if let Ok(s) = self.get_str() {
@@ -590,10 +546,7 @@ impl<B: Buffer> Reader<B> {
if !self.fxb_type.is_vector() {
self.expect_type(FlexBufferType::Vector)?;
};
Ok(VectorReader {
reader: self.clone(),
length: self.length(),
})
Ok(VectorReader { reader: self.clone(), length: self.length() })
}
}

10
rust/flexbuffers/src/reader/vector.rs
View File

@@ -29,19 +29,13 @@ pub struct VectorReader<B> {
impl<B: Buffer> Clone for VectorReader<B> {
fn clone(&self) -> Self {
VectorReader {
reader: self.reader.clone(),
..*self
}
VectorReader { reader: self.reader.clone(), ..*self }
}
}
impl<B: Buffer> Default for VectorReader<B> {
fn default() -> Self {
VectorReader {
reader: Reader::default(),
length: usize::default(),
}
VectorReader { reader: Reader::default(), length: usize::default() }
}
}