Struct egui::util::id_type_map::IdTypeMap
source · pub struct IdTypeMap { /* private fields */ }Expand description
Stores values identified by an Id AND a the std::any::TypeId of the value.
In other words, it maps (Id, TypeId) to any value you want.
Values are cloned when read, so keep them small and light.
If you want to store something bigger, wrap them in Arc<Mutex<…>>.
Also try Arc<ArcSwap<…>>.
Values can either be “persisted” (serializable) or “temporary” (cleared when egui is shut down).
You can store state using the key Id::NULL. The state will then only be identified by its type.
let a = Id::new("a");
let b = Id::new("b");
let mut map: IdTypeMap = Default::default();
// `a` associated with an f64 and an i32
map.insert_persisted(a, 3.14);
map.insert_temp(a, 42);
// `b` associated with an f64 and a `&'static str`
map.insert_persisted(b, 13.37);
map.insert_temp(b, "Hello World".to_owned());
// we can retrieve all four values:
assert_eq!(map.get_temp::<f64>(a), Some(3.14));
assert_eq!(map.get_temp::<i32>(a), Some(42));
assert_eq!(map.get_temp::<f64>(b), Some(13.37));
assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));
// we can retrieve them like so also:
assert_eq!(map.get_persisted::<f64>(a), Some(3.14));
assert_eq!(map.get_persisted::<i32>(a), Some(42));
assert_eq!(map.get_persisted::<f64>(b), Some(13.37));
assert_eq!(map.get_temp::<String>(b), Some("Hello World".to_owned()));Implementations§
source§impl IdTypeMap
impl IdTypeMap
sourcepub fn insert_temp<T: 'static + Any + Clone + Send + Sync>(
&mut self,
id: Id,
value: T
)
pub fn insert_temp<T: 'static + Any + Clone + Send + Sync>( &mut self, id: Id, value: T )
Insert a value that will not be persisted.
sourcepub fn insert_persisted<T: SerializableAny>(&mut self, id: Id, value: T)
pub fn insert_persisted<T: SerializableAny>(&mut self, id: Id, value: T)
Insert a value that will be persisted next time you start the app.
sourcepub fn get_temp<T: 'static + Clone>(&self, id: Id) -> Option<T>
pub fn get_temp<T: 'static + Clone>(&self, id: Id) -> Option<T>
Read a value without trying to deserialize a persisted value.
The call clones the value (if found), so make sure it is cheap to clone!
sourcepub fn get_persisted<T: SerializableAny>(&mut self, id: Id) -> Option<T>
pub fn get_persisted<T: SerializableAny>(&mut self, id: Id) -> Option<T>
Read a value, optionally deserializing it if available.
NOTE: A mutable self is needed because internally this deserializes on first call
and caches the result (caching requires self-mutability).
The call clones the value (if found), so make sure it is cheap to clone!
pub fn get_temp_mut_or<T: 'static + Any + Clone + Send + Sync>( &mut self, id: Id, or_insert: T ) -> &mut T
pub fn get_persisted_mut_or<T: SerializableAny>( &mut self, id: Id, or_insert: T ) -> &mut T
pub fn get_temp_mut_or_default<T: 'static + Any + Clone + Send + Sync + Default>( &mut self, id: Id ) -> &mut T
pub fn get_persisted_mut_or_default<T: SerializableAny + Default>( &mut self, id: Id ) -> &mut T
pub fn get_temp_mut_or_insert_with<T: 'static + Any + Clone + Send + Sync>( &mut self, id: Id, insert_with: impl FnOnce() -> T ) -> &mut T
pub fn get_persisted_mut_or_insert_with<T: SerializableAny>( &mut self, id: Id, insert_with: impl FnOnce() -> T ) -> &mut T
sourcepub fn remove_temp<T: 'static + Default>(&mut self, id: Id) -> Option<T>
pub fn remove_temp<T: 'static + Default>(&mut self, id: Id) -> Option<T>
Remove and fetch the state of this type and id.
sourcepub fn remove_by_type<T: 'static>(&mut self)
pub fn remove_by_type<T: 'static>(&mut self)
Note all state of the given type.
pub fn clear(&mut self)
pub fn is_empty(&self) -> bool
pub fn len(&self) -> usize
sourcepub fn count_serialized(&self) -> usize
pub fn count_serialized(&self) -> usize
Count how many values are stored but not yet deserialized.
sourcepub fn count<T: 'static>(&self) -> usize
pub fn count<T: 'static>(&self) -> usize
Count the number of values are stored with the given type.
sourcepub fn max_bytes_per_type(&self) -> usize
pub fn max_bytes_per_type(&self) -> usize
The maximum number of bytes that will be used to store the persisted state of a single widget type.
Some egui widgets store persisted state that is
serialized to disk by some backends (e.g. eframe).
Example of such widgets is CollapsingHeader and Window.
If you keep creating widgets with unique ids (e.g. Windows with many different names),
egui will use up more and more space for these widgets, until this limit is reached.
Once this limit is reached, the state that was read the longest time ago will be dropped first.
This value in itself will not be serialized.