Struct egui::util::id_type_map::IdTypeMap

pub struct IdTypeMap(_);

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<…>>.

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

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>(&mut 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.

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 an 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.

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

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IdTypeMap

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IdTypeMap

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
S: Serializer,

Serialize this value into the given Serde serializer.