]>
Commit | Line | Data |
---|---|---|
a1dfa0c6 XL |
1 | //! Buffer management for same-process client<->server communication. |
2 | ||
3 | use std::io::{self, Write}; | |
4 | use std::mem; | |
5 | use std::ops::{Deref, DerefMut}; | |
6 | use std::slice; | |
7 | ||
a1dfa0c6 | 8 | #[repr(C)] |
923072b8 FG |
9 | pub struct Buffer { |
10 | data: *mut u8, | |
a1dfa0c6 XL |
11 | len: usize, |
12 | capacity: usize, | |
923072b8 FG |
13 | reserve: extern "C" fn(Buffer, usize) -> Buffer, |
14 | drop: extern "C" fn(Buffer), | |
a1dfa0c6 XL |
15 | } |
16 | ||
923072b8 FG |
17 | unsafe impl Sync for Buffer {} |
18 | unsafe impl Send for Buffer {} | |
a1dfa0c6 | 19 | |
923072b8 FG |
20 | impl Default for Buffer { |
21 | #[inline] | |
a1dfa0c6 XL |
22 | fn default() -> Self { |
23 | Self::from(vec![]) | |
24 | } | |
25 | } | |
26 | ||
923072b8 FG |
27 | impl Deref for Buffer { |
28 | type Target = [u8]; | |
29 | #[inline] | |
30 | fn deref(&self) -> &[u8] { | |
31 | unsafe { slice::from_raw_parts(self.data as *const u8, self.len) } | |
a1dfa0c6 XL |
32 | } |
33 | } | |
34 | ||
923072b8 FG |
35 | impl DerefMut for Buffer { |
36 | #[inline] | |
37 | fn deref_mut(&mut self) -> &mut [u8] { | |
a1dfa0c6 XL |
38 | unsafe { slice::from_raw_parts_mut(self.data, self.len) } |
39 | } | |
40 | } | |
41 | ||
923072b8 FG |
42 | impl Buffer { |
43 | #[inline] | |
a1dfa0c6 XL |
44 | pub(super) fn new() -> Self { |
45 | Self::default() | |
46 | } | |
47 | ||
923072b8 | 48 | #[inline] |
a1dfa0c6 XL |
49 | pub(super) fn clear(&mut self) { |
50 | self.len = 0; | |
51 | } | |
52 | ||
923072b8 | 53 | #[inline] |
a1dfa0c6 | 54 | pub(super) fn take(&mut self) -> Self { |
416331ca | 55 | mem::take(self) |
a1dfa0c6 XL |
56 | } |
57 | ||
17df50a5 XL |
58 | // We have the array method separate from extending from a slice. This is |
59 | // because in the case of small arrays, codegen can be more efficient | |
60 | // (avoiding a memmove call). With extend_from_slice, LLVM at least | |
61 | // currently is not able to make that optimization. | |
923072b8 FG |
62 | #[inline] |
63 | pub(super) fn extend_from_array<const N: usize>(&mut self, xs: &[u8; N]) { | |
17df50a5 XL |
64 | if xs.len() > (self.capacity - self.len) { |
65 | let b = self.take(); | |
66 | *self = (b.reserve)(b, xs.len()); | |
67 | } | |
68 | unsafe { | |
69 | xs.as_ptr().copy_to_nonoverlapping(self.data.add(self.len), xs.len()); | |
70 | self.len += xs.len(); | |
71 | } | |
72 | } | |
73 | ||
923072b8 FG |
74 | #[inline] |
75 | pub(super) fn extend_from_slice(&mut self, xs: &[u8]) { | |
17df50a5 XL |
76 | if xs.len() > (self.capacity - self.len) { |
77 | let b = self.take(); | |
78 | *self = (b.reserve)(b, xs.len()); | |
79 | } | |
80 | unsafe { | |
81 | xs.as_ptr().copy_to_nonoverlapping(self.data.add(self.len), xs.len()); | |
82 | self.len += xs.len(); | |
83 | } | |
84 | } | |
85 | ||
923072b8 FG |
86 | #[inline] |
87 | pub(super) fn push(&mut self, v: u8) { | |
17df50a5 XL |
88 | // The code here is taken from Vec::push, and we know that reserve() |
89 | // will panic if we're exceeding isize::MAX bytes and so there's no need | |
90 | // to check for overflow. | |
91 | if self.len == self.capacity { | |
92 | let b = self.take(); | |
93 | *self = (b.reserve)(b, 1); | |
94 | } | |
95 | unsafe { | |
96 | *self.data.add(self.len) = v; | |
97 | self.len += 1; | |
a1dfa0c6 | 98 | } |
a1dfa0c6 XL |
99 | } |
100 | } | |
101 | ||
923072b8 FG |
102 | impl Write for Buffer { |
103 | #[inline] | |
a1dfa0c6 XL |
104 | fn write(&mut self, xs: &[u8]) -> io::Result<usize> { |
105 | self.extend_from_slice(xs); | |
106 | Ok(xs.len()) | |
107 | } | |
108 | ||
923072b8 | 109 | #[inline] |
a1dfa0c6 XL |
110 | fn write_all(&mut self, xs: &[u8]) -> io::Result<()> { |
111 | self.extend_from_slice(xs); | |
112 | Ok(()) | |
113 | } | |
114 | ||
923072b8 | 115 | #[inline] |
a1dfa0c6 XL |
116 | fn flush(&mut self) -> io::Result<()> { |
117 | Ok(()) | |
118 | } | |
119 | } | |
120 | ||
923072b8 FG |
121 | impl Drop for Buffer { |
122 | #[inline] | |
a1dfa0c6 XL |
123 | fn drop(&mut self) { |
124 | let b = self.take(); | |
125 | (b.drop)(b); | |
126 | } | |
127 | } | |
128 | ||
923072b8 FG |
129 | impl From<Vec<u8>> for Buffer { |
130 | fn from(mut v: Vec<u8>) -> Self { | |
a1dfa0c6 XL |
131 | let (data, len, capacity) = (v.as_mut_ptr(), v.len(), v.capacity()); |
132 | mem::forget(v); | |
133 | ||
134 | // This utility function is nested in here because it can *only* | |
135 | // be safely called on `Buffer`s created by *this* `proc_macro`. | |
923072b8 | 136 | fn to_vec(b: Buffer) -> Vec<u8> { |
a1dfa0c6 | 137 | unsafe { |
dfeec247 | 138 | let Buffer { data, len, capacity, .. } = b; |
a1dfa0c6 XL |
139 | mem::forget(b); |
140 | Vec::from_raw_parts(data, len, capacity) | |
141 | } | |
142 | } | |
143 | ||
923072b8 | 144 | extern "C" fn reserve(b: Buffer, additional: usize) -> Buffer { |
a1dfa0c6 | 145 | let mut v = to_vec(b); |
17df50a5 | 146 | v.reserve(additional); |
a1dfa0c6 XL |
147 | Buffer::from(v) |
148 | } | |
149 | ||
923072b8 | 150 | extern "C" fn drop(b: Buffer) { |
a1dfa0c6 XL |
151 | mem::drop(to_vec(b)); |
152 | } | |
153 | ||
17df50a5 | 154 | Buffer { data, len, capacity, reserve, drop } |
a1dfa0c6 XL |
155 | } |
156 | } |