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
|
//! Some more general utilities.
//!
//! Or with other words, thinks which
//! (currently) have no other place to
//! be placed in.
use std::any::TypeId;
use std::cell::RefCell;
use std::mem;
use std::fmt::{self, Debug};
/// Helper for implementing debug for an iterable think where the think on itself is irrelevant.
pub struct DebugIterableOpaque<I> {
one_use_inner: RefCell<I>
}
impl<I> DebugIterableOpaque<I> {
pub fn new(one_use_inner: I) -> Self {
let one_use_inner = RefCell::new(one_use_inner);
DebugIterableOpaque { one_use_inner }
}
}
impl<I> Debug for DebugIterableOpaque<I>
where I: Iterator, I::Item: Debug
{
fn fmt(&self, fter: &mut fmt::Formatter) -> fmt::Result {
let mut borrow = self.one_use_inner.borrow_mut();
fter.debug_list().entries(&mut *borrow).finish()
}
}
//FIXME[rust/fat pointer cast]: make it ?Sized once it's supported by rust
///
/// Used to undo type erasure in a generic context,
/// roughly semantically eqivalent to creating a `&Any`
/// type object from the input and then using `downcast_ref::<EXP>()`,
/// except that it does not require the cration of a
/// trait object as a step inbetween.
///
/// Note:
/// This function can be used for some form of specialisation,
/// (not just in a performence sense) but all "specialization path"
/// have to be known when writing the unspeciallized version and
/// it is easy to make functions behave in a unexpected (but safe)
/// way so use with care.
///
///
#[inline(always)]
pub fn uneraser_ref<GOT: 'static, EXP: 'static>(inp: &GOT ) -> Option<&EXP> {
if TypeId::of::<GOT>() == TypeId::of::<EXP>() {
//SAFE: the GOT type is exact the same as the EXP type,
// the compiler just does not know this due to type erasure wrt.
// generic types
let res: &EXP = unsafe { mem::transmute::<&GOT, &EXP>(inp) };
Some( res )
} else {
None
}
}
//FIXME[rust/fat pointer cast]: make it ?Sized once it's supported by rust
#[doc(hidden)]
#[inline(always)]
pub fn uneraser_mut<GOT: 'static, EXP: 'static>(inp: &mut GOT ) -> Option<&mut EXP> {
if TypeId::of::<GOT>() == TypeId::of::<EXP>() {
//SAFE: the GOT type is exact the same as the EXP type,
// the compiler just does not know this due to type erasure wrt.
// generic types
let res: &mut EXP = unsafe { mem::transmute::<&mut GOT, &mut EXP>(inp) };
Some( res )
} else {
None
}
}
//FIXME: only works if the rust compiler get's a bit more clever or a bit less (either is fine)
//#[inline(always)]
//pub fn uneraser<GOT: 'static, EXP: 'static>( inp: GOT ) -> Result<EXP, GOT> {
// if TypeId::of::<GOT>() == TypeId::of::<EXP>() {
// //SAFE: the GOT type is exact the same as the EXP type,
// // the compiler just does not know this due to type erasure wrt.
// // generic types
// Ok( unsafe { mem::transmute::<GOT, EXP>( inp ) } )
// } else {
// Err( inp )
// }
//}
//fn get_flat_byte_repr<T>(val: &T) -> Vec<u8> {
// let count = mem::size_of::<T>();
// let mut out = Vec::with_capacity(count);
// let byte_ptr = val as *const T as *const u8;
// for offset in 0..count {
// out.push( unsafe {
// *byte_ptr.offset(offset as isize)
// })
// }
// out
//}
/// returns true if this a not first byte from a multi byte utf-8
///
/// This will return false:
/// - on all us-ascii chars (as u8)
/// - on the first byte of a multi-byte utf-8 char
///
pub fn is_utf8_continuation_byte(b: u8) -> bool {
// all additional bytes (and only them) in utf8 start with 0b10xxxxxx so while
(b & 0b11000000) == 0b10000000
}
/// Faster insertion of byte slices into a byte vector.
pub fn vec_insert_bytes(target: &mut Vec<u8>, idx: usize, source: &[u8]) {
use std::ptr::copy;
let old_len = target.len();
let insertion_len = source.len();
let source_ptr = source.as_ptr();
let insertion_point = unsafe { target.as_mut_ptr().offset(idx as isize) };
let moved_data_len = old_len - idx;
target.reserve(insertion_len);
unsafe {
copy(/*src*/insertion_point,
/*dest*/insertion_point.offset(insertion_len as isize),
/*count*/moved_data_len);
copy(source_ptr, insertion_point, insertion_len);
//3. set the new len for the vec
target.set_len(old_len + insertion_len)
}
}
|
