Skip to main content

ionic/ion/
format.rs

1use crate::ion::{IonError, IonResult};
2
3pub const HEADER_SIZE: usize = 1024;
4pub const FILE_SIGNATURE: [u8; 8] = *b"IONIC\0\0\0";
5pub const FILE_TRAILER: [u8; 8] = *b"\0\0\0CINOI";
6
7pub use crate::ion::version_generated::{
8    CURRENT_VERSION, MAX_SUPPORTED_VERSION, MIN_SUPPORTED_VERSION,
9};
10
11#[allow(clippy::absurd_extreme_comparisons)]
12const _VERSION_POLICY_INVARIANTS: () = {
13    assert!(
14        MIN_SUPPORTED_VERSION <= CURRENT_VERSION,
15        "CURRENT_VERSION must be supported"
16    );
17    assert!(
18        CURRENT_VERSION <= MAX_SUPPORTED_VERSION,
19        "CURRENT_VERSION must be supported"
20    );
21};
22
23#[inline]
24pub fn is_supported(version: u16) -> bool {
25    (MIN_SUPPORTED_VERSION..=MAX_SUPPORTED_VERSION).contains(&version)
26}
27
28#[inline]
29pub fn allow_version(version: u16) -> IonResult<()> {
30    if is_supported(version) {
31        Ok(())
32    } else {
33        Err(IonError::UnsupportedFormatVersion(version))
34    }
35}
36
37pub const CODEC_NONE: u8 = 0;
38pub const CODEC_ZSTD: u8 = 1;
39pub const ZSTD_LEVEL_MIN: u8 = 1;
40pub const ZSTD_LEVEL_MAX: u8 = 22;
41
42#[inline]
43pub fn allow_compression(codec: u8, level: u8) -> IonResult<()> {
44    match codec {
45        CODEC_NONE if level == 0 => Ok(()),
46        CODEC_ZSTD if (ZSTD_LEVEL_MIN..=ZSTD_LEVEL_MAX).contains(&level) => Ok(()),
47        CODEC_NONE | CODEC_ZSTD => Err(IonError::from(format!(
48            "compression level {level} does not match codec {codec}"
49        ))),
50        other => Err(IonError::UnsupportedCodec(other)),
51    }
52}
53
54#[cfg(test)]
55mod tests {
56    use super::*;
57
58    #[test]
59    fn current_version_is_supported() {
60        assert!(is_supported(CURRENT_VERSION));
61    }
62
63    #[test]
64    fn allow_decision_matches_is_supported_for_every_u16() {
65        for version in 0u16..=u16::MAX {
66            match allow_version(version) {
67                Ok(()) => assert!(
68                    is_supported(version),
69                    "allow_version accepted {version} but is_supported says no"
70                ),
71                Err(IonError::UnsupportedFormatVersion(rejected)) => {
72                    assert_eq!(rejected, version, "error must carry the rejected version");
73                    assert!(
74                        !is_supported(version),
75                        "allow_version rejected {version} but is_supported says yes"
76                    );
77                }
78                Err(other) => {
79                    panic!("allow_version returned wrong error variant for {version}: {other:?}")
80                }
81            }
82        }
83    }
84
85    #[test]
86    fn signature_and_trailer_are_eight_bytes() {
87        assert_eq!(FILE_SIGNATURE.len(), 8);
88        assert_eq!(FILE_TRAILER.len(), 8);
89    }
90
91    #[test]
92    fn allow_compression_accepts_matching_codec_and_level() {
93        assert!(allow_compression(CODEC_NONE, 0).is_ok());
94        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MIN).is_ok());
95        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MAX).is_ok());
96    }
97
98    #[test]
99    fn allow_compression_rejects_level_that_does_not_match_codec() {
100        assert!(allow_compression(CODEC_NONE, 1).is_err());
101        assert!(allow_compression(CODEC_ZSTD, 0).is_err());
102        assert!(allow_compression(CODEC_ZSTD, ZSTD_LEVEL_MAX + 1).is_err());
103    }
104
105    #[test]
106    fn allow_compression_rejects_unknown_codec() {
107        match allow_compression(2, 0) {
108            Err(IonError::UnsupportedCodec(2)) => {}
109            other => panic!("expected UnsupportedCodec(2), got {other:?}"),
110        }
111    }
112}