Merge branch 'master' into 2025-11-16-egui
This commit is contained in:
commit
306774c15b
1 changed files with 80 additions and 36 deletions
|
|
@ -101,7 +101,7 @@ macro_rules! define_typemap {
|
|||
{
|
||||
type Output<'a> = (&'a mut A,);
|
||||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
Some((a,))
|
||||
|
|
@ -133,8 +133,8 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>()];
|
||||
if ids[0] == ids[1] { return None; }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -170,9 +170,9 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
|
||||
if ids[0] == ids[1] || ids[0] == ids[2] || ids[1] == ids[2] { return None; }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -212,10 +212,10 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>()];
|
||||
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -259,11 +259,11 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>()];
|
||||
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -311,12 +311,12 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>()];
|
||||
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -368,13 +368,13 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>()];
|
||||
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -430,14 +430,14 @@ macro_rules! define_typemap {
|
|||
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
|
||||
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>(), TypeId::of::<H>()];
|
||||
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v as *mut dyn Any) }?;
|
||||
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v.as_mut() as *mut dyn Any) }?;
|
||||
unsafe {
|
||||
let a = (&mut *ptr_a).downcast_mut::<A>()?;
|
||||
let b = (&mut *ptr_b).downcast_mut::<B>()?;
|
||||
|
|
@ -498,3 +498,47 @@ macro_rules! define_typemap {
|
|||
// Self::new()
|
||||
// }
|
||||
// }
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::define_typemap;
|
||||
|
||||
define_typemap!(TestMap,);
|
||||
|
||||
#[test]
|
||||
fn get_test() {
|
||||
let mut tm = TestMap::new();
|
||||
tm.insert::<u32>(42);
|
||||
let v = tm.get::<u32>().expect("value should be present");
|
||||
assert_eq!(*v, 42);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_many_test() {
|
||||
let mut tm = TestMap::new();
|
||||
tm.insert::<u32>(1);
|
||||
tm.insert::<i32>(-2);
|
||||
tm.insert::<f32>(3.5);
|
||||
|
||||
let (a, b, c) = tm
|
||||
.get_many::<(u32, i32, f32)>()
|
||||
.expect("all values should be present");
|
||||
assert_eq!((*a, *b, *c), (1, -2, 3.5));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_many_mut_test() {
|
||||
let mut tm = TestMap::new();
|
||||
|
||||
tm.insert::<i32>(-2);
|
||||
tm.insert::<u32>(1);
|
||||
tm.insert::<f32>(3.5);
|
||||
|
||||
let (a, b, c) = tm
|
||||
.get_many_mut::<(i32, u32, f32)>()
|
||||
.expect("all values should be present");
|
||||
*a = 4;
|
||||
*b = 5;
|
||||
*c = 6.5;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue