Flexbuffers

https://docs.rs/flexbuffers
Admin
Flexbuffers is a high-performance schemaless binary data format for serialization and...
Tokens:95,410
Snippets:883
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Builder Methods

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

Provides methods to start building flexbuffers, such as starting a map or building a singleton value.

```APIDOC
## Builder

### start_map

Resets the builder and builds a new flexbuffer with a map at the root.

### build_singleton<P: Pushable>

Resets the builder and builds a new flexbuffer with the pushed value at the root.

### push<P: Pushable>

Pushes a value onto the builder.

### end_map_or_vector

Stores the values past `previous_end` as a map or vector depending on `is_map`. If `previous_end` is None then this was a root map / vector and the last value is stored as the root.
```

--------------------------------

### Builder::start_map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Starts building a Flexbuffer with a map as the root element.

```APIDOC
## Builder::start_map

### Description
Resets the builder and begins the construction of a Flexbuffer with a map as the root. Keys and values are pushed into the map using the returned `MapBuilder`.

### Signature
```rust
pub fn start_map(&'a mut self) -> MapBuilder<'a>
```
```

--------------------------------

### Builder::start_vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Starts building a Flexbuffer with a vector as the root element.

```APIDOC
## Builder::start_vector

### Description
Resets the builder and initiates the construction of a Flexbuffer where the root element is a vector. The type of vector elements is determined dynamically. Returns a `VectorBuilder` to populate the vector.

### Signature
```rust
pub fn start_vector(&'a mut self) -> VectorBuilder<'a>
```
```

--------------------------------

### Start building a root vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Resets the builder and starts a new flexbuffer with a vector at the root. The exact Flexbuffer vector type is dynamically inferred. Returns a `VectorBuilder` to push elements.

```rust
pub fn start_vector(&'a mut self) -> VectorBuilder<'a>
```

--------------------------------

### Starting a nested vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorBuilder.html

Starts a nested vector that will be pushed onto the current vector when the returned VectorBuilder is dropped.

```rust
pub fn start_vector(&mut self) -> VectorBuilder<'_>
```

--------------------------------

### Starting a nested map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorBuilder.html

Starts a nested map that will be pushed onto the current vector when the returned MapBuilder is dropped.

```rust
pub fn start_map(&mut self) -> MapBuilder<'_>
```

--------------------------------

### Get Key String

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Retrieves the string value up until the first `\0` character.

```rust
pub fn get_key(&self) -> Result<B::BufferString, Error> {
        let bytes = self
            .buffer
            .slice(self.address..self.address + self.get_key_len()?)
            .ok_or(Error::IndexOutOfBounds)?;
        Ok(bytes.buffer_str()?)
    }
```

--------------------------------

### Initialize a new FlexBuffers Builder

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

Creates a new Builder instance with default options. Use this to start constructing a FlexBuffer.

```rust
let opts = Default::default();
Builder::new(opts)
```

--------------------------------

### VectorBuilder::start_vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorBuilder.html

Starts a nested vector. This new vector will be pushed onto the current vector when it is dropped.

```APIDOC
## VectorBuilder::start_vector

### Description
Starts a nested vector that will be pushed onto this vector when it is dropped.

### Signature
```rust
pub fn start_vector(&mut self) -> VectorBuilder<'_>
```

### Returns
A new `VectorBuilder` instance representing the nested vector.
```

--------------------------------

### VectorBuilder::start_map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorBuilder.html

Starts a nested map. This new map will be pushed onto the current vector when it is dropped.

```APIDOC
## VectorBuilder::start_map

### Description
Starts a nested map that will be pushed onto this vector when it is dropped.

### Signature
```rust
pub fn start_map(&mut self) -> MapBuilder<'_>
```

### Returns
A new `MapBuilder` instance representing the nested map.
```

--------------------------------

### Start building a root map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Resets the builder and builds a new flexbuffer with a map at the root. Returns a `MapBuilder` to push key-value pairs.

```rust
pub fn start_map(&'a mut self) -> MapBuilder<'a>
```

--------------------------------

### BuilderOptions Default and Iteration

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Provides functionality to get the default BuilderOptions and to create them from iterators.

```APIDOC
## Default for BuilderOptions

### fn default() -> Self

Returns the “default value” for a type.

## Extend<BuilderOptions> for BuilderOptions

### fn extend<T: IntoIterator<Item = Self>>(&mut self, iterator: T)

Extends a collection with the contents of an iterator.

### fn extend_one(&mut self, item: A)

Extends a collection with exactly one element.

### fn extend_reserve(&mut self, additional: usize)

Reserves capacity in a collection for the given number of additional elements.

## FromIterator<BuilderOptions> for BuilderOptions

### fn from_iter<T: IntoIterator<Item = Self>>(iterator: T) -> Self

Creates a value from an iterator.
```

--------------------------------

### Start building a vector

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

Resets the builder and prepares it to construct a new FlexBuffer with a vector as the root element. The specific vector type is determined dynamically.

```rust
pub fn start_vector(&'a mut self) -> VectorBuilder<'a> {
    self.reset();
}
```

--------------------------------

### Start Map Serialization

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates the serialization of a map. Similar to `start_vector`, it records the current state of the builder's value stack for later use when ending the map.

```rust
fn start_map(&mut self) {
        let previous_end =
            if self.nesting.is_empty() { None } else { Some(self.builder.values.len()) };
        self.nesting.push(previous_end);
    }
```

--------------------------------

### Start Nested Map in MapBuilder

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapBuilder.html

Starts a nested map within the current map. The nested map is pushed with the given key when the returned MapBuilder is dropped. Panics in debug mode if the key contains internal nulls.

```rust
pub fn start_map(&mut self, key: &str) -> MapBuilder<'_>
```

--------------------------------

### Serialize Struct Variant in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a struct variant by starting a map, pushing the variant name as a key, and then starting another map for the struct fields. Returns the serializer to continue building.

```rust
fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        self.start_map();
        self.builder.push_key(variant);
        self.start_map();
        Ok(self)
    }
```

--------------------------------

### Start Nested Vector in MapBuilder

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapBuilder.html

Starts a nested vector within the map. The vector is pushed with the given key when the returned VectorBuilder is dropped. Panics in debug mode if the key contains internal nulls.

```rust
pub fn start_vector(&mut self, key: &str) -> VectorBuilder<'_>
```

--------------------------------

### Serialize Sequence in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a sequence by starting a vector. Returns the serializer itself to continue building the sequence.

```rust
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        self.start_vector();
        Ok(self)
    }
```

--------------------------------

### Serialize Map in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a map by starting a map. Returns the serializer itself to continue building the map entries.

```rust
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        self.start_map();
        Ok(self)
    }
```

--------------------------------

### Start Vector Serialization

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Marks the beginning of a vector serialization. It pushes the current builder's value stack size onto the nesting stack to track the vector's boundaries.

```rust
fn start_vector(&mut self) {
        let previous_end =
            if self.nesting.is_empty() { None } else { Some(self.builder.values.len()) };
        self.nesting.push(previous_end);
    }
```

--------------------------------

### MapBuilder::start_map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapBuilder.html

Starts a nested map within the current map. The nested map will be added with the specified key when the returned MapBuilder is dropped. Panics if the key contains internal nulls in debug mode.

```APIDOC
## start_map

### Description
Starts a nested map which that will be pushed onto this map with key `key` when it is dropped.
This will panic (in debug mode) if `key` contains internal nulls.

### Signature
```rust
pub fn start_map(&mut self, key: &str) -> MapBuilder<'_>
```

### Parameters
* `key` - The string key under which the nested map will be added.
```

--------------------------------

### Rust: Start a Nested Map in a Flexbuffer Map

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/map.rs.html

Use `start_map` to begin a nested map within the current map. The nested map is added when the returned `MapBuilder` is dropped. Panics if keys contain internal nulls in debug mode.

```rust
pub fn start_map(&mut self, key: &str) -> MapBuilder<'_> {
        // Push the key that refers to this nested vector.
        self.builder.push_key(key);
        // Nested map.
        let start = Some(self.builder.values.len());
        MapBuilder { builder: self.builder, start }
    }
```

--------------------------------

### Serialize Tuple in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a tuple by starting a vector. Returns the serializer itself to continue building the tuple elements.

```rust
fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.start_vector();
        Ok(self)
    }
```

--------------------------------

### Serialize Struct in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a struct by starting a map. Returns the serializer itself to continue building the struct fields.

```rust
fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        self.start_map();
        Ok(self)
    }
```

--------------------------------

### Get Root Element of Flexbuffer

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Parses the flexbuffer from the given buffer, assuming the root is at the end. It determines the root's width, type, and starting address.

```rust
pub fn get_root(buffer: B) -> Result<Self, Error> {
        let end = buffer.len();
        if end < 3 {
            return Err(Error::FlexbufferOutOfBounds);
        }
        // Last byte is the root width.
        let root_width = BitWidth::from_nbytes(buffer[end - 1]).ok_or(Error::InvalidRootWidth)?;
        // Second last byte is root type.
        let (fxb_type, width) = unpack_type(buffer[end - 2])?;
        // Location of root data. (BitWidth bits before root type)
        let address = safe_sub(end - 2, root_width.n_bytes())?;
        Self::new(buffer, address, fxb_type, width, root_width)
    }
```

--------------------------------

### Get the root of a Flexbuffer

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Parses the flexbuffer from the given buffer. Assumes the flexbuffer root is the last byte of the buffer. Use this to start reading data from a Flexbuffer.

```rust
pub fn get_root(buffer: B) -> Result<Self, Error>
```

--------------------------------

### take

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.ReaderIterator.html

Creates an iterator that yields the first `n` elements.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- `n`: The maximum number of elements to yield.
```

--------------------------------

### Get Key Length

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Gets the length of the key if this type is a key. Otherwise, returns an error.

```rust
fn get_key_len(&self) -> Result<usize, Error> {
        self.expect_type(FlexBufferType::Key)?;
        let (length, _) = self.buffer[self.address..]
            .iter()
            .enumerate()
            .find(|(_, &b)| b == b'\0')
            .unwrap_or((0, &0));
        Ok(length)
    }
```

--------------------------------

### singleton

Source: https://docs.rs/flexbuffers/latest/flexbuffers/fn.singleton.html

Builds a Flexbuffer with the single pushed value as the root.

```APIDOC
## singleton<P: Pushable>(p: P) -> Vec<u8>

### Description
Builds a Flexbuffer with the single pushed value as the root.

### Signature
```rust
pub fn singleton<P: Pushable>(p: P) -> Vec<u8>
```
```

--------------------------------

### MapBuilder::start_vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapBuilder.html

Starts a nested vector within the map. The vector will be added to the map with the specified key when the returned VectorBuilder is dropped. Panics if the key contains internal nulls in debug mode.

```APIDOC
## start_vector

### Description
Starts a nested vector that will be pushed onto this map with key `key` when it is dropped.
This will panic (in debug mode) if `key` contains internal nulls.

### Signature
```rust
pub fn start_vector(&mut self, key: &str) -> VectorBuilder<'_>
```

### Parameters
* `key` - The string key under which the vector will be added to the map.
```

--------------------------------

### Builder::new

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

Creates a new Builder instance with the specified options. If `BuilderOptions::SHARE_KEYS` is set, a key pool is initialized.

```APIDOC
pub fn new(opts: BuilderOptions) -> Self
```

--------------------------------

### Initialize FlexbufferSerializer

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Creates a new instance of `FlexbufferSerializer` using its default configuration. This is the entry point for serializing data.

```rust
pub fn new() -> Self {
        Self::default()
    }
```

--------------------------------

### BuilderOptions Initialization

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Methods for creating and manipulating BuilderOptions instances.

```APIDOC
## BuilderOptions Initialization

### `empty()`
Returns an empty set of flags, meaning no data sharing is enabled.

### `all()`
Returns a BuilderOptions instance with all available flags set, enabling all data sharing options.
```

--------------------------------

### Rust: Start a Nested Vector in a Flexbuffer Map

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/map.rs.html

Use `start_vector` to begin a nested vector within a map. The vector is added to the map when the returned `VectorBuilder` is dropped. Panics if keys contain internal nulls in debug mode.

```rust
pub fn start_vector(&mut self, key: &str) -> VectorBuilder<'_> {
        // Push the key that refers to this nested vector.
        self.builder.push_key(key);
        // Nested vector.
        let start = Some(self.builder.values.len());
        VectorBuilder { builder: self.builder, start }
    }
```

--------------------------------

### Serialize Tuple Variant in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a tuple variant by starting a map, pushing the variant name as a key, and then starting a vector for the tuple elements. Returns the serializer to continue building.

```rust
fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        self.start_map();
        self.builder.push_key(variant);
        self.start_vector();
        Ok(self)
    }
