mbrotli 0.4.1

Fast Brotli (RFC 7932 and RFC 9841) compression and decompression in safe Rust; encoding is byte-identical to Google's reference encoder
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Owned decode-only prefix storage; no encoder search indexes are constructed.

use crate::dictionary::{DecodeDictionaryError, DecodeDictionaryLimits, DictionaryAttachment};
use alloc::vec::Vec;

#[derive(Debug, Default)]
pub(crate) struct Prefixes {
    #[cfg(feature = "experimental")]
    pub(crate) description: Option<super::decode_serialized::Description>,
    segments: [Vec<u8>; 15],
    count: usize,
    total: u64,
    retained: usize,
}

impl Prefixes {
    pub(crate) fn build(
        attachments: &[DictionaryAttachment<'_>],
        limits: DecodeDictionaryLimits,
    ) -> Result<Self, DecodeDictionaryError> {
        let mut result = Self::default();
        let mut source_bytes = 0u64;
        for attachment in attachments {
            #[cfg(not(feature = "experimental"))]
            let DictionaryAttachment::Raw(source) = attachment;
            #[cfg(feature = "experimental")]
            let source = match attachment {
                DictionaryAttachment::Raw(source) => source,
                DictionaryAttachment::Serialized(source) => source,
            };
            source_bytes = source_bytes
                .checked_add(source.len() as u64)
                .ok_or(DecodeDictionaryError::SizeOverflow)?;
            if let Some(limit) = limits.max_source_bytes
                && source_bytes > limit
            {
                return Err(DecodeDictionaryError::SourceLimitExceeded { limit });
            }
            match attachment {
                DictionaryAttachment::Raw(source) => result.attach(source, limits)?,
                #[cfg(feature = "experimental")]
                DictionaryAttachment::Serialized(source) => {
                    result.attach_serialized(source, limits)?
                }
            }
        }
        Ok(result)
    }

    #[cfg(feature = "experimental")]
    fn attach_serialized(
        &mut self,
        source: &[u8],
        limits: DecodeDictionaryLimits,
    ) -> Result<(), DecodeDictionaryError> {
        let (description, prefix) = super::decode_serialized::Description::parse(
            source,
            self.retained,
            limits.max_owned_bytes,
        )?;
        if description.custom() && self.description.is_some() {
            return Err(DecodeDictionaryError::ConflictingStaticDictionaries);
        }
        let new_bytes = description.retained_bytes();
        // Until the replacement commits, both the old and the new description
        // are live. Account for that peak when copying an embedded prefix.
        self.retained = self
            .retained
            .checked_add(new_bytes)
            .ok_or(DecodeDictionaryError::SizeOverflow)?;
        if !prefix.is_empty() {
            self.attach(&source[prefix], limits)?;
        }
        if let Some(previous) = self.description.take() {
            self.retained -= previous.retained_bytes();
        }
        self.description = description.custom().then_some(description);
        Ok(())
    }

    fn attach(
        &mut self,
        source: &[u8],
        limits: DecodeDictionaryLimits,
    ) -> Result<(), DecodeDictionaryError> {
        if self.count == self.segments.len() {
            return Err(DecodeDictionaryError::TooManyAttachments);
        }
        let next = self
            .retained
            .checked_add(source.len())
            .ok_or(DecodeDictionaryError::SizeOverflow)?;
        if let Some(limit) = limits.max_owned_bytes
            && next > limit
        {
            return Err(DecodeDictionaryError::MemoryLimitExceeded { limit });
        }
        self.total = self
            .total
            .checked_add(source.len() as u64)
            .ok_or(DecodeDictionaryError::SizeOverflow)?;
        let segment = &mut self.segments[self.count];
        segment
            .try_reserve_exact(source.len())
            .map_err(|_| DecodeDictionaryError::AllocationFailed)?;
        segment.extend_from_slice(source);
        self.retained += segment.capacity();
        self.count += 1;
        Ok(())
    }

    pub(crate) const fn count(&self) -> usize {
        self.count
    }
    pub(crate) const fn retained_bytes(&self) -> usize {
        self.retained
    }
    pub(crate) const fn total(&self) -> u64 {
        self.total
    }

    /// Contiguous bytes from `offset` to the end of the segment holding it.
    /// Empty past the end of the prefix, so a caller advances segment by
    /// segment without a separate bounds test.
    pub(crate) fn run_from(&self, mut offset: u64) -> &[u8] {
        for segment in &self.segments[..self.count] {
            if offset < segment.len() as u64 {
                return &segment[offset as usize..];
            }
            offset -= segment.len() as u64;
        }
        &[]
    }
}