Struct serde_yaml::value::Mapping

pub struct Mapping { /* private fields */ }

A YAML mapping in which the keys and values are both serde_yaml::Value.

Implementations

impl Mapping

pub fn new() -> Self

Creates an empty YAML map.

pub fn with_capacity(capacity: usize) -> Self

Creates an empty YAML map with the given initial capacity.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted into the map. The map may reserve more space to avoid frequent allocations.

Panics

Panics if the new allocation size overflows usize.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

pub fn insert(&mut self, k: Value, v: Value) -> Option<Value>

Inserts a key-value pair into the map. If the key already existed, the old value is returned.

pub fn contains_key<I: Index>(&self, index: I) -> bool

Checks if the map contains the given key.

pub fn get<I: Index>(&self, index: I) -> Option<&Value>

Returns the value corresponding to the key in the map.

pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value>

Returns the mutable reference corresponding to the key in the map.

pub fn entry(&mut self, k: Value) -> Entry<'_>

Gets the given key’s corresponding entry in the map for insertion and/or in-place manipulation.

pub fn remove<I: Index>(&mut self, index: I) -> Option<Value>

Removes and returns the value corresponding to the key from the map.

This is equivalent to .swap_remove(index), replacing this entry’s position with the last element. If you need to preserve the relative order of the keys in the map, use .shift_remove(key) instead.

pub fn remove_entry<I: Index>(&mut self, index: I) -> Option<(Value, Value)>

Remove and return the key-value pair.

This is equivalent to .swap_remove_entry(index), replacing this entry’s position with the last element. If you need to preserve the relative order of the keys in the map, use .shift_remove_entry(key) instead.

pub fn swap_remove<I: Index>(&mut self, index: I) -> Option<Value>

Removes and returns the value corresponding to the key from the map.

Like Vec::swap_remove, the entry is removed by swapping it with the last element of the map and popping it off. This perturbs the position of what used to be the last element!

pub fn swap_remove_entry<I: Index>( &mut self, index: I, ) -> Option<(Value, Value)>

Remove and return the key-value pair.

Like Vec::swap_remove, the entry is removed by swapping it with the last element of the map and popping it off. This perturbs the position of what used to be the last element!

pub fn shift_remove<I: Index>(&mut self, index: I) -> Option<Value>

Removes and returns the value corresponding to the key from the map.

Like Vec::remove, the entry is removed by shifting all of the elements that follow it, preserving their relative order. This perturbs the index of all of those elements!

pub fn shift_remove_entry<I: Index>( &mut self, index: I, ) -> Option<(Value, Value)>

Remove and return the key-value pair.

Like Vec::remove, the entry is removed by shifting all of the elements that follow it, preserving their relative order. This perturbs the index of all of those elements!

pub fn retain<F>(&mut self, keep: F)

where F: FnMut(&Value, &mut Value) -> bool,

Scan through each key-value pair in the map and keep those where the closure keep returns true.

pub fn capacity(&self) -> usize

Returns the maximum number of key-value pairs the map can hold without reallocating.

pub fn len(&self) -> usize

Returns the number of key-value pairs in the map.

pub fn is_empty(&self) -> bool

Returns whether the map is currently empty.

pub fn clear(&mut self)

Clears the map of all key-value pairs.

pub fn iter(&self) -> Iter<'_>

Returns a double-ended iterator visiting all key-value pairs in order of insertion. Iterator element type is (&'a Value, &'a Value).

pub fn iter_mut(&mut self) -> IterMut<'_>

Returns a double-ended iterator visiting all key-value pairs in order of insertion. Iterator element type is (&'a Value, &'a mut ValuE).

pub fn keys(&self) -> Keys<'_>

Return an iterator over the keys of the map.

pub fn into_keys(self) -> IntoKeys

Return an owning iterator over the keys of the map.

pub fn values(&self) -> Values<'_>

Return an iterator over the values of the map.

pub fn values_mut(&mut self) -> ValuesMut<'_>

Return an iterator over mutable references to the values of the map.

pub fn into_values(self) -> IntoValues

Return an owning iterator over the values of the map.

Trait Implementations

impl Clone for Mapping

fn clone(&self) -> Mapping

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mapping

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

Formats the value using the given formatter.

impl Default for Mapping

fn default() -> Mapping

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Mapping

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<(Value, Value)> for Mapping

fn extend<I: IntoIterator<Item = (Value, Value)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

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

impl From<Mapping> for Value

fn from(f: Mapping) -> Self

Convert map (with string keys) to Value

Examples

use serde_yaml::{Mapping, Value};

let mut m = Mapping::new();
m.insert("Lorem".into(), "ipsum".into());
let x: Value = m.into();

impl FromIterator<(Value, Value)> for Mapping

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

Creates a value from an iterator.

impl Hash for Mapping

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.

impl<I> Index<I> for Mapping

where I: Index,

type Output = Value

The returned type after indexing.

fn index(&self, index: I) -> &Value

Performs the indexing (container[index]) operation.

impl<I> IndexMut<I> for Mapping

where I: Index,

fn index_mut(&mut self, index: I) -> &mut Value

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Mapping

type Item = (&'a Value, &'a Value)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Mapping

type Item = (&'a Value, &'a mut Value)

The type of the elements being iterated over.

type IntoIter = IterMut<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Mapping

type Item = (Value, Value)

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Mapping

fn eq(&self, other: &Mapping) -> 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 PartialOrd for Mapping

fn partial_cmp(&self, other: &Self) -> 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.

impl Serialize for Mapping

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Mapping

impl StructuralPartialEq for Mapping