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
use super::{data_structures::ArrayLen, *};
use std::ops::{Deref, Index};
abi_stable_shared::declare_tl_lifetime_types! {
repr=u8,
attrs=[
derive(StableAbi),
]
}
impl Display for LifetimeIndex {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
LifetimeIndex::STATIC => f.write_str("'static"),
LifetimeIndex::ANONYMOUS => f.write_str("'_"),
LifetimeIndex::NONE => f.write_str("'NONE"),
LifetimeIndex { bits: n } => write!(f, "'{}", n - Self::START_OF_LIFETIMES),
}
}
}
impl LifetimeRange {
pub fn slicing(self, lifetime_indices: &[LifetimeIndexPair]) -> LifetimeArrayOrSlice<'_> {
let len = (self.len() + 1) / 2;
if self.is_range() {
let start = (self.bits & Self::START_MASK) as usize;
let end = start + len;
let x = RSlice::from_slice(&lifetime_indices[start..end]);
LifetimeArrayOrSlice::Slice(x)
} else {
LifetimeArrayOrSlice::Array(ArrayLen {
len: len as u16,
array: LifetimeIndexArray::from_u20(self.bits).to_array(),
})
}
}
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, StableAbi)]
pub enum LifetimeArrayOrSlice<'a> {
Slice(RSlice<'a, LifetimeIndexPair>),
Array(ArrayLen<[LifetimeIndexPair; 3]>),
}
impl<'a> LifetimeArrayOrSlice<'a> {
pub const EMPTY: Self = LifetimeArrayOrSlice::Array(ArrayLen {
len: 0,
array: [
LifetimeIndexPair::NONE,
LifetimeIndexPair::NONE,
LifetimeIndexPair::NONE,
],
});
pub fn as_slice(&self) -> &[LifetimeIndexPair] {
match self {
LifetimeArrayOrSlice::Slice(slice) => slice.as_slice(),
LifetimeArrayOrSlice::Array(arraylen) => &arraylen.array[..arraylen.len as usize],
}
}
}
impl<'a> Deref for LifetimeArrayOrSlice<'a> {
type Target = [LifetimeIndexPair];
#[inline]
fn deref(&self) -> &[LifetimeIndexPair] {
self.as_slice()
}
}
impl<'a, I, Output: ?Sized> Index<I> for LifetimeArrayOrSlice<'a>
where
[LifetimeIndexPair]: Index<I, Output = Output>,
{
type Output = Output;
#[inline]
fn index(&self, i: I) -> &Output {
&self.as_slice()[i]
}
}