pk2 0.3.0

Crate for interacting with Silkroad Online's pk2 archive format
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Windows `FILETIME`

/// Windows `FILETIME`
#[allow(non_snake_case, clippy::upper_case_acronyms)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

impl Default for FILETIME {
    fn default() -> Self {
        Self { dwLowDateTime: Self::MS_EPOCH as u32, dwHighDateTime: (Self::MS_EPOCH >> 32) as u32 }
    }
}

impl FILETIME {
    const MS_EPOCH: u64 = 11_6444_7360_0000_0000;
}

#[cfg(feature = "std")]
mod std_impls {
    use std::time::SystemTime;

    use crate::FILETIME;

    impl FILETIME {
        const RESOLUTION_SCALE: u128 = 100;

        #[inline]
        pub fn now() -> Self {
            SystemTime::now().into()
        }

        pub fn into_systime(self) -> Option<SystemTime> {
            let FILETIME { dwLowDateTime: low, dwHighDateTime: high } = self;
            let ftime = ((high as u64) << 32) | low as u64;
            let nanos =
                ftime.checked_sub(FILETIME::MS_EPOCH)? * (FILETIME::RESOLUTION_SCALE as u64);
            Some(SystemTime::UNIX_EPOCH + core::time::Duration::from_nanos(nanos))
        }
    }

    impl From<SystemTime> for FILETIME {
        fn from(time: SystemTime) -> Self {
            let duration = time.duration_since(SystemTime::UNIX_EPOCH).unwrap();
            let ftime = (duration.as_nanos() / Self::RESOLUTION_SCALE) as u64 + Self::MS_EPOCH;
            FILETIME { dwLowDateTime: ftime as u32, dwHighDateTime: (ftime >> 32) as u32 }
        }
    }

    #[test]
    fn test_convert_roundtrip() {
        use core::time::Duration;

        let now = SystemTime::now();
        let ftime = FILETIME::from(now);
        let round_trip = ftime.into_systime().unwrap();
        // we compare it this way because the conversion loses precision due to the
        // division by 100. So comparing it by dividing the nanoseconds we will get a
        // lossless comparison for systems that have a higher timer resolution.
        assert_eq!(
            now.duration_since(SystemTime::UNIX_EPOCH)
                .as_ref()
                .map(Duration::as_nanos)
                .map(|nanos| nanos / FILETIME::RESOLUTION_SCALE)
                .unwrap(),
            round_trip
                .duration_since(SystemTime::UNIX_EPOCH)
                .as_ref()
                .map(Duration::as_nanos)
                .map(|nanos| nanos / FILETIME::RESOLUTION_SCALE)
                .unwrap()
        );
    }
}