```

--------------------------------

### Builder::new

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Creates a new Builder instance with the specified options.

```APIDOC
## Builder::new

### Description
Initializes a new `Builder` with the given `BuilderOptions`.

### Signature
```rust
pub fn new(opts: BuilderOptions) -> Self
```
```

--------------------------------

### Create a New FlexbufferSerializer

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.FlexbufferSerializer.html

Instantiates a new FlexbufferSerializer. This is the entry point for serializing data.

```rust
pub fn new() -> Self
```

--------------------------------

### type_id

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Gets the `TypeId` of `self`.

```APIDOC
## type_id

### Description
Gets the `TypeId` of `self`.

### Signature
`fn type_id(&self) -> TypeId`
```

--------------------------------

### BuilderOptions Ordering and Comparison

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Provides methods for comparing BuilderOptions instances, including total ordering and partial ordering.

```APIDOC
## Ord for BuilderOptions

### fn cmp(&self, other: &BuilderOptions) -> Ordering

This method returns an `Ordering` between `self` and `other`.

### fn max(self, other: Self) -> Self

where Self: Sized,
Compares and returns the maximum of two values.

### fn min(self, other: Self) -> Self

where Self: Sized,
Compares and returns the minimum of two values.

### fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,
Restrict a value to a certain interval.

