multi-any 0.1.1

`MultiAny` is just like `Any` but can downcast to trait objects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

use multi_any::{Meta, MultiAny, multi_any};
use std::any::TypeId;

#[test]
fn test_basic() {
    #[multi_any]
    trait Hello {
        fn hello(&self) -> String;
    }

    #[multi_any]
    trait Bye {
        fn bye(&self) -> String;
    }

    #[multi_any]
    trait Other {}

    struct Foo {
        name: String,
    }

    impl Hello for Foo {
        fn hello(&self) -> String {
            format!("Hello, {}", self.name)
        }
    }

    impl Bye for Foo {
        fn bye(&self) -> String {
            format!("Bye, {}", self.name)
        }
    }

    impl MultiAny for Foo {
        fn get_metadata(&self, type_id: TypeId) -> Option<Meta> {
            Meta::try_from(self, type_id, |v| v)
                .or_else(|| Meta::try_from(self, type_id, |v| v as &dyn Hello))
                .or_else(|| Meta::try_from(self, type_id, |v| v as &dyn Bye))
        }
    }

    let foo: Box<dyn MultiAny> = Box::new(Foo { name: "Bob".into() });

    // downcast to concrete type
    assert_eq!(foo.downcast_ref::<Foo>().unwrap().name, "Bob");

    // downcast to dyn traits that are implemented
    assert_eq!(
        foo.downcast_ref::<dyn Hello>().unwrap().hello(),
        "Hello, Bob"
    );
    assert_eq!(foo.downcast_ref::<dyn Bye>().unwrap().bye(), "Bye, Bob");

    // Test invalid downcasts
    assert!(foo.downcast_ref::<dyn Other>().is_none());
    assert!(foo.downcast_ref::<()>().is_none());
}

#[test]
fn test_derive() {
    #[multi_any]
    trait Trait1 {}
    #[multi_any]
    trait Trait2 {}
    #[multi_any]
    trait Trait3 {}

    #[derive(MultiAny)]
    #[multi_any(Trait1, Trait2)]
    struct Foo;

    impl Trait1 for Foo {}
    impl Trait2 for Foo {}

    let foo: Box<dyn MultiAny> = Box::new(Foo);
    assert!(foo.downcast_ref::<Foo>().is_some());
    assert!(foo.downcast_ref::<dyn Trait1>().is_some());
    assert!(foo.downcast_ref::<dyn Trait2>().is_some());
    assert!(foo.downcast_ref::<dyn Trait3>().is_none());
}

#[test]
fn test_downcast_mut() {
    #[multi_any]
    trait Named {
        fn set_name(&mut self, name: &str);
    }

    #[multi_any]
    trait Other {}

    #[derive(MultiAny)]
    #[multi_any(Named)]
    struct Foo {
        name: String,
    }

    impl Named for Foo {
        fn set_name(&mut self, name: &str) {
            self.name = name.to_string();
        }
    }

    let mut foo: Box<dyn MultiAny> = Box::new(Foo { name: "old".into() });

    // Test mutable downcast to concrete type
    foo.downcast_mut::<Foo>().unwrap().name = "new".to_string();
    assert_eq!(foo.downcast_ref::<Foo>().unwrap().name, "new");

    // Test mutable downcast to trait
    foo.downcast_mut::<dyn Named>().unwrap().set_name("trait");
    assert_eq!(foo.downcast_ref::<Foo>().unwrap().name, "trait");

    // Test invalid downcasts
    assert!(foo.downcast_mut::<dyn Other>().is_none());
    assert!(foo.downcast_mut::<()>().is_none());
}

#[test]
fn test_downcast() {
    #[multi_any]
    trait Displayable {
        fn get_value(&self) -> i32;
    }

    #[derive(MultiAny)]
    #[multi_any(Displayable)]
    struct Foo {
        value: i32,
    }

    impl Displayable for Foo {
        fn get_value(&self) -> i32 {
            self.value
        }
    }

    // Test successful downcast to concrete type
    let foo: Box<dyn MultiAny> = Box::new(Foo { value: 42 });
    match foo.downcast::<Foo>() {
        Ok(downcasted) => assert_eq!(downcasted.value, 42),
        Err(_) => panic!("Expected successful downcast"),
    }

    // Test successful downcast to trait object
    let foo: Box<dyn MultiAny> = Box::new(Foo { value: 99 });
    match foo.downcast::<dyn Displayable>() {
        Ok(downcasted) => assert_eq!(downcasted.get_value(), 99),
        Err(_) => panic!("Expected successful trait downcast"),
    }

    // Test failed downcast
    let foo: Box<dyn MultiAny> = Box::new(Foo { value: 123 });
    match foo.downcast::<String>() {
        Ok(_) => panic!("Expected failed downcast"),
        Err(original) => assert_eq!(original.downcast_ref::<Foo>().unwrap().value, 123),
    }
}

#[cfg(feature = "nightly")]
#[test]
fn test_nightly() {
    // We can omit `#[multi_any]` on nightly
    trait Trait {}

    #[derive(MultiAny)]
    #[multi_any(Trait)]
    struct Foo;

    impl Trait for Foo {}

    let foo: Box<dyn MultiAny> = Box::new(Foo);
    assert!(foo.downcast_ref::<dyn Trait>().is_some())
}