reznez 0.0.0

The high accuracy NES Emulator
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
52
53
54
55
56
57
58
59
60
61

use std::str::FromStr;
use std::time::Duration;

#[derive(Clone, Copy, Debug)]
pub struct FrameRate(f64);

#[rustfmt::skip]
impl FrameRate {
    const NTSC:  FrameRate = FrameRate(60.0988);
    const PAL:   FrameRate = FrameRate(50.0070);
    const DENDY: FrameRate = FrameRate(50.0070);
    const RGB:   FrameRate = FrameRate(60.0985);

    pub fn new(value: f64) -> Result<FrameRate, String> {
        if value.is_normal() {
            Ok(FrameRate(value))
        } else {
            Err("Frame rate must be a normal, non-zero number.".to_string())
        }
    }

    pub fn to_frame_duration(self) -> Duration {
        Duration::from_nanos((1_000_000_000.0 / self.0) as u64)
    }
}

impl FromStr for FrameRate {
    type Err = String;

    #[rustfmt::skip]
    fn from_str(value: &str) -> Result<FrameRate, String> {
        Ok(match value {
            "ntsc"  => FrameRate::NTSC,
            "pal"   => FrameRate::PAL,
            "dendy" => FrameRate::DENDY,
            "rgb"   => FrameRate::RGB,
            _ => {
                let value = f64::from_str(value)
                    .map_err(|err| err.to_string())?;
                FrameRate::new(value)?
            },
        })
    }
}

#[derive(Clone, Copy, Debug)]
pub enum TargetFrameRate {
    Value(FrameRate),
    Unbounded,
}

impl FromStr for TargetFrameRate {
    type Err = String;

    fn from_str(value: &str) -> Result<TargetFrameRate, String> {
        match value {
            "unbounded" => Ok(TargetFrameRate::Unbounded),
            _ => Ok(TargetFrameRate::Value(FrameRate::from_str(value)?)),
        }
    }
}