## PartialEq for BuilderOptions

### fn eq(&self, other: &BuilderOptions) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.

### fn ne(&self, other: &Rhs) -> bool

Tests for `!=`.

## PartialOrd for BuilderOptions

### fn partial_cmp(&self, other: &BuilderOptions) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists.

### fn lt(&self, other: &Rhs) -> bool

Tests less than (for `self` and `other`) and is used by the `<` operator.

### fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### fn gt(&self, other: &Rhs) -> bool

Tests greater than (for `self` and `other`) and is used by the `>` operator.

### fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.
```

--------------------------------

### Get Bitwidth

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns the bitwidth of this Reader.

```rust
pub fn bitwidth(&self) -> BitWidth {
        self.width
    }
```

--------------------------------

### Rust: Create and Push to a Flexbuffer Map

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/map.rs.html

Use `MapBuilder` to create a map and `push` to add key-value pairs. Panics if keys contain internal nulls in debug mode.

```rust
pub fn push<P: Pushable>(&mut self, key: &str, p: P) {
        self.builder.push_key(key);
        self.builder.push(p);
    }
```

--------------------------------

### Build a Flexbuffer with a Singleton Root

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

Use this function to create a flexbuffer where the entire buffer consists of a single value at the root. It initializes a builder, pushes the value, and stores it as the root.

```rust
pub fn singleton<P: Pushable>(p: P) -> Vec<u8> {
    let mut b = Builder::default();
    b.build_singleton(p);
    let Builder { buffer, .. } = b;
    buffer
}
```

--------------------------------

### Get a blob

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Retrieves a blob from the Flexbuffer. Use this for raw byte data.

```rust
pub fn get_blob(&self) -> Result<Blob<B>, Error>
```

--------------------------------

### Singleton Builder

Source: https://docs.rs/flexbuffers/latest/index.html

Builds a Flexbuffer with a single pushed value as the root.

```APIDOC
## Function

