Struct Map

pub struct Map<'a> {
    pub _tab: Table<'a>,
}

A Map is a logical nested type that is represented as

List<entries: Struct<key: K, value: V>>

In this layout, the keys and values are each respectively contiguous. We do not constrain the key and value types, so the application is responsible for ensuring that the keys are hashable and unique. Whether the keys are sorted may be set in the metadata for this field.

In a field with Map type, the field has a child Struct field, which then has two children: key type and the second the value type. The names of the child fields may be respectively “entries”, “key”, and “value”, but this is not enforced.

Map

  - child[0] entries: Struct
    - child[0] key: K
    - child[1] value: V

Neither the “entries” field nor the “key” field may be nullable.

The metadata is structured so that Arrow systems without special handling for Map can make Map an alias for List. The “layout” attribute for the Map field must have the same contents as a List.

Fields

_tab: Table<'a>

Implementations

impl<'a> Map<'a>

pub const VT_KEYSSORTED: u16 = 4u16

pub unsafe fn init_from_table(table: Table<'a>) -> Map<'a>

pub fn create<'bldr, 'args, 'mut_bldr, A>( _fbb: &'mut_bldr mut FlatBufferBuilder<'bldr, A>, args: &'args MapArgs, ) -> WIPOffset<Map<'bldr>>

where 'bldr: 'args, 'args: 'mut_bldr, A: Allocator + 'bldr,

pub fn keysSorted(&self) -> bool

Set to true if the keys within each value are sorted

Trait Implementations

impl<'a> Clone for Map<'a>

fn clone(&self) -> Map<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Map<'_>

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

Formats the value using the given formatter.

impl<'a> Follow<'a> for Map<'a>

type Inner = Map<'a>

unsafe fn follow(buf: &'a [u8], loc: usize) -> <Map<'a> as Follow<'a>>::Inner

Safety

impl<'a> PartialEq for Map<'a>

fn eq(&self, other: &Map<'a>) -> bool

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Verifiable for Map<'_>

fn run_verifier( v: &mut Verifier<'_, '_>, pos: usize, ) -> Result<(), InvalidFlatbuffer>

Runs the verifier for this type, assuming its at position pos in the verifier’s buffer. Should not need to be called directly.

impl<'a> Copy for Map<'a>

impl<'a> StructuralPartialEq for Map<'a>