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
|
/**
* 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::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
use linkme::distributed_slice;
use once_cell::sync::Lazy;
mod hasher;
use hasher::BuildFastHasher;
pub mod cast_box;
pub mod cast_rc;
pub type BoxedCaster = Box<dyn Any + Send + Sync>;
#[distributed_slice]
pub static CASTERS: [fn() -> (TypeId, BoxedCaster)] = [..];
static CASTER_MAP: Lazy<HashMap<(TypeId, TypeId), BoxedCaster, BuildFastHasher>> =
Lazy::new(|| {
CASTERS
.iter()
.map(|f| {
let (type_id, caster) = f();
((type_id, (*caster).type_id()), caster)
})
.collect()
});
pub struct Caster<T: ?Sized + 'static>
{
/// Casts a `Box` holding a trait object for `Any` to another `Box` holding a trait object
/// for trait `T`.
pub cast_box: fn(from: Box<dyn Any>) -> Box<T>,
/// Casts an `Rc` holding a trait object for `Any` to another `Rc` holding a trait object
/// for trait `T`.
pub cast_rc: fn(from: Rc<dyn Any>) -> Rc<T>,
}
impl<T: ?Sized + 'static> Caster<T>
{
pub fn new(
cast_box: fn(from: Box<dyn Any>) -> Box<T>,
cast_rc: fn(from: Rc<dyn Any>) -> Rc<T>,
) -> Caster<T>
{
Caster::<T> { cast_box, cast_rc }
}
}
/// Returns a `Caster<S, T>` from a concrete type `S` to a trait `T` implemented by it.
fn caster<T: ?Sized + 'static>(type_id: TypeId) -> Option<&'static Caster<T>>
{
CASTER_MAP
.get(&(type_id, TypeId::of::<Caster<T>>()))
.and_then(|caster| caster.downcast_ref::<Caster<T>>())
}
/// `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>;
}
pub trait CastFromSync: CastFrom + Sync + Send + 'static
{
fn arc_any(self: Arc<Self>) -> Arc<dyn Any + Sync + Send + 'static>;
}
impl<T: Sized + Any + 'static> CastFrom for T
{
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
}
}
|
