Struct egui::util::id_type_map::IdTypeMap

pub struct IdTypeMap {
    map: IntMap<u64, Element>,
    max_bytes_per_type: usize,
}

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()));

Fields

map: IntMap<u64, Element>

max_bytes_per_type: usize

Implementations

impl IdTypeMap

pub fn insert_temp<T: 'static + Any + Clone + Send + Sync>( &mut self, id: Id, value: T, )

Insert a value that will not be persisted.

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.

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!

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

pub fn remove<T: 'static>(&mut self, id: Id)

Remove the state of this type and id.

pub fn remove_temp<T: 'static + Default>(&mut self, id: Id) -> Option<T>

Remove and fetch the state of this type and id.

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

pub fn count_serialized(&self) -> usize

Count how many values are stored but not yet deserialized.

pub fn count<T: 'static>(&self) -> usize

Count the number of values are stored with the given type.

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.

pub fn set_max_bytes_per_type(&mut self, max_bytes_per_type: usize)

See Self::max_bytes_per_type.

Trait Implementations

impl Clone for IdTypeMap

fn clone(&self) -> IdTypeMap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IdTypeMap

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

Formats the value using the given formatter.

impl Default for IdTypeMap

fn default() -> Self

Returns the “default value” for a type.