### `singleton<T: Pushable>(value: T) -> Vec<u8>`

Builds a Flexbuffer with the single pushed value as the root.

### Example
```rust
use flexbuffers::singleton;

let buffer = singleton(42);
```
```

--------------------------------

### Get Boolean Value

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns the value of the reader if it is a boolean. Otherwise returns error.

```rust
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))
    }
```

--------------------------------

### Get Blob as Buffer

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns the Blob data, or an empty buffer if an error occurs during retrieval.

```rust
pub fn as_blob(&self) -> Blob<B> {
        self.get_blob().unwrap_or_else(|_| Blob(B::empty()))
    }
```

--------------------------------

### Get a MapReader

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns a MapReader for accessing map data. Use this when the Flexbuffer type is a map.

```rust
pub fn as_map(&self) -> MapReader<B>
```

--------------------------------

### Get a VectorReader

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns a VectorReader for accessing vector data. Use this when the Flexbuffer type is a vector.

```rust
pub fn as_vector(&self) -> VectorReader<B>
```

--------------------------------

### Builder::build_singleton

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Builds a Flexbuffer with a single root value.

```APIDOC
## Builder::build_singleton

### Description
Resets the builder and serializes a single provided value as the root of the Flexbuffer. The value must implement the `Pushable` trait.

### Signature
```rust
pub fn build_singleton<P: Pushable>(&mut self, p: P)
```
```

--------------------------------

### Get the bitwidth of a Reader

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns the bitwidth of this Reader. This is important for understanding the size of the data elements.

```rust
pub fn bitwidth(&self) -> BitWidth
```

--------------------------------

### Get Vector Reader

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns a VectorReader for the current element if it is a vector. It ensures the type is a Vector before proceeding.

```rust
pub fn get_vector(&self) -> Result<VectorReader<B>, Error> {
        if !self.fxb_type.is_vector() {
            self.expect_type(FlexBufferType::Vector)?;
        };
        Ok(VectorReader { reader: self.clone(), length: self.length() })
    }
```

--------------------------------

### BuilderOptions Hashing and Formatting

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Methods for hashing BuilderOptions and formatting them in hexadecimal and octal.

```APIDOC
## Hash for BuilderOptions

### fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given `Hasher`.

### fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,
Feeds a slice of this type into the given `Hasher`.

## LowerHex for BuilderOptions

### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

## Octal for BuilderOptions

### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.
```

--------------------------------

### Get String Value

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Retrieves the string value. Errors if invalid UTF-8, or the provided index is out of bounds.

```rust
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());
        Ok(bytes.ok_or(Error::ReadUsizeOverflowed)?.buffer_str()?)
    }
```

--------------------------------

### Implementation for &[u8]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Buffer.html

Demonstrates the implementation of the Buffer trait for byte slices (`&[u8]`), providing concrete methods for slicing, creating empty buffers, and string conversion.

```APIDOC
## Implementations on Foreign Types

### impl<'de> Buffer for &'de [u8]

#### fn empty_str() -> Self::BufferString

Based off of the `empty` function, allows override for optimization purposes.

#### type BufferString = &'de str

#### fn slice(&self, range: Range<usize>) -> Option<Self>

#### fn empty() -> Self

#### fn buffer_str(&self) -> Result<Self::BufferString, Utf8Error>
```

--------------------------------

### Get the length of the Flexbuffer

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns the length of the Flexbuffer. If the type has no length, or if an error occurs, 0 is returned.

```rust
pub fn length(&self) -> usize
```

--------------------------------

### Get the FlexBufferType of a Reader

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns the FlexBufferType of this Reader. This indicates the type of data the reader is currently pointing to.

```rust
pub fn flexbuffer_type(&self) -> FlexBufferType
```

--------------------------------

### BitWidth Methods

Source: https://docs.rs/flexbuffers/latest/flexbuffers/enum.BitWidth.html

Provides methods for converting between byte sizes and BitWidth variants.

```APIDOC
## Implementations for BitWidth

