Struct bevy::utils::hashbrown::hash_map::RawOccupiedEntryMut

pub struct RawOccupiedEntryMut<'a, K, V, S, A = Global>where
    A: Allocator + Clone,{ /* private fields */ }

Expand description

A view into an occupied entry in a HashMap. It is part of the RawEntryMut enum.

Examples

use core::hash::{BuildHasher, Hash};
use hashbrown::hash_map::{HashMap, RawEntryMut, RawOccupiedEntryMut};

let mut map = HashMap::new();
map.extend([("a", 10), ("b", 20), ("c", 30)]);

fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
    use core::hash::Hasher;
    let mut state = hash_builder.build_hasher();
    key.hash(&mut state);
    state.finish()
}

let _raw_o: RawOccupiedEntryMut<_, _, _> = map.raw_entry_mut().from_key(&"a").insert("a", 100);
assert_eq!(map.len(), 3);

// Existing key (insert and update)
match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(mut view) => {
        assert_eq!(view.get(), &100);
        let v = view.get_mut();
        let new_v = (*v) * 10;
        *v = new_v;
        assert_eq!(view.insert(1111), 1000);
    }
}

assert_eq!(map[&"a"], 1111);
assert_eq!(map.len(), 3);

// Existing key (take)
let hash = compute_hash(map.hasher(), &"c");
match map.raw_entry_mut().from_key_hashed_nocheck(hash, &"c") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(view) => {
        assert_eq!(view.remove_entry(), ("c", 30));
    }
}
assert_eq!(map.raw_entry().from_key(&"c"), None);
assert_eq!(map.len(), 2);

let hash = compute_hash(map.hasher(), &"b");
match map.raw_entry_mut().from_hash(hash, |q| *q == "b") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(view) => {
        assert_eq!(view.remove_entry(), ("b", 20));
    }
}
assert_eq!(map.get(&"b"), None);
assert_eq!(map.len(), 1);

Implementations§

§

impl<'a, K, V, S, A> RawOccupiedEntryMut<'a, K, V, S, A>where
A: Allocator + Clone,

pub fn key(&self) -> &K

Gets a reference to the key in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.key(), &"a")
}

pub fn key_mut(&mut self) -> &mut K

Gets a mutable reference to the key in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        *o.key_mut() = key_two.clone();
    }
}
assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn into_key(self) -> &'a mut K

Converts the entry into a mutable reference to the key in the entry with a lifetime bound to the map itself.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

let inside_key: &mut Rc<&str>;

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => inside_key = o.into_key(),
}
*inside_key = key_two.clone();

assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn get(&self) -> &V

Gets a reference to the value in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.get(), &100),
}

pub fn into_mut(self) -> &'a mut V

Converts the OccupiedEntry into a mutable reference to the value in the entry with a lifetime bound to the map itself.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

let value: &mut u32;

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => value = o.into_mut(),
}
*value += 900;

assert_eq!(map[&"a"], 1000);

pub fn get_mut(&mut self) -> &mut V

Gets a mutable reference to the value in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => *o.get_mut() += 900,
}

assert_eq!(map[&"a"], 1000);

pub fn get_key_value(&self) -> (&K, &V)

Gets a reference to the key and value in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.get_key_value(), (&"a", &100)),
}

pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V)

Gets a mutable reference to the key and value in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        let (inside_key, inside_value) = o.get_key_value_mut();
        *inside_key = key_two.clone();
        *inside_value = 100;
    }
}
assert_eq!(map[&key_two], 100);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn into_key_value(self) -> (&'a mut K, &'a mut V)

Converts the OccupiedEntry into a mutable reference to the key and value in the entry with a lifetime bound to the map itself.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

let inside_key: &mut Rc<&str>;
let inside_value: &mut u32;
match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => {
        let tuple = o.into_key_value();
        inside_key = tuple.0;
        inside_value = tuple.1;
    }
}
*inside_key = key_two.clone();
*inside_value = 100;
assert_eq!(map[&key_two], 100);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn insert(&mut self, value: V) -> V

Sets the value of the entry, and returns the entry’s old value.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => assert_eq!(o.insert(1000), 100),
}

assert_eq!(map[&"a"], 1000);

pub fn insert_key(&mut self, key: K) -> K

Sets the value of the entry, and returns the entry’s old value.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        let old_key = o.insert_key(key_two.clone());
        assert!(Rc::ptr_eq(&old_key, &key_one));
    }
}
assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn remove(self) -> V

Takes the value out of the entry, and returns it.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.remove(), 100),
}
assert_eq!(map.get(&"a"), None);

pub fn remove_entry(self) -> (K, V)

Take the ownership of the key and value from the map.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.remove_entry(), ("a", 100)),
}
assert_eq!(map.get(&"a"), None);

pub fn replace_entry_with<F>(self, f: F) -> RawEntryMut<'a, K, V, S, A>where
F: FnOnce(&K, V) -> Option<V>,

Provides shared access to the key and owned access to the value of the entry and allows to replace or remove it based on the value of the returned option.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

