Struct HashConstraintMap 

pub struct HashConstraintMap<Pos, Ter, Pat> { /* private fields */ }

A pattern source that is stored in a hash map.

Implementations

impl<Pos, Ter, Pat> HashConstraintMap<Pos, Ter, Pat>

where Pos: Hash + Eq + OffsetPosition, Ter: Clone, Pat: Clone,

pub fn fill_from<T, P>(&mut self, terrains: &T, patterns: &P)

where T: TerrainSource<Position = Pos, Terrain = Ter>, P: PatternSource<Position = Pos, Terrain = Ter, Pattern = Pat>,

Replace the content of this map using the given PatternSource and TerrainSource. The TerrainSource specifies certain cells that need to be given tiles by specifying the required terrain for those tiles. The terrains and patterns for the surrounding cells are taken from the PatternSource.

The immediately adjacent cells are added to the front of the list of cells to be assigned tiles and their terrain is taken from the PatternSource. The cells that are one further away are make immutable by constraining them to be exactly their current pattern from PatternSource.

impl<Pos, Ter, Pat> HashConstraintMap<Pos, Ter, Pat>

where Pos: Hash + Eq + Clone,

pub fn clear(&mut self)

Makes this map empty, so all cells have TileConstraint::None.

pub fn insert(&mut self, pos: Pos, constraint: TileConstraint<Ter, Pat>)

Add the given constraint to this map.

pub fn get(&self, pos: &Pos) -> &TileConstraint<Ter, Pat>

Get the constraint for the given position.

pub fn all_positions(&self) -> impl Iterator<Item = &Pos>

Iterate over all the terrain cells that are to be tiled in the order that they should be tiled.

Methods from Deref<Target = HashMap<Pos, TileConstraint<Ter, Pat>, BuildHasherDefault<FxHasher>>>

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 map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

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

Performance

In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

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 map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

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

Performance

In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

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 map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

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

Performance

In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.

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::hash::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. This is potentially useful:

• for key types where non-identical keys can be considered equal;
• for getting the &K stored key value from a borrowed &Q lookup key; or
• for getting a reference to a key with the same lifetime as the collection.

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;
use std::hash::{Hash, Hasher};

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and hashing operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl Hash for S {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = HashMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), 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);

Trait Implementations

impl<Pos, Ter, Pat> Clone for HashConstraintMap<Pos, Ter, Pat>

where Pos: Clone, Ter: Clone, Pat: Clone,

fn clone(&self) -> HashConstraintMap<Pos, Ter, Pat>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Ter, Pat> Debug for HashConstraintMap<Matrix<i32, Const<2>, Const<1>, ArrayStorage<i32, 2, 1>>, Ter, Pat>

where Ter: Debug, Pat: Debug,

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

Formats the value using the given formatter.

impl<Pos, Ter, Pat> Default for HashConstraintMap<Pos, Ter, Pat>

fn default() -> HashConstraintMap<Pos, Ter, Pat>

Returns the “default value” for a type.

impl<Pos, Ter, Pat> Deref for HashConstraintMap<Pos, Ter, Pat>

type Target = HashMap<Pos, TileConstraint<Ter, Pat>, BuildHasherDefault<FxHasher>>

The resulting type after dereferencing.

fn deref(&self) -> &<HashConstraintMap<Pos, Ter, Pat> as Deref>::Target

Dereferences the value.