### `impl BitWidth`

#### `pub fn n_bytes(self) -> usize`
Returns the number of bytes corresponding to the BitWidth variant.

#### `pub fn from_nbytes(n: impl Into<usize>) -> Option<Self>`
Attempts to create a BitWidth variant from a given number of bytes. Returns `None` if the input is not a valid byte size for a BitWidth.

```

--------------------------------

### as_f32

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns an f32 by casting from f64.

```APIDOC
## as_f32

### Description
Returns an f32 representation of the current value by first obtaining an f64 representation and then casting it to f32. This method leverages the `as_f64` method for the initial conversion.

### Method Signature
`pub fn as_f32(&self) -> f32`

### Return Value
- `f32`: The f32 representation of the value.
```

--------------------------------

### Reader::buffer

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Convenience function to get the underlying buffer. By using `shallow_copy`, this preserves the lifetime that the underlying buffer has.

```APIDOC
## Reader::buffer

### Description
Convenience function to get the underlying buffer. By using `shallow_copy`, this preserves the lifetime that the underlying buffer has.

### Method
`pub fn buffer(&self) -> B`

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **B** - The underlying buffer.

### Response Example
None
```

--------------------------------

### VectorReader Methods

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/vector.rs.html

Provides methods for interacting with flexbuffer vectors, such as getting the length, checking for emptiness, and indexing elements.

```APIDOC
## VectorReader

### Description
Allows indexing on any flexbuffer vector type, including heterogenous vectors, typed vectors, or fixed-length typed vectors. VectorReaders may be indexed with `usize`. The `index` method returns a result type which may indicate failure due to indexing out of bounds or bad data. The `idx` method returns a Null Reader in the event of any failure.

### Methods

#### `len()`

*   **Description**: Returns the number of elements in the vector.
*   **Returns**: `usize` - The number of elements.

#### `is_empty()`

*   **Description**: Returns true if there are 0 elements in the vector.
*   **Returns**: `bool` - `true` if the vector is empty, `false` otherwise.

#### `idx(i: usize)`

*   **Description**: Index into a flexbuffer vector. Any errors are defaulted to Null Readers.
*   **Parameters**:
    *   `i` (usize) - The index to access.
*   **Returns**: `Reader<B>` - The reader for the element at the given index, or a default Null Reader on error.

#### `index(i: usize)`

*   **Description**: Index into a flexbuffer.
*   **Parameters**:
    *   `i` (usize) - The index to access.
*   **Returns**: `Result<Reader<B>, Error>` - A `Result` containing the reader for the element at the given index, or an `Error` if the index is out of bounds or the data is invalid.
```

--------------------------------

### Get the underlying buffer

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

A convenience function to retrieve the underlying buffer. Using `shallow_copy` preserves the lifetime of the buffer.

```rust
pub fn buffer(&self) -> B
```

--------------------------------

### BuilderOptions Cloning and Debugging

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Methods for cloning BuilderOptions instances and formatting them for debugging.

```APIDOC
## Clone for BuilderOptions

### fn clone(&self) -> BuilderOptions

Returns a duplicate of the value.

### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`.

## Debug for BuilderOptions

### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.
```

--------------------------------

### Pushable Implementation for &[f64]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f64 slices to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Get an iterator for VectorReader

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorReader.html

Returns an iterator over the elements of the vector. This is useful for iterating through all elements without manual indexing.

```rust
pub fn iter(&self) -> ReaderIterator<B>
```

--------------------------------

### Create a default Builder

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Builder.html

Returns the default value for a Builder. This typically initializes an empty builder.

```rust
fn default() -> Self
```

--------------------------------

### Get Map Information

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Retrieves information about a map, including the address and width of its keys. This is a prerequisite for accessing map elements.

```rust
pub fn get_map(&self) -> Result<MapReader<B>, Error> {
        let (keys_offset_address, keys_width) = self.get_map_info()?;
        let keys_address = deref_offset(&self.buffer, keys_offset_address, self.width)?;
        // TODO(cneo): Check that vectors length equals keys length.
        Ok(MapReader {
            buffer: self.buffer.shallow_copy(),
            values_address: self.address,
            values_width: self.width,
            keys_address,
            keys_width,
            length: self.length(),
        })
    }
```

--------------------------------

### CloneToUninit Trait (Nightly Experimental)

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Allows cloning data to uninitialized memory. This is an experimental API and requires a nightly Rust toolchain.

```APIDOC
## impl<T> CloneToUninit for T

### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Get Blob Data

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/mod.rs.html

Returns a Blob containing the raw byte data. Errors if the type is not a Blob or if the index is out of bounds.

```rust
pub fn get_blob(&self) -> Result<Blob<B>, Error> {
        self.expect_type(FlexBufferType::Blob)?;
        Ok(Blob(
            self.buffer
                .slice(self.address..self.address + self.length())
                .ok_or(Error::IndexOutOfBounds)?,
        ))
    }
```

