Struct conrod_core::image::Map

pub struct Map<Img> {
    pub trigger_redraw: Cell<bool>,
    // some fields omitted
}

A type used to map the widget::Id of Image widgets to their associated Img data.

The image::Map type is usually instantiated and loaded during the "setup" stage of the application before the main loop begins.

Fields

trigger_redraw: Cell<bool>

Whether or not the image::Map will trigger a redraw the next time Ui::draw is called.

This is automatically set to true when any method that takes &mut self is called.

Methods

impl<Img> Map<Img>

pub fn new() -> Self

Construct a new, empty image::Map.

pub fn get_mut(&mut self, id: Id) -> Option<&mut Img>

Uniquely borrow the Img associated with the given widget.

Note: Calling this will trigger a redraw the next time Ui::draw_if_changed is called.

pub fn insert(&mut self, img: Img) -> Id

Inserts the given image into the map, returning its associated image::Id. The user must store the returned image::Id in order to use, modify or remove the inserted image.

Note: Calling this will trigger a redraw the next time Ui::draw_if_changed is called.

pub fn replace(&mut self, id: Id, img: Img) -> Option<Img>

Replaces the given image in the map if it exists. Returns the image or None.

Note: Calling this will trigger a redraw the next time Ui::draw_if_changed is called.

pub fn remove(&mut self, id: Id) -> Option<Img>

Removes the given image from the map if it exists. Returns the image or None.

Any future use of the given image::Id will be invalid.

Note: Calling this will trigger a redraw the next time Ui::draw_if_changed is called.

Important traits for NewIds

impl Iterator for NewIds type Item = Id;

pub fn extend<I>(&mut self, images: I) -> NewIds where
    I: IntoIterator<Item = Img>, 

Insert each of the images yielded by the given iterator and produce an iterator yielding their generated Ids in the same order.

Note: Calling this will trigger a redraw the next time Ui::draw_if_changed is called.

Methods from Deref<Target = HashMap<Img>>

pub fn capacity(&self) -> usize

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

This number is a lower bound; the HashMap<K, V> might be able to hold more, but is guaranteed to be able to hold at least this many.

Examples

use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);

pub fn keys(&self) -> Keys<K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for key in map.keys() {
    println!("{}", key);
}

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

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for val in map.values() {
    println!("{}", val);
}

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

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for (key, val) in map.iter() {
    println!("key: {} val: {}", key, val);
}

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use std::collections::HashMap;

let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn hasher(&self) -> &S

Returns a reference to the map's BuildHasher.

Examples

use std::collections::HashMap;
use std::collections::hash_map::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();

pub fn get<Q>(&self, k: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);

pub fn contains_key<Q>(&self, k: &Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

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

The key may be any borrowed form of the map's key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

pub fn raw_entry(&self) -> RawEntryBuilder<K, V, S>

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

Creates a raw immutable entry builder for the HashMap.

Raw entries provide the lowest level of control for searching and manipulating a map. They must be manually initialized with a hash and then manually searched.

This is useful for

• Hash memoization
• Using a search key that doesn't work with the Borrow trait
• Using custom comparison logic without newtype wrappers

Unless you are in such a situation, higher-level and more foolproof APIs like get should be preferred.

Immutable raw entries have very limited use; you might instead want raw_entry_mut.

Trait Implementations

impl<Img> Deref for Map<Img>

type Target = HashMap<Img>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.