extern crate alloc;
#[cfg(any(feature = "enc", feature = "dec"))]
use alloc::vec::Vec;
use embark_format::CodecId;
#[cfg(feature = "dec")]
use embark_format::Error;
mod sealed {
pub trait Sealed {}
}
pub trait Codec: sealed::Sealed {
const ID: CodecId;
}
#[derive(Debug)]
pub struct Store;
impl sealed::Sealed for Store {}
impl Codec for Store {
const ID: CodecId = CodecId::Store;
}
impl Store {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::store::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::store::decompress(input, orig_len)
}
}
#[cfg(feature = "deflate")]
#[derive(Debug)]
pub struct Deflate;
#[cfg(feature = "deflate")]
impl sealed::Sealed for Deflate {}
#[cfg(feature = "deflate")]
impl Codec for Deflate {
const ID: CodecId = CodecId::Deflate;
}
#[cfg(feature = "deflate")]
impl Deflate {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::deflate::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::deflate::decompress(input, orig_len)
}
}
#[cfg(feature = "lz4")]
#[derive(Debug)]
pub struct Lz4;
#[cfg(feature = "lz4")]
impl sealed::Sealed for Lz4 {}
#[cfg(feature = "lz4")]
impl Codec for Lz4 {
const ID: CodecId = CodecId::Lz4;
}
#[cfg(feature = "lz4")]
impl Lz4 {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::lz4::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::lz4::decompress(input, orig_len)
}
}
#[cfg(feature = "snappy")]
#[derive(Debug)]
pub struct Snappy;
#[cfg(feature = "snappy")]
impl sealed::Sealed for Snappy {}
#[cfg(feature = "snappy")]
impl Codec for Snappy {
const ID: CodecId = CodecId::Snappy;
}
#[cfg(feature = "snappy")]
impl Snappy {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::snappy::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::snappy::decompress(input, orig_len)
}
}
#[cfg(feature = "zstd")]
#[derive(Debug)]
pub struct Zstd;
#[cfg(feature = "zstd")]
impl sealed::Sealed for Zstd {}
#[cfg(feature = "zstd")]
impl Codec for Zstd {
const ID: CodecId = CodecId::Zstd;
}
#[cfg(feature = "zstd")]
impl Zstd {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::zstd::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::zstd::decompress(input, orig_len)
}
}
#[cfg(feature = "lzma")]
#[derive(Debug)]
pub struct Lzma;
#[cfg(feature = "lzma")]
impl sealed::Sealed for Lzma {}
#[cfg(feature = "lzma")]
impl Codec for Lzma {
const ID: CodecId = CodecId::Lzma;
}
#[cfg(feature = "lzma")]
impl Lzma {
#[cfg(feature = "enc")]
#[must_use]
pub fn compress(&self, input: &[u8]) -> Vec<u8> {
crate::lzma::compress(input)
}
#[cfg(feature = "dec")]
pub fn decompress(&self, input: &[u8], orig_len: usize) -> Result<Vec<u8>, Error> {
crate::lzma::decompress(input, orig_len)
}
}
#[cfg(all(test, feature = "enc", feature = "dec"))]
mod tests {
use super::*;
#[test]
fn store_roundtrips_via_handle() {
let data = b"handle roundtrip via Store";
let c = Store.compress(data);
assert_eq!(Store.decompress(&c, data.len()).unwrap(), data);
assert_eq!(Store::ID, CodecId::Store);
}
#[cfg(feature = "deflate")]
#[test]
fn deflate_roundtrips_via_handle() {
let data = b"handle roundtrip via Deflate handle roundtrip via Deflate".repeat(4);
let c = Deflate.compress(&data);
assert_eq!(Deflate.decompress(&c, data.len()).unwrap(), data);
assert_eq!(Deflate::ID, CodecId::Deflate);
}
}