--------------------------------

### Get a key string

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Retrieves the string value up to the first null character (`\0`). This is typically used for map keys.

```rust
pub fn get_key(&self) -> Result<B::BufferString, Error>
```

--------------------------------

### Pushable Implementation for &[f32]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f32 slices to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f32]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### VectorReader Methods

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.VectorReader.html

Provides methods for interacting with VectorReader, including getting its length, checking if it's empty, and indexing into the vector.

```APIDOC
## VectorReader

Allows indexing on any flexbuffer vector type, (heterogenous vector, typed vector, or fixed length typed vector).
VectorReaders may be indexed with usize, `index` returns a result type which may indicate failure due to indexing out of bounds or bad data. `idx` returns a Null Reader in the event of any failure.

### `len()`

Returns the number of elements in the vector.

### `is_empty()`

Returns true if there are 0 elements in the vector.

### `idx(i: usize)`

Index into a flexbuffer vector. Any errors are defaulted to Null Readers.

### `index(i: usize)`

Index into a flexbuffer. Returns a `Result<Reader<B>, Error>`.
```

--------------------------------

### Required Method: empty

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Buffer.html

Creates an empty buffer instance. This method guarantees a zero-length buffer, distinct from the default behavior.

```APIDOC
#### fn empty() -> Self

Creates an empty instance of a `Buffer`. This is different than `Default` b/c it guarantees that the buffer instance will have length zero. Most impls shold be able to implement this via `Default`.
```

--------------------------------

### Get Map Size - len()

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapReader.html

Returns the number of key/value pairs in the map. Use this to determine the total elements before iteration.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### BitWidth Methods

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/bitwidth.rs.html

Provides utility methods for the BitWidth enum, including iterating over all possible widths, calculating the byte size for a given width, and converting from a byte count to a BitWidth.

```APIDOC
impl BitWidth {
    /// Returns an iterator over all possible `BitWidth` values.
    pub(crate) fn iter() -> Iter<'static, Self> {
        [W8, W16, W32, W64].iter()
    }

    /// Returns the number of bytes corresponding to the `BitWidth`.
    pub fn n_bytes(self) -> usize {
        1 << self as usize
    }

    /// Attempts to convert a number of bytes into a `BitWidth`.
    /// Returns `None` if the number of bytes is not a power of 2 or is not supported.
    pub fn from_nbytes(n: impl std::convert::Into<usize>) -> Option<Self> {
        match n.into() {
            1 => Some(W8),
            2 => Some(W16),
            4 => Some(W32),
            8 => Some(W64),
            _ => None,
        }
    }
}
```

--------------------------------

### Pushable Implementation for &[f64; 1]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f64 arrays of size 1 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64; 1]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Pushable Implementation for &[f64; 5]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f64 arrays of size 5 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64; 5]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Get a boolean value

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns the value of the reader if it is a boolean. Otherwise, returns an error. Use this to safely read boolean values.

```rust
pub fn get_bool(&self) -> Result<bool, Error>
```

--------------------------------

### Get Fixed-Length Vector Length

Source: https://docs.rs/flexbuffers/latest/flexbuffers/enum.FlexBufferType.html

Retrieves the number of elements in a fixed-length vector type. Returns None if the type is not a fixed-length vector.

```rust
pub fn fixed_length_vector_length(self) -> Option<usize>

```

--------------------------------

### Serialization and Deserialization Utilities

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/lib.rs.html

Provides functions to serialize Rust data structures into Flexbuffers format and deserialize them back. These functions leverage the `serde` crate for seamless integration.

