Struct LinksTable 

pub struct LinksTable(pub EnumMap<LinkKind, Option<String>>);

Tuple Fields

0: EnumMap<LinkKind, Option<String>>

Methods from Deref<Target = EnumMap<LinkKind, Option<String>>>

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

An iterator visiting all values. The iterator type is &V.

Examples

use enum_map::enum_map;

let map = enum_map! { false => 3, true => 4 };
let mut values = map.values();
assert_eq!(values.next(), Some(&3));
assert_eq!(values.next(), Some(&4));
assert_eq!(values.next(), None);

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

An iterator visiting all values mutably. The iterator type is &mut V.

Examples

use enum_map::enum_map;

let mut map = enum_map! { _ => 2 };
for value in map.values_mut() {
    *value += 2;
}
assert_eq!(map[false], 4);
assert_eq!(map[true], 4);

pub fn clear(&mut self)

Clear enum map with default values.

Examples

use enum_map::{Enum, EnumMap};

#[derive(Enum)]
enum Example {
    A,
    B,
}

let mut enum_map = EnumMap::<_, String>::default();
enum_map[Example::B] = "foo".into();
enum_map.clear();
assert_eq!(enum_map[Example::A], "");
assert_eq!(enum_map[Example::B], "");

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

Returns an iterator over enum map.

The iteration order is deterministic, and when using Enum derive it will be the order in which enum variants are declared.

Examples

use enum_map::{enum_map, Enum};

#[derive(Enum, PartialEq)]
enum E {
    A,
    B,
    C,
}

let map = enum_map! { E::A => 1, E::B => 2, E::C => 3};
assert!(map.iter().eq([(E::A, &1), (E::B, &2), (E::C, &3)]));

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

Returns a mutable iterator over enum map.

pub fn len(&self) -> usize

Returns number of elements in enum map.

pub fn swap(&mut self, a: K, b: K)

Swaps two indexes.

Examples

use enum_map::enum_map;

let mut map = enum_map! { false => 0, true => 1 };
map.swap(false, true);
assert_eq!(map[false], 1);
assert_eq!(map[true], 0);

pub fn as_array(&self) -> &<K as EnumArray<V>>::Array

Returns a reference to the underlying array.

The order of elements is deterministic, and when using Enum derive it will be the order in which enum variants are declared.

Examples

use enum_map::{enum_map, Enum};

#[derive(Enum, PartialEq)]
enum E {
    A,
    B,
    C,
}

let map = enum_map! { E::A => 1, E::B => 2, E::C => 3};
assert_eq!(map.as_array(), &[1, 2, 3]);

pub fn as_mut_array(&mut self) -> &mut <K as EnumArray<V>>::Array

Returns a mutable reference to the underlying array.

The order of elements is deterministic, and when using Enum derive it will be the order in which enum variants are declared.

Examples

use enum_map::{enum_map, Enum};

#[derive(Enum, PartialEq)]
enum E {
    A,
    B,
    C,
}

let mut map = enum_map! { E::A => 1, E::B => 2, E::C => 3};
map.as_mut_array()[1] = 42;
assert_eq!(map.as_array(), &[1, 42, 3]);

pub fn as_slice(&self) -> &[V]

Converts an enum map to a slice representing values.

The order of elements is deterministic, and when using Enum derive it will be the order in which enum variants are declared.

Examples

use enum_map::{enum_map, Enum};

#[derive(Enum, PartialEq)]
enum E {
    A,
    B,
    C,
}

let map = enum_map! { E::A => 1, E::B => 2, E::C => 3};
assert_eq!(map.as_slice(), &[1, 2, 3]);

pub fn as_mut_slice(&mut self) -> &mut [V]

Converts a mutable enum map to a mutable slice representing values.

Trait Implementations

impl Clone for LinksTable

fn clone(&self) -> LinksTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinksTable

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

Formats the value using the given formatter.

impl Default for LinksTable

fn default() -> LinksTable

Returns the “default value” for a type.

impl Deref for LinksTable

type Target = EnumMap<LinkKind, Option<String>>

The resulting type after dereferencing.

fn deref(&self) -> &<LinksTable as Deref>::Target

Dereferences the value.

impl DerefMut for LinksTable

fn deref_mut(&mut self) -> &mut <LinksTable as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for LinksTable

fn deserialize<__D>( __deserializer: __D, ) -> Result<LinksTable, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&LinksTable> for Html

fn from(links: &LinksTable) -> Html

Converts to this type from the input type.

impl Serialize for LinksTable

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.