Struct HashVec 

pub struct HashVec<K: Eq + Hash, V> { /* private fields */ }

Implementations

impl<K: Eq + Hash, V> HashVec<K, V>

pub fn new() -> HashVec<K, V>

Creates a new, empty map.

pub fn with_capacity(capacity: usize) -> HashVec<K, V>

Creates a new, empty hashvec with the specified capacity.

pub fn from_vec(v: Vec<(K, V)>) -> HashVec<K, V>

Creates a hashvec from a vector of key-value pairs.

Internally, this uses HashVec::append_vec(), which means that redundant keys’ entries will be overwritten and moved to the end of the hashvec sequentially.

pub fn capacity(&self) -> usize

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

pub fn len(&self) -> usize

Returns the number of elements in the hashvec.

Examples found in repository

examples/animals.rs (line 40)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn is_empty(&self) -> bool

Returns true if the hashvec contains no elements.

pub fn clear(&mut self)

Clears the hashvec, removing all entries.

Keep in mind this will not reallocate memory.

Examples found in repository

examples/animals.rs (line 80)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn insert(&mut self, k: K, v: V)

Inserts an entry into the hashvec, or replaces an existing one.

Examples found in repository

examples/animals.rs (line 17)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn push(&mut self, entry: (K, V))

Appends an entry to the back of the hashvec.

If an entry with an identical key was already in the hashvec, it is removed before the new entry is inserted.

Panics

Panics if the new capacity either overflows usize or exceeds isize::MAX bytes.

Examples found in repository

examples/animals.rs (line 21)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn pop(&mut self) -> Option<(K, V)>

Removes the last entry from the hashvec and returns it (or None if the hashvec is empty).

Examples found in repository

examples/animals.rs (line 76)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn append(&mut self, other: &mut HashVec<K, V>)

Appends all entries of other into Self, leaving other empty.

Panics

Panics if the number of elements in the hashvec either overflows usize or exceeds isize::MAX bytes

Examples found in repository

examples/append.rs (line 13)

fn main() {
    use hashvec::*;

    let mut a: HashVec<&'static str, &'static str> = hashvec![
        ("Frank", "Dog"),
        ("Jimmy", "Pig")
    ];

    let mut b: HashVec<&'static str, &'static str> = hashvec![
        ("Mack", "Cat")
    ];

    a.append(&mut b);

    println!("{:#?}", a);
    println!("{:#?}", b);
}

pub fn append_vec(&mut self, v: Vec<(K, V)>)

Appends a vector of key-value pairs onto the hashvec.

Internally, this uses HashVec::push(), which means that redundant keys’ entries will be overwritten and moved to the end of the hashvec sequentially.

pub fn swap_keys(&mut self, key_a: &K, key_b: &K)

Swaps the location of the provided keys’ entries

If either one of the keys is not already in the hashvec, this is a no-op.

Examples found in repository

examples/animals.rs (line 61)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn swap_indices(&mut self, index_a: usize, index_b: usize)

Swaps the location of the entries at the provided indices

If either one of the indices exceeds the current length of the hashvec, this is a no-op.

Examples found in repository

examples/animals.rs (line 66)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn contains_key(&self, k: &K) -> bool

Returns true if the hashvec contains an entry corresponding to the provided key.

pub fn get(&self, k: &K) -> Option<&V>

Returns a reference to the value corresponding to the key, if it exists.

Examples found in repository

examples/animals.rs (line 24)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn get_mut(&mut self, k: &K) -> Option<&mut V>

Returns a mutable reference to the value corresponding to the key, if it exists.

Examples found in repository

examples/animals.rs (line 48)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn rename(&mut self, old_key: &K, new_key: K) -> Option<&V>

Changes an entry’s key, preserving and returning a reference to the associated value.

If the hashvec did not have an entry corresponding to the old key, None is returned.

Examples found in repository