```APIDOC
## `to_vec<T: Serialize>(x: T) -> Result<Vec<u8>, SerializationError>`

### Description
Serializes a given Rust value `T` that implements the `Serialize` trait into a `Vec<u8>` representing the Flexbuffer format.

### Parameters
- `x` (T): The value to serialize.

### Returns
- `Result<Vec<u8>, SerializationError>`: A `Result` containing the serialized byte vector on success, or a `SerializationError` on failure.

## `from_slice<'de, T: Deserialize<'de>>(buf: &'de [u8]) -> Result<T, DeserializationError>`

### Description
Deserializes a Rust value `T` that implements the `Deserialize` trait from a byte slice `buf` representing a Flexbuffer.

### Parameters
- `buf` (&'de [u8]): The byte slice containing the Flexbuffer data.

### Returns
- `Result<T, DeserializationError>`: A `Result` containing the deserialized value of type `T` on success, or a `DeserializationError` on failure.

## `from_buffer<'de, T: Deserialize<'de>, B: Buffer>(buf: &'de B) -> Result<T, DeserializationError>`

### Description
Deserializes a Rust value `T` that implements the `Deserialize` trait from a buffer `buf` that implements the `Buffer` trait.

### Parameters
- `buf` (&'de B): The buffer containing the Flexbuffer data.

### Returns
- `Result<T, DeserializationError>`: A `Result` containing the deserialized value of type `T` on success, or a `DeserializationError` on failure.
```

--------------------------------

### by_ref

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.ReaderIterator.html

Creates a "by reference" adapter for an iterator instance.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.
```

--------------------------------

### Get Keys as Vector - keys_vector()

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapReader.html

Returns a VectorReader containing all the keys present in the map. This allows for treating keys as a vector for further processing.

```rust
pub fn keys_vector(&self) -> VectorReader<B>
```

--------------------------------

### Build a Flexbuffer with a single value

Source: https://docs.rs/flexbuffers/latest/flexbuffers/fn.singleton.html

Use `singleton` to create a Flexbuffer with a single root value. This function takes a `Pushable` type and returns a `Vec<u8>` representing the Flexbuffer.

```rust
pub fn singleton<P: Pushable>(p: P) -> Vec<u8> ⓘ
```

--------------------------------

### Get Flexbuffer View

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Returns a byte slice view of the currently built flexbuffer. This allows inspecting the serialized data without consuming it.

```rust
pub fn view(&self) -> &[u8] {
        self.builder.view()
    }
```

--------------------------------

### Type Conversion Implementations for BitWidth

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/bitwidth.rs.html

Implements the `From` trait for various integer and floating-point types to convert them into the appropriate `BitWidth`. This allows Flexbuffers to automatically determine the smallest bit width needed to represent a given value.

```APIDOC
// TODO(cneo): Overloading with `from` is probably not the most readable idea in hindsight.
macro_rules! impl_bitwidth_from {
    ($from: ident, $w64: ident, $w32: ident, $w16: ident, $w8: ident) => {
        impl From<$from> for BitWidth {
            fn from(x: $from) -> BitWidth {
                let x = x as $w64;
                if x >= $w8::min_value() as $w64 && x <= $w8::max_value() as $w64 {
                    return W8;
                }
                if x >= $w16::min_value() as $w64 && x <= $w16::max_value() as $w64 {
                    return W16;
                }
                if x >= $w32::min_value() as $w64 && x <= $w32::max_value() as $w64 {
                    return W32;
                }
                W64
            }
        }
    };
}
impl_bitwidth_from!(u64, u64, u32, u16, u8);
impl_bitwidth_from!(usize, u64, u32, u16, u8);
impl_bitwidth_from!(i64, i64, i32, i16, i8);

#[allow(clippy::float_cmp)]
impl From<f64> for BitWidth {
    fn from(x: f64) -> BitWidth {
        if x != x as f32 as f64 {
            W64
        } else {
            W32
        }
    }
}
impl From<f32> for BitWidth {
    fn from(_: f32) -> BitWidth {
        W32
    }
}
```

--------------------------------

### Get Map Keys as Vector in FlexBuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/map.rs.html

Retrieves all keys from a FlexBuffers map as a VectorReader. This is used internally by `iter_keys` and for direct key access.

```rust
pub fn keys_vector(&self) -> VectorReader<B> {
        VectorReader {
            reader: Reader {
                buffer: self.buffer.shallow_copy(),
                fxb_type: crate::FlexBufferType::VectorKey,
                width: self.keys_width,
                address: self.keys_address,
            },
            length: self.length,
        }
    }
```

--------------------------------

### Getting the Address

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/value.rs.html

Retrieves the memory address stored within a `Value`. Returns `Some(address)` for `Reference` and `Key` types, and `None` for inline types.

```rust
pub fn get_address(&self) -> Option<usize> {
    if let Value::Reference { address, .. } | Value::Key(address) = self {
        Some(*address)
    } else {
        None
    }
}
```

--------------------------------

### BuilderOptions State Checks

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Methods for checking the state of BuilderOptions flags.

```APIDOC
## BuilderOptions State Checks

### `is_empty()`
Returns `true` if no flags are currently set in the `BuilderOptions`.

### `is_all()`
Returns `true` if all available flags are set in the `BuilderOptions`.
```

--------------------------------

### SerializeMap Implementation

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Implementation of `serde::ser::SerializeMap` for `FlexbufferSerializer` to handle map-like structures.

```APIDOC
## Trait Implementation: `serde::ser::SerializeMap` for `&mut FlexbufferSerializer`

### Description
This implementation enables `FlexbufferSerializer` to serialize map-like data structures. Flexbuffers maps are represented as alternating keys and values.

### Methods
* `serialize_key<T: ?Sized>(&mut self, key: &T)`: Serializes a key within the map. Keys are expected to be strings.
* `serialize_value<T: ?Sized>(&mut self, value: &T)`: Serializes a value associated with a key in the map.
* `end(self)`: Finalizes the serialization of the map. This corresponds to calling `end_map` internally.
```

--------------------------------

### Get a vector

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns a VectorReader for accessing vector data. Use this when you expect the Flexbuffer type to be a vector and want to handle potential errors.

```rust
pub fn get_vector(&self) -> Result<VectorReader<B>, Error>
```

--------------------------------

### Get a map

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Returns a MapReader for accessing map data. Use this when you expect the Flexbuffer type to be a map and want to handle potential errors.

```rust
pub fn get_map(&self) -> Result<MapReader<B>, Error>
```

--------------------------------

### EnumAccess Implementation for EnumReader

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/de.rs.html

Provides an implementation for serde::de::EnumAccess, enabling the deserialization of enum variants from flexbuffers.

```APIDOC
struct EnumReader<'de> {
    variant: &'de str,
    value: Option<Reader<&'de [u8]>>,
}

impl<'de> EnumAccess<'de> for EnumReader<'de> {
    type Error = DeserializationError;
    type Variant = Reader<&'de [u8]>;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
    where
        V: DeserializeSeed<'de>,
    {
        seed.deserialize(self.variant.into_deserializer())
            .map(|v| (v, self.value.unwrap_or_default()))
    }
}
```

--------------------------------

### BuilderOptions Formatting

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.BuilderOptions.html

Allows BuilderOptions to be formatted for display.

```APIDOC
## fn fmt(&self, f: &mut Formatter<'_>) -> Result

### Description
Formats the value using the given formatter.

### Method
`fmt` (from `UpperHex` trait)

### Parameters
- **&self**: `BuilderOptions` - A reference to the BuilderOptions to format.
- **f**: `&mut Formatter<'_>` - The formatter to use.

### Returns
- `Result` - The result of the formatting operation.
```

--------------------------------

### VectorReader len() and is_empty() Methods

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/reader/vector.rs.html

Get the number of elements in a vector or check if it's empty. These methods are efficient as they use a cached length.

```rust
/// Returns the number of elements in the vector.
pub fn len(&self) -> usize {
    self.length
}
/// Returns true if there are 0 elements in the vector.
pub fn is_empty(&self) -> bool {
    self.length == 0
}
```

--------------------------------

### Get Key Index - index_key()

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.MapReader.html

Returns the numerical index of a given string key within the map. Returns None if the key is not found.

```rust
pub fn index_key(&self, key: &str) -> Option<usize>
```

--------------------------------

### Pushable Implementation for &[f64; 2]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f64 arrays of size 2 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64; 2]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Pushable Implementation for &[f64; 0]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables empty f64 arrays to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64; 0]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Serialize Tuple Struct in Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/ser.rs.html

Initiates serialization for a tuple struct by starting a map. Returns the serializer itself to continue building the struct fields.

```rust
fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        self.start_map();
        Ok(self)
    }
```

--------------------------------

### Pushable Implementation for &[f32; 1]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f32 arrays of size 1 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f32; 1]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Get a string value

Source: https://docs.rs/flexbuffers/latest/flexbuffers/struct.Reader.html

Retrieves a string pointer from the Flexbuffer. Errors if the data is invalid UTF-8 or the index is out of bounds. Use this for reading string data.

```rust
pub fn get_str(&self) -> Result<B::BufferString, Error>
```

--------------------------------

### Pushable Implementation for &[f32; 5]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f32 arrays of size 5 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f32; 5]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Rust: Get Flexbuffer Map Key Iterator

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/map.rs.html

Provides an iterator over the bytes of a key in a Flexbuffer, stopping at the null terminator. Assumes valid UTF-8.

```rust
pub(super) fn get_key(buffer: &[u8], address: usize) -> impl Iterator<Item = &u8> {
    buffer[address..].iter().take_while(|&&b| b != b'\0')
}
```

--------------------------------

### Pushable Implementation for &[f64; 3]

Source: https://docs.rs/flexbuffers/latest/flexbuffers/trait.Pushable.html

Enables f64 arrays of size 3 to be pushed into a Flexbuffer.

```rust
impl Pushable for &[f64; 3]
Source§
#### fn push_to_builder(self, builder: &mut Builder)
```

--------------------------------

### Builder Struct for Flexbuffers

Source: https://docs.rs/flexbuffers/latest/src/flexbuffers/builder/mod.rs.html

The main struct used to build a Flexbuffer. It manages the internal buffer and values, and provides methods to start vectors or maps.

```rust
/// **Use this struct to build a Flexbuffer.**
///
/// Flexbuffers may only have a single root value, which may be constructed
/// with  one of the following functions.
/// * `build_singleton` will push 1 value to the buffer and serialize it as the root.
/// * `start_vector` returns a `VectorBuilder`, into which many (potentially
/// heterogenous) values can be pushed. The vector itself is the root and is serialized
/// when the `VectorBuilder` is dropped (or `end` is called).
/// * `start_map` returns a `MapBuilder`, which is similar to a `VectorBuilder` except
/// every value must be pushed with an associated key. The map is serialized when the
/// `MapBuilder` is dropped (or `end` is called).
///
/// These functions reset and overwrite the Builder which means, while there are no
/// active `MapBuilder` or `VectorBuilder`, the internal buffer is empty or contains a
/// finished Flexbuffer. The internal buffer is accessed with `view`.
#[derive(Debug, Clone)]
pub struct Builder {
    buffer: Vec<u8>,
    values: Vec<Value>,
    key_pool: Option<Vec<CachedKey>>,
}
impl Default for Builder {
```
Tokens:
Raw