let raw_entry = match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => o.replace_entry_with(|k, v| {
        assert_eq!(k, &"a");
        assert_eq!(v, 100);
        Some(v + 900)
    }),
};
let raw_entry = match raw_entry {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => o.replace_entry_with(|k, v| {
        assert_eq!(k, &"a");
        assert_eq!(v, 1000);
        None
    }),
};
match raw_entry {
    RawEntryMut::Vacant(_) => { },
    RawEntryMut::Occupied(_) => panic!(),
};
assert_eq!(map.get(&"a"), None);

Trait Implementations§

§

impl<K, V, S, A> Debug for RawOccupiedEntryMut<'_, K, V, S, A>where
 K: Debug,
 V: Debug,
 A: Allocator + Clone,

§

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

Formats the value using the given formatter. Read more

§

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>where
 K: Send,
 V: Send,
 S: Send,
 A: Send + Allocator + Clone,

§

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A>where
 K: Sync,
 V: Sync,
 S: Sync,
 A: Sync + Allocator + Clone,

Auto Trait Implementations§

§

impl<'a, K, V, S, A> RefUnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>where
 A: RefUnwindSafe,
 K: RefUnwindSafe,
 S: RefUnwindSafe,
 V: RefUnwindSafe,

§

impl<'a, K, V, S, A> Unpin for RawOccupiedEntryMut<'a, K, V, S, A>

§

impl<'a, K, V, S, A = Global> !UnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>

Blanket Implementations§

source §

impl<T> Any for Twhere
T: 'static + ?Sized,

source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

§

impl<T, U> AsBindGroupShaderType for Twhere
U: ShaderType,
&'a T: for<'a> Into,

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist. Read more

source §

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source §

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

§

impl<T> Downcast for Twhere
T: Any,

§

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

§

impl<T> DowncastSync for Twhere
T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait. Read more

source §

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source §

impl<T> Instrument for T

source §

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

source §

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

source §

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source §

impl<T, U> TryFrom for Twhere
U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source §

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

§

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source §

impl<T> WithSubscriber for T

source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

source §

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

§

Struct bevy::utils::hashbrown::hash_map::RawOccupiedEntryMut

Implementations§

impl<'a, K, V, S, A> RawOccupiedEntryMut<'a, K, V, S, A>where A: Allocator + Clone,

pub fn key(&self) -> &K

pub fn key_mut(&mut self) -> &mut K

pub fn into_key(self) -> &'a mut K

pub fn get(&self) -> &V

pub fn into_mut(self) -> &'a mut V

pub fn get_mut(&mut self) -> &mut V

pub fn get_key_value(&self) -> (&K, &V)

pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V)

pub fn into_key_value(self) -> (&'a mut K, &'a mut V)

pub fn insert(&mut self, value: V) -> V

pub fn insert_key(&mut self, key: K) -> K

pub fn remove(self) -> V

pub fn remove_entry(self) -> (K, V)

pub fn replace_entry_with<F>(self, f: F) -> RawEntryMut<'a, K, V, S, A>where F: FnOnce(&K, V) -> Option<V>,

Trait Implementations§

impl<K, V, S, A> Debug for RawOccupiedEntryMut<'_, K, V, S, A>where K: Debug, V: Debug, A: Allocator + Clone,

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

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>where K: Send, V: Send, S: Send, A: Send + Allocator + Clone,

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A>where K: Sync, V: Sync, S: Sync, A: Sync + Allocator + Clone,

Auto Trait Implementations§

impl<'a, K, V, S, A> RefUnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>where A: RefUnwindSafe, K: RefUnwindSafe, S: RefUnwindSafe, V: RefUnwindSafe,

impl<'a, K, V, S, A> Unpin for RawOccupiedEntryMut<'a, K, V, S, A>

impl<'a, K, V, S, A = Global> !UnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T, U> AsBindGroupShaderType<U> for Twhere U: ShaderType, &'a T: for<'a> Into<U>,

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

fn in_current_span(self) -> Instrumented<Self> ⓘ

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

impl<T> Event for Twhere T: 'static + Send + Sync,

impl<'a, K, V, S, A> RawOccupiedEntryMut<'a, K, V, S, A>where
A: Allocator + Clone,

pub fn replace_entry_with<F>(self, f: F) -> RawEntryMut<'a, K, V, S, A>where
F: FnOnce(&K, V) -> Option<V>,

impl<K, V, S, A> Debug for RawOccupiedEntryMut<'_, K, V, S, A>where
K: Debug,
V: Debug,
A: Allocator + Clone,

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>where
K: Send,
V: Send,
S: Send,
A: Send + Allocator + Clone,

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A>where
K: Sync,
V: Sync,
S: Sync,
A: Sync + Allocator + Clone,

impl<'a, K, V, S, A> RefUnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>where
A: RefUnwindSafe,
K: RefUnwindSafe,
S: RefUnwindSafe,
V: RefUnwindSafe,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for Twhere
U: ShaderType,
&'a T: for<'a> Into<U>,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T> Downcast for Twhere
T: Any,

impl<T> DowncastSync for Twhere
T: Any + Send + Sync,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere
S: Into<Dispatch>,

impl<T> Event for Twhere
T: 'static + Send + Sync,