Enum bonsaidb_core::schema::view::map::Mappings

pub enum Mappings<K: for<'a> Key<'a> = (), V = ()> {
    Simple(Option<Map<K, V>>),
    List(Vec<Map<K, V>>),
}

A collection of Maps.

Variants

Simple(Option<Map<K, V>>)

Zero or one mappings.

List(Vec<Map<K, V>>)

More than one mapping.

Implementations

impl<K: for<'a> Key<'a>, V> Mappings<K, V>

pub fn none() -> Self

Returns an empty collection of mappings.

pub fn push(&mut self, mapping: Map<K, V>)

Appends mapping to the end of this collection.

pub fn and(self, mappings: Self) -> Self

Appends mappings to the end of this collection and returns self.

Trait Implementations

impl<K: Debug + for<'a> Key<'a>, V: Debug> Debug for Mappings<K, V>

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

Formats the value using the given formatter.

impl<K: for<'a> Key<'a>, V> Default for Mappings<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: for<'a> Key<'a>, V> Extend<Map<K, V>> for Mappings<K, V>

fn extend<T: IntoIterator<Item = Map<K, V>>>(&mut self, iter: T)

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<K: for<'a> Key<'a>, V> FromIterator<Map<K, V>> for Mappings<K, V>

fn from_iter<T: IntoIterator<Item = Map<K, V>>>(iter: T) -> Self

Creates a value from an iterator.

impl<K: for<'a> Key<'a>, V> FromIterator<Mappings<K, V>> for Mappings<K, V>

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

Creates a value from an iterator.

impl<K: for<'a> Key<'a>, V> IntoIterator for Mappings<K, V>

type Item = Map<K, V>

The type of the elements being iterated over.

type IntoIter = MappingsIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq + for<'a> Key<'a>, V: PartialEq> PartialEq<Mappings<K, V>> for Mappings<K, V>

fn eq(&self, other: &Mappings<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Mappings<K, V>) -> bool

This method tests for !=.

impl<K: for<'a> Key<'a>, V> StructuralPartialEq for Mappings<K, V>