examples/animals.rs (line 44)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn remove_key_entry(&mut self, k: &K) -> Option<(K, V)>

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

pub fn index(&self, k: &K) -> Option<usize>

Returns the index of the provided key, if the key exists.

Examples found in repository

examples/animals.rs (line 36)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

pub fn remove_key(&mut self, k: &K) -> Option<V>

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

Examples found in repository

examples/animals.rs (line 57)

fn main() {
    use hashvec::*;

    // Create a new hashvec containing pairs of animal names and species
    // The hashvec! macro acts like vec!, but with key-value tuple pairs
    let mut hashvec: HashVec<&'static str, &'static str> = hashvec![
        ("Doug", "Kobold"),
        ("Skye", "Hyena"),
        ("Lee", "Shiba"),
        ("Sock", "Man"),
        ("Salad", "Wolf"),
        ("Finn", "Human")
    ];

    // Insert a value into the hashvec (HashMap-style)
    // Inserting overwrites existing keys' entries in-place
    hashvec.insert("Jake", "Dog");

    // Push a value onto the hashvec (Vector-style)
    // Pushing overwrites existing keys' entries and moves them to the end
    hashvec.push(("Susie", "Squid"));

    // Access a value by key
    match hashvec.get(&"Finn") {
        Some(value) => {
            assert_eq!(*value, "Human");
        },
        None => {}
    }
    
    // Access an entry by index
    let lee_value = hashvec[2];
    assert_eq!(lee_value, ("Lee", "Shiba"));
    
    // Get the index of a key
    let lee_index = hashvec.index(&"Lee").unwrap();
    assert_eq!(lee_index, 2);

    // Get the length of the hashvec
    let hashvec_length = hashvec.len();
    assert_eq!(hashvec_length, 8);
    
    // Change an entry's key in-place
    hashvec.rename(&"Salad", "Caesar");
    assert_eq!(hashvec[4], ("Caesar", "Wolf"));

    // Mutate a value
    match hashvec.get_mut(&"Sock") {
        Some(value) => {
            *value = "Guinea Pig";
        },
        None => {}
    }
    assert_eq!(*hashvec.get(&"Sock").unwrap(), "Guinea Pig");

    // Remove an entry
    hashvec.remove_key(&"Doug");
    assert_eq!(hashvec.get(&"Doug"), None);

    // Swap the locations of two entries by their keys
    hashvec.swap_keys(&"Lee", &"Skye");
    assert_eq!(hashvec.index(&"Lee").unwrap(), 0);
    assert_eq!(hashvec.index(&"Skye").unwrap(), 1);

    // Now swap them again, by their indices
    hashvec.swap_indices(0, 1);
    assert_eq!(hashvec[0], ("Skye", "Hyena"));
    assert_eq!(hashvec[1], ("Lee", "Shiba"));
    
    // Iterate over each of the key-value pairs in the hashvec
    for (k, v) in hashvec.into_iter() {
        println!("{} is a {}!", k, v);
    }

    // Remove an entry from the end of the hashvec
    let last_entry = hashvec.pop();
    assert_eq!(last_entry.unwrap(), ("Susie", "Squid"));

    // Clear the hashvec
    hashvec.clear();
}

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

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

Panics

Panics if the new capacity either overflows usize or exceeds isize::MAX bytes.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the hashvec with a lower limit.

The capacity will remain at least as large as both the length and the supplied value.

If the current capacity is less than the lower limit, this is a no-op.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the hashvec as much as possible, according to internal rules.

Trait Implementations

impl<K: Debug + Eq + Hash, V: Debug> Debug for HashVec<K, V>

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V> Index<usize> for HashVec<K, V>

type Output = (K, V)

The returned type after indexing.

fn index(&self, i: usize) -> &(K, V)

Performs the indexing (container[index]) operation.

impl<'a, K: Eq + Hash, V> IntoIterator for &'a HashVec<K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = HashVecIter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.