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
|
/**
* Originally from Intertrait by CodeChain
*
* <https://github.com/CodeChain-io/intertrait>
* <https://crates.io/crates/intertrait/0.2.2>
*
* Licensed under either of
*
* Apache License, Version 2.0 (LICENSE-APACHE or <http://www.apache.org/licenses/LICENSE-2.0>)
* MIT license (LICENSE-MIT or <http://opensource.org/licenses/MIT>)
* at your option.
*/
use std::any::{Any, TypeId};
use std::rc::Rc;
use ahash::AHashMap;
use linkme::distributed_slice;
use once_cell::sync::Lazy;
pub mod cast_box;
pub mod cast_rc;
pub type BoxedCaster = Box<dyn Any + Send + Sync>;
type CasterFn = fn() -> (TypeId, BoxedCaster);
#[distributed_slice]
pub static CASTERS: [CasterFn] = [..];
static CASTER_MAP: Lazy<AHashMap<(TypeId, TypeId), BoxedCaster>> = Lazy::new(|| {
CASTERS
.iter()
.map(|caster_fn| {
let (type_id, caster) = caster_fn();
((type_id, (*caster).type_id()), caster)
})
.collect()
});
pub struct Caster<Trait: ?Sized + 'static>
{
/// Casts a `Box` holding a trait object for `Any` to another `Box` holding a trait object
/// for `Trait`.
pub cast_box: fn(from: Box<dyn Any>) -> Box<Trait>,
/// Casts an `Rc` holding a trait object for `Any` to another `Rc` holding a trait object
/// for `Trait`.
pub cast_rc: fn(from: Rc<dyn Any>) -> Rc<Trait>,
}
impl<Trait: ?Sized + 'static> Caster<Trait>
{
pub fn new(
cast_box: fn(from: Box<dyn Any>) -> Box<Trait>,
cast_rc: fn(from: Rc<dyn Any>) -> Rc<Trait>,
) -> Caster<Trait>
{
Caster::<Trait> { cast_box, cast_rc }
}
}
/// Returns a `Caster<Implementation, Trait>` from a concrete type `Implementation`
/// from inside `CASTER_MAP` to a `Trait` implemented by it.
fn caster<Trait: ?Sized + 'static>(type_id: TypeId) -> Option<&'static Caster<Trait>>
{
CASTER_MAP
.get(&(type_id, TypeId::of::<Caster<Trait>>()))
.and_then(|caster| caster.downcast_ref::<Caster<Trait>>())
}
/// `CastFrom` must be extended by a trait that wants to allow for casting into another trait.
///
/// It is used for obtaining a trait object for [`Any`] from a trait object for its sub-trait,
/// and blanket implemented for all `Sized + Any + 'static` types.
///
/// # Examples
/// ```ignore
/// trait Source: CastFrom {
/// ...
/// }
/// ```
pub trait CastFrom: Any + 'static
{
/// Returns a `Box` of `Any`, which is backed by the type implementing this trait.
fn box_any(self: Box<Self>) -> Box<dyn Any>;
/// Returns an `Rc` of `Any`, which is backed by the type implementing this trait.
fn rc_any(self: Rc<Self>) -> Rc<dyn Any>;
}
impl<Trait: Sized + Any + 'static> CastFrom for Trait
{
fn box_any(self: Box<Self>) -> Box<dyn Any>
{
self
}
fn rc_any(self: Rc<Self>) -> Rc<dyn Any>
{
self
}
}
impl CastFrom for dyn Any + 'static
{
fn box_any(self: Box<Self>) -> Box<dyn Any>
{
self
}
fn rc_any(self: Rc<Self>) -> Rc<dyn Any>
{
self
}
}
impl CastFrom for dyn Any + Sync + Send + 'static
{
fn box_any(self: Box<Self>) -> Box<dyn Any>
{
self
}
fn rc_any(self: Rc<Self>) -> Rc<dyn Any>
{
self
}
}
|
