bolero_generator/driver/
object.rs

1use super::Driver;
2use core::ops::{self, Bound};
3
4/// An object-safe Driver trait
5pub trait DynDriver {
6    fn depth(&self) -> usize;
7    fn set_depth(&mut self, depth: usize);
8    fn max_depth(&self) -> usize;
9    fn gen_variant(&mut self, variants: usize, base_case: usize) -> Option<usize>;
10    fn gen_u8(&mut self, min: Bound<&u8>, max: Bound<&u8>) -> Option<u8>;
11    fn gen_i8(&mut self, min: Bound<&i8>, max: Bound<&i8>) -> Option<i8>;
12    fn gen_u16(&mut self, min: Bound<&u16>, max: Bound<&u16>) -> Option<u16>;
13    fn gen_i16(&mut self, min: Bound<&i16>, max: Bound<&i16>) -> Option<i16>;
14    fn gen_u32(&mut self, min: Bound<&u32>, max: Bound<&u32>) -> Option<u32>;
15    fn gen_i32(&mut self, min: Bound<&i32>, max: Bound<&i32>) -> Option<i32>;
16    fn gen_u64(&mut self, min: Bound<&u64>, max: Bound<&u64>) -> Option<u64>;
17    fn gen_i64(&mut self, min: Bound<&i64>, max: Bound<&i64>) -> Option<i64>;
18    fn gen_u128(&mut self, min: Bound<&u128>, max: Bound<&u128>) -> Option<u128>;
19    fn gen_i128(&mut self, min: Bound<&i128>, max: Bound<&i128>) -> Option<i128>;
20    fn gen_usize(&mut self, min: Bound<&usize>, max: Bound<&usize>) -> Option<usize>;
21    fn gen_isize(&mut self, min: Bound<&isize>, max: Bound<&isize>) -> Option<isize>;
22    fn gen_f32(&mut self, min: Bound<&f32>, max: Bound<&f32>) -> Option<f32>;
23    fn gen_f64(&mut self, min: Bound<&f64>, max: Bound<&f64>) -> Option<f64>;
24    fn gen_char(&mut self, min: Bound<&char>, max: Bound<&char>) -> Option<char>;
25    fn gen_bool(&mut self, probability: Option<f32>) -> Option<bool>;
26    fn gen_from_bytes(
27        &mut self,
28        hint: &mut dyn FnMut() -> (usize, Option<usize>),
29        produce: &mut dyn FnMut(&[u8]) -> Option<usize>,
30    ) -> Option<()>;
31}
32
33/// `&dyn FnOnce()` doesn't work since invoking it takes ownership. So wrap it as a `FnMut()`.
34#[inline]
35fn hint_fn<F: FnOnce() -> (usize, Option<usize>)>(f: F) -> impl FnMut() -> (usize, Option<usize>) {
36    enum Hint<F> {
37        Pending(F),
38        Resolved((usize, Option<usize>)),
39    }
40
41    impl<F: FnOnce() -> (usize, Option<usize>)> Hint<F> {
42        #[inline]
43        fn get(&mut self) -> (usize, Option<usize>) {
44            match core::mem::replace(self, Hint::Resolved((0, None))) {
45                Hint::Pending(f) => {
46                    let value = f();
47                    *self = Hint::Resolved(value);
48                    value
49                }
50                Hint::Resolved(value) => {
51                    *self = Hint::Resolved(value);
52                    value
53                }
54            }
55        }
56    }
57
58    let mut hint = Hint::Pending(f);
59
60    move || hint.get()
61}
62
63pub struct Borrowed<'a>(pub &'a mut dyn DynDriver);
64
65impl Driver for Borrowed<'_> {
66    #[inline]
67    fn depth(&self) -> usize {
68        self.0.depth()
69    }
70
71    #[inline]
72    fn set_depth(&mut self, depth: usize) {
73        self.0.set_depth(depth);
74    }
75
76    #[inline]
77    fn max_depth(&self) -> usize {
78        self.0.max_depth()
79    }
80
81    #[inline]
82    fn gen_variant(&mut self, variants: usize, base_case: usize) -> Option<usize> {
83        self.0.gen_variant(variants, base_case)
84    }
85
86    #[inline]
87    fn gen_u8(&mut self, min: Bound<&u8>, max: Bound<&u8>) -> Option<u8> {
88        self.0.gen_u8(min, max)
89    }
90
91    #[inline]
92    fn gen_i8(&mut self, min: Bound<&i8>, max: Bound<&i8>) -> Option<i8> {
93        self.0.gen_i8(min, max)
94    }
95
96    #[inline]
97    fn gen_u16(&mut self, min: Bound<&u16>, max: Bound<&u16>) -> Option<u16> {
98        self.0.gen_u16(min, max)
99    }
100
101    #[inline]
102    fn gen_i16(&mut self, min: Bound<&i16>, max: Bound<&i16>) -> Option<i16> {
103        self.0.gen_i16(min, max)
104    }
105
106    #[inline]
107    fn gen_u32(&mut self, min: Bound<&u32>, max: Bound<&u32>) -> Option<u32> {
108        self.0.gen_u32(min, max)
109    }
110
111    #[inline]
112    fn gen_i32(&mut self, min: Bound<&i32>, max: Bound<&i32>) -> Option<i32> {
113        self.0.gen_i32(min, max)
114    }
115
116    #[inline]
117    fn gen_u64(&mut self, min: Bound<&u64>, max: Bound<&u64>) -> Option<u64> {
118        self.0.gen_u64(min, max)
119    }
120
121    #[inline]
122    fn gen_i64(&mut self, min: Bound<&i64>, max: Bound<&i64>) -> Option<i64> {
123        self.0.gen_i64(min, max)
124    }
125
126    #[inline]
127    fn gen_u128(&mut self, min: Bound<&u128>, max: Bound<&u128>) -> Option<u128> {
128        self.0.gen_u128(min, max)
129    }
130
131    #[inline]
132    fn gen_i128(&mut self, min: Bound<&i128>, max: Bound<&i128>) -> Option<i128> {
133        self.0.gen_i128(min, max)
134    }
135
136    #[inline]
137    fn gen_usize(&mut self, min: Bound<&usize>, max: Bound<&usize>) -> Option<usize> {
138        self.0.gen_usize(min, max)
139    }
140
141    #[inline]
142    fn gen_isize(&mut self, min: Bound<&isize>, max: Bound<&isize>) -> Option<isize> {
143        self.0.gen_isize(min, max)
144    }
145
146    #[inline]
147    fn gen_f32(&mut self, min: Bound<&f32>, max: Bound<&f32>) -> Option<f32> {
148        self.0.gen_f32(min, max)
149    }
150
151    #[inline]
152    fn gen_f64(&mut self, min: Bound<&f64>, max: Bound<&f64>) -> Option<f64> {
153        self.0.gen_f64(min, max)
154    }
155
156    #[inline]
157    fn gen_char(&mut self, min: Bound<&char>, max: Bound<&char>) -> Option<char> {
158        self.0.gen_char(min, max)
159    }
160
161    #[inline]
162    fn gen_bool(&mut self, probability: Option<f32>) -> Option<bool> {
163        self.0.gen_bool(probability)
164    }
165
166    #[inline]
167    fn gen_from_bytes<Hint, Gen, T>(&mut self, hint: Hint, mut produce: Gen) -> Option<T>
168    where
169        Hint: FnOnce() -> (usize, Option<usize>),
170        Gen: FnMut(&[u8]) -> Option<(usize, T)>,
171    {
172        let mut value = None;
173        let mut hint = hint_fn(hint);
174        self.0.gen_from_bytes(&mut hint, &mut |bytes| {
175            let (len, v) = produce(bytes)?;
176            value = Some(v);
177            Some(len)
178        })?;
179        value
180    }
181}
182
183impl<D: DynDriver> Driver for D {
184    #[inline]
185    fn depth(&self) -> usize {
186        <D as DynDriver>::depth(self)
187    }
188
189    #[inline]
190    fn set_depth(&mut self, depth: usize) {
191        <D as DynDriver>::set_depth(self, depth)
192    }
193
194    #[inline]
195    fn max_depth(&self) -> usize {
196        <D as DynDriver>::max_depth(self)
197    }
198
199    #[inline]
200    fn gen_variant(&mut self, variants: usize, base_case: usize) -> Option<usize> {
201        <D as DynDriver>::gen_variant(self, variants, base_case)
202    }
203
204    #[inline]
205    fn gen_u8(&mut self, min: Bound<&u8>, max: Bound<&u8>) -> Option<u8> {
206        <D as DynDriver>::gen_u8(self, min, max)
207    }
208
209    #[inline]
210    fn gen_i8(&mut self, min: Bound<&i8>, max: Bound<&i8>) -> Option<i8> {
211        <D as DynDriver>::gen_i8(self, min, max)
212    }
213
214    #[inline]
215    fn gen_u16(&mut self, min: Bound<&u16>, max: Bound<&u16>) -> Option<u16> {
216        <D as DynDriver>::gen_u16(self, min, max)
217    }
218
219    #[inline]
220    fn gen_i16(&mut self, min: Bound<&i16>, max: Bound<&i16>) -> Option<i16> {
221        <D as DynDriver>::gen_i16(self, min, max)
222    }
223
224    #[inline]
225    fn gen_u32(&mut self, min: Bound<&u32>, max: Bound<&u32>) -> Option<u32> {
226        <D as DynDriver>::gen_u32(self, min, max)
227    }
228
229    #[inline]
230    fn gen_i32(&mut self, min: Bound<&i32>, max: Bound<&i32>) -> Option<i32> {
231        <D as DynDriver>::gen_i32(self, min, max)
232    }
233
234    #[inline]
235    fn gen_u64(&mut self, min: Bound<&u64>, max: Bound<&u64>) -> Option<u64> {
236        <D as DynDriver>::gen_u64(self, min, max)
237    }
238
239    #[inline]
240    fn gen_i64(&mut self, min: Bound<&i64>, max: Bound<&i64>) -> Option<i64> {
241        <D as DynDriver>::gen_i64(self, min, max)
242    }
243
244    #[inline]
245    fn gen_u128(&mut self, min: Bound<&u128>, max: Bound<&u128>) -> Option<u128> {
246        <D as DynDriver>::gen_u128(self, min, max)
247    }
248
249    #[inline]
250    fn gen_i128(&mut self, min: Bound<&i128>, max: Bound<&i128>) -> Option<i128> {
251        <D as DynDriver>::gen_i128(self, min, max)
252    }
253
254    #[inline]
255    fn gen_usize(&mut self, min: Bound<&usize>, max: Bound<&usize>) -> Option<usize> {
256        <D as DynDriver>::gen_usize(self, min, max)
257    }
258
259    #[inline]
260    fn gen_isize(&mut self, min: Bound<&isize>, max: Bound<&isize>) -> Option<isize> {
261        <D as DynDriver>::gen_isize(self, min, max)
262    }
263
264    #[inline]
265    fn gen_f32(&mut self, min: Bound<&f32>, max: Bound<&f32>) -> Option<f32> {
266        <D as DynDriver>::gen_f32(self, min, max)
267    }
268
269    #[inline]
270    fn gen_f64(&mut self, min: Bound<&f64>, max: Bound<&f64>) -> Option<f64> {
271        <D as DynDriver>::gen_f64(self, min, max)
272    }
273
274    #[inline]
275    fn gen_char(&mut self, min: Bound<&char>, max: Bound<&char>) -> Option<char> {
276        <D as DynDriver>::gen_char(self, min, max)
277    }
278
279    #[inline]
280    fn gen_bool(&mut self, probability: Option<f32>) -> Option<bool> {
281        <D as DynDriver>::gen_bool(self, probability)
282    }
283
284    #[inline]
285    fn gen_from_bytes<Hint, Gen, T>(&mut self, hint: Hint, mut produce: Gen) -> Option<T>
286    where
287        Hint: FnOnce() -> (usize, Option<usize>),
288        Gen: FnMut(&[u8]) -> Option<(usize, T)>,
289    {
290        let mut value = None;
291        let mut hint = hint_fn(hint);
292        <D as DynDriver>::gen_from_bytes(self, &mut hint, &mut |bytes| {
293            let (len, v) = produce(bytes)?;
294            value = Some(v);
295            Some(len)
296        })?;
297        value
298    }
299}
300
301#[derive(Clone, Default, Debug)]
302pub struct Object<D: super::Driver>(pub D);
303
304impl<D: Driver> ops::Deref for Object<D> {
305    type Target = D;
306
307    #[inline]
308    fn deref(&self) -> &Self::Target {
309        &self.0
310    }
311}
312
313impl<D: Driver> ops::DerefMut for Object<D> {
314    #[inline]
315    fn deref_mut(&mut self) -> &mut Self::Target {
316        &mut self.0
317    }
318}
319
320impl<D: super::Driver> DynDriver for Object<D> {
321    #[inline]
322    fn depth(&self) -> usize {
323        <D as Driver>::depth(self)
324    }
325
326    #[inline]
327    fn set_depth(&mut self, depth: usize) {
328        <D as Driver>::set_depth(self, depth)
329    }
330
331    #[inline]
332    fn max_depth(&self) -> usize {
333        <D as Driver>::max_depth(self)
334    }
335
336    #[inline]
337    fn gen_variant(&mut self, variants: usize, base_case: usize) -> Option<usize> {
338        <D as Driver>::gen_variant(self, variants, base_case)
339    }
340
341    #[inline]
342    fn gen_u8(&mut self, min: Bound<&u8>, max: Bound<&u8>) -> Option<u8> {
343        <D as Driver>::gen_u8(self, min, max)
344    }
345
346    #[inline]
347    fn gen_i8(&mut self, min: Bound<&i8>, max: Bound<&i8>) -> Option<i8> {
348        <D as Driver>::gen_i8(self, min, max)
349    }
350
351    #[inline]
352    fn gen_u16(&mut self, min: Bound<&u16>, max: Bound<&u16>) -> Option<u16> {
353        <D as Driver>::gen_u16(self, min, max)
354    }
355
356    #[inline]
357    fn gen_i16(&mut self, min: Bound<&i16>, max: Bound<&i16>) -> Option<i16> {
358        <D as Driver>::gen_i16(self, min, max)
359    }
360
361    #[inline]
362    fn gen_u32(&mut self, min: Bound<&u32>, max: Bound<&u32>) -> Option<u32> {
363        <D as Driver>::gen_u32(self, min, max)
364    }
365
366    #[inline]
367    fn gen_i32(&mut self, min: Bound<&i32>, max: Bound<&i32>) -> Option<i32> {
368        <D as Driver>::gen_i32(self, min, max)
369    }
370
371    #[inline]
372    fn gen_u64(&mut self, min: Bound<&u64>, max: Bound<&u64>) -> Option<u64> {
373        <D as Driver>::gen_u64(self, min, max)
374    }
375
376    #[inline]
377    fn gen_i64(&mut self, min: Bound<&i64>, max: Bound<&i64>) -> Option<i64> {
378        <D as Driver>::gen_i64(self, min, max)
379    }
380
381    #[inline]
382    fn gen_u128(&mut self, min: Bound<&u128>, max: Bound<&u128>) -> Option<u128> {
383        <D as Driver>::gen_u128(self, min, max)
384    }
385
386    #[inline]
387    fn gen_i128(&mut self, min: Bound<&i128>, max: Bound<&i128>) -> Option<i128> {
388        <D as Driver>::gen_i128(self, min, max)
389    }
390
391    #[inline]
392    fn gen_usize(&mut self, min: Bound<&usize>, max: Bound<&usize>) -> Option<usize> {
393        <D as Driver>::gen_usize(self, min, max)
394    }
395
396    #[inline]
397    fn gen_isize(&mut self, min: Bound<&isize>, max: Bound<&isize>) -> Option<isize> {
398        <D as Driver>::gen_isize(self, min, max)
399    }
400
401    #[inline]
402    fn gen_f32(&mut self, min: Bound<&f32>, max: Bound<&f32>) -> Option<f32> {
403        <D as Driver>::gen_f32(self, min, max)
404    }
405
406    #[inline]
407    fn gen_f64(&mut self, min: Bound<&f64>, max: Bound<&f64>) -> Option<f64> {
408        <D as Driver>::gen_f64(self, min, max)
409    }
410
411    #[inline]
412    fn gen_char(&mut self, min: Bound<&char>, max: Bound<&char>) -> Option<char> {
413        <D as Driver>::gen_char(self, min, max)
414    }
415
416    #[inline]
417    fn gen_bool(&mut self, probability: Option<f32>) -> Option<bool> {
418        <D as Driver>::gen_bool(self, probability)
419    }
420
421    #[inline]
422    fn gen_from_bytes(
423        &mut self,
424        hint: &mut dyn FnMut() -> (usize, Option<usize>),
425        produce: &mut dyn FnMut(&[u8]) -> Option<usize>,
426    ) -> Option<()> {
427        <D as Driver>::gen_from_bytes(self, hint, |bytes| {
428            let len = produce(bytes)?;
429            Some((len, ()))
430        })?;
431        Some(())
432    }
433}
434
435#[cfg(test)]
436mod tests {
437    use super::*;
438
439    #[allow(dead_code)]
440    fn assert_object_safe(_: &dyn DynDriver) {}
441
442    #[allow(dead_code)]
443    fn assert_dyn_cast<T: 'static + Driver>(driver: T) -> Box<dyn DynDriver> {
444        Box::new(Object(driver))
445    }
446}
bolero_generator/driver/object.rs

bolero_generator/driver/
object.rs
