opendrive 0.1.0+1.7.0

OpenDRIVE parser and writer for Rust
Documentation 
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

use std::ops::RangeInclusive;

pub trait NotNan {
    fn not_nan_f32(&mut self) -> arbitrary::Result<f32>;
    fn not_nan_f64(&mut self) -> arbitrary::Result<f64>;
}

impl<'a> NotNan for arbitrary::Unstructured<'a> {
    fn not_nan_f32(&mut self) -> arbitrary::Result<f32> {
        Ok(f32::from_bits(
            self.arbitrary::<f32>()?.to_bits() & !f32::NAN.to_bits(),
        ))
    }

    fn not_nan_f64(&mut self) -> arbitrary::Result<f64> {
        Ok(f64::from_bits(
            self.arbitrary::<f64>()?.to_bits() & !f64::NAN.to_bits(),
        ))
    }
}

pub trait ArbitraryStrings {
    fn arbitrary_string(
        &mut self,
        size: RangeInclusive<usize>,
        characters: &[RangeInclusive<char>],
    ) -> arbitrary::Result<String>;
}

impl<'a> ArbitraryStrings for arbitrary::Unstructured<'a> {
    fn arbitrary_string(
        &mut self,
        size: RangeInclusive<usize>,
        characters: &[RangeInclusive<char>],
    ) -> arbitrary::Result<String> {
        let len = self.arbitrary_len::<String>()?;
        let len = len.min(*size.end()).max(*size.start());
        let mut string = String::with_capacity(len);

        while string.len() < len && !characters.is_empty() {
            let slice = self.int_in_range(0..=characters.len().saturating_sub(1))?;
            let slice = &characters[slice];
            let character = self.int_in_range(*slice.start() as u32..=*slice.end() as u32)?;
            if let Ok(character) = char::try_from(character) {
                string.push(character);
            }
        }

        Ok(string)
    }
}