Struct Map 

pub struct Map { /* private fields */ }

A map that keeps keys in insertion order.

Entries are stored once, as a flat list of pairs. Insertion order is intrinsic to that list. Predicate paths enumerate keys in this order. Equality ignores order, so two maps with the same pairs are equal whatever the order. The maps this library edits are small, so linear lookup is fine and matches how the engine clones whole maps along the path.

Implementations

impl Map

pub fn new() -> Self

Create an empty map.

pub fn is_empty(&self) -> bool

Whether the map has no keys.

pub fn contains_key(&self, key: &str) -> bool

Whether key is present.

pub fn get(&self, key: &str) -> Option<&Value>

Read the value at key.

pub fn insert(&mut self, key: String, value: Value)

Insert or replace key. A new key is appended in insertion order. An existing key keeps its position.

pub fn remove(&mut self, key: &str)

Remove key and its value, keeping the order of the rest.

pub fn iter(&self) -> impl Iterator<Item = (&String, &Value)>

Iterate keys and values in insertion order.

Trait Implementations

impl Clone for Map

fn clone(&self) -> Map

Returns a duplicate 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

Formats the value using the given formatter.

impl Default for Map

fn default() -> Map

Returns the “default value” for a type.

impl From<Map> for Value

fn from(map: Map) -> Value

Converts to this type from the input type.

impl FromIterator<(String, Value)> for Map

fn from_iter<I: IntoIterator<Item = (String, Value)>>(iter: I) -> Self

Creates a value from an iterator.

impl IntoIterator for Map

type Item = (String, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter<(String, Value)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Map

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

Two maps are equal when they hold the same keys and values. Order is ignored, matching deep value equality.

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

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