use std::fmt;
use crate::error::WasmCheckError;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
pub struct Compression {
gzip_level: u32,
brotli_quality: i32,
}
impl Compression {
pub const CDN_GZIP_LEVEL: u32 = 6;
pub const CDN_BROTLI_QUALITY: i32 = 5;
pub const MAX_GZIP_LEVEL: u32 = 9;
pub const MAX_BROTLI_QUALITY: i32 = 11;
#[must_use]
pub const fn cdn() -> Self {
Self {
gzip_level: Self::CDN_GZIP_LEVEL,
brotli_quality: Self::CDN_BROTLI_QUALITY,
}
}
#[must_use]
pub const fn max() -> Self {
Self {
gzip_level: Self::MAX_GZIP_LEVEL,
brotli_quality: Self::MAX_BROTLI_QUALITY,
}
}
pub fn new(gzip_level: u32, brotli_quality: i32) -> Result<Self, WasmCheckError> {
let compression = Self {
gzip_level,
brotli_quality,
};
compression.validate()?;
Ok(compression)
}
#[must_use]
pub const fn gzip_level(&self) -> u32 {
self.gzip_level
}
#[must_use]
pub const fn brotli_quality(&self) -> i32 {
self.brotli_quality
}
pub fn with_gzip_level(self, level: u32) -> Result<Self, WasmCheckError> {
Self::new(level, self.brotli_quality)
}
pub fn with_brotli_quality(self, quality: i32) -> Result<Self, WasmCheckError> {
Self::new(self.gzip_level, quality)
}
#[must_use]
pub const fn is_default(&self) -> bool {
self.gzip_level == Self::CDN_GZIP_LEVEL && self.brotli_quality == Self::CDN_BROTLI_QUALITY
}
fn validate(&self) -> Result<(), WasmCheckError> {
if self.gzip_level > Self::MAX_GZIP_LEVEL {
return Err(WasmCheckError::InvalidGzipLevel(i64::from(self.gzip_level)));
}
if self.brotli_quality < 0 || self.brotli_quality > Self::MAX_BROTLI_QUALITY {
return Err(WasmCheckError::InvalidBrotliQuality(i64::from(
self.brotli_quality,
)));
}
Ok(())
}
}
impl Default for Compression {
fn default() -> Self {
Self::cdn()
}
}
impl fmt::Display for Compression {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"gzip level {}, brotli quality {}",
self.gzip_level, self.brotli_quality
)
}
}
impl<'de> serde::Deserialize<'de> for Compression {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(serde::Deserialize)]
struct Raw {
gzip_level: Option<u32>,
brotli_quality: Option<i32>,
}
let raw = Raw::deserialize(deserializer)?;
let cdn = Compression::cdn();
Compression::new(
raw.gzip_level.unwrap_or(cdn.gzip_level()),
raw.brotli_quality.unwrap_or(cdn.brotli_quality()),
)
.map_err(serde::de::Error::custom)
}
}