Struct serde_yml::mapping::Mapping

pub struct Mapping {
    pub map: IndexMap<Value, Value>,
}

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

Fields

map: IndexMap<Value, Value>

The underlying map.

Implementations

impl Mapping

pub fn new() -> Self

Creates an empty YAML mapping.

pub fn with_capacity(capacity: usize) -> Self

Creates an empty YAML mapping with the given initial capacity.

The mapping will be able to hold at least capacity elements without reallocating. If capacity is 0, the mapping will not allocate.

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

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

Panics

Panics if the new allocation size overflows usize.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the mapping 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 mapping.

If the mapping did not have this key present, None is returned.

If the mapping did have this key present, the value is updated, and the old value is returned.

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

Returns true if the mapping contains a value for the specified key.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

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

Returns a mutable reference to the value corresponding to the key.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

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

Gets the given key’s corresponding entry in the mapping for in-place manipulation.

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

Removes a key from the mapping, returning the value at the key if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

This is equivalent to calling swap_remove and ignores the order of the elements.

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

Removes a key from the mapping, returning the stored key and value if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

This is equivalent to calling swap_remove_entry and ignores the order of the elements.

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

Removes a key from the mapping, returning the value at the key if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

The element is removed by swapping it with the last element of the mapping and popping it off. This perturbs the position of the last element.

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

Removes a key from the mapping, returning the stored key and value if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

The element is removed by swapping it with the last element of the mapping and popping it off. This perturbs the position of the last element.

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

Removes a key from the mapping, returning the value at the key if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

The element 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)>

Removes a key from the mapping, returning the stored key and value if the key was previously in the mapping.

The key may be any borrowed form of the mapping’s key type, but the ordering on the borrowed form must match the key type’s ordering.

The element 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,

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(&k, &mut v) returns false.

pub fn capacity(&self) -> usize

Returns the number of elements the mapping can hold without reallocating.

pub fn len(&self) -> usize

Returns the number of elements in the mapping.

pub fn is_empty(&self) -> bool

Returns true if the mapping contains no elements.

pub fn clear(&mut self)

Clears the mapping, removing all key-value pairs.

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

Returns an iterator over the key-value pairs of the mapping, in their order.

The iterator element type is (&'a Value, &'a Value).

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

Returns a mutable iterator over the key-value pairs of the mapping, in their order.

The iterator element type is (&'a Value, &'a mut Value).

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

Returns an iterator over the keys of the mapping, in their order.

The iterator element type is &'a Value.

pub fn into_keys(self) -> IntoKeys

Returns an owning iterator over the keys of the mapping, in their order.

The iterator element type is Value.

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

Returns an iterator over the values of the mapping, in their order.

The iterator element type is &'a Value.

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

Returns a mutable iterator over the values of the mapping, in their order.

The iterator element type is &'a mut Value.

pub fn into_values(self) -> IntoValues

Returns an owning iterator over the values of the mapping, in their order.

The iterator element type is Value.

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

Implements the Debug trait for Mapping. This allows for customized formatting when debugging Mapping instances.

Examples

use serde_yml::{Mapping, Value};

let mut mapping = Mapping::new();
mapping.insert(Value::String("name".to_string()), Value::String("John".to_string()));
mapping.insert(Value::String("age".to_string()), Value::Number(30.into()));
println!("{:?}", mapping);
// Output: Mapping {"name": String("John"), "age": Number(30)}

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

Mapping implements Deserialize using the serde crate.

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_yml::{Mapping, Value};

let mut m = Mapping::new();
m.insert("Lorem".into(), "ipsum".into());
let x: Value = m.into();
assert_eq!(x, Value::Mapping(Mapping::from_iter(vec![("Lorem".into(), "ipsum".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

Mapping is hashable if its keys and values are hashable.

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,

Mapping is ordered if its keys and values are ordered.

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,

Mapping is ordered if its keys and values are ordered.

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

Mapping is ordered if its keys and values are ordered.

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

Mapping implements Serialize using the serde crate.

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