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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/*******************************************************************************
*
* Copyright (c) 2026 Haixing Hu.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0.
*
******************************************************************************/
//! Buffered encoder adapter backed by a low-level codec.
use super::{
BufferedEncoder,
BufferedTranscoder,
FinishError,
TranscodeProgress,
buffered_encode_engine::BufferedEncodeEngine,
codec_buffered_encode_hooks::CodecBufferedEncodeHooks,
};
use crate::{
CapacityError,
Codec,
CodecEncodeError,
};
/// Encodes values into caller-provided output units by using a [`Codec`].
///
/// `CodecBufferedEncoder` is the default bridge from the low-level unchecked
/// [`Codec`] contract to the buffered [`BufferedTranscoder`] and [`BufferedEncoder`]
/// contracts. It encodes complete values only; when the remaining output
/// capacity is smaller than `codec.max_units_per_value()`, it stops before
/// consuming the next input value and reports [`crate::TranscodeStatus::NeedOutput`].
///
/// # Type Parameters
///
/// - `C`: Low-level codec used to encode values.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct CodecBufferedEncoder<C> {
/// Common buffered encoding engine.
engine: BufferedEncodeEngine<C, CodecBufferedEncodeHooks>,
}
impl<C> CodecBufferedEncoder<C>
where
C: Codec,
{
/// Creates a buffered encoder backed by `codec`.
///
/// # Parameters
///
/// - `codec`: Low-level codec used to encode values.
///
/// # Returns
///
/// Returns a buffered encoder adapter for the supplied codec.
#[must_use]
#[inline(always)]
pub const fn new(codec: C) -> Self {
Self {
engine: BufferedEncodeEngine::new(codec, CodecBufferedEncodeHooks),
}
}
}
impl<C> BufferedTranscoder<C::Value, C::Unit> for CodecBufferedEncoder<C>
where
C: Codec,
{
type Error = CodecEncodeError<C::EncodeError>;
/// Returns the maximum number of output units needed for `input_len` values.
///
/// # Parameters
///
/// - `input_len`: Logical input values the caller plans to encode.
///
/// # Returns
///
/// Returns a conservative upper bound for output units.
#[inline(always)]
fn max_output_len(&self, input_len: usize) -> Result<usize, CapacityError> {
self.engine.max_output_len(input_len)
}
/// Returns the maximum units emitted by finishing internal state.
///
/// # Returns
///
/// Returns the number of units that may be emitted by finishing state.
#[inline(always)]
fn max_finish_output_len(&self) -> Result<usize, CapacityError> {
Ok(self.engine.max_finish_output_len())
}
/// Resets hook-owned state.
///
/// # Returns
///
/// Returns unit `()`.
#[inline(always)]
fn reset(&mut self) {
self.engine.reset();
}
/// Encodes values into the supplied output buffer.
///
/// # Parameters
///
/// - `input`: Input value slice.
/// - `input_index`: Absolute input index where encoding starts.
/// - `output`: Destination unit slice.
/// - `output_index`: Absolute output index where writing starts.
///
/// # Returns
///
/// Returns conversion progress for consumed input and produced output units.
///
/// # Errors
///
/// Returns an encode error when indices are invalid or when encoding cannot
/// continue under current policy.
#[inline(always)]
fn transcode(
&mut self,
input: &[C::Value],
input_index: usize,
output: &mut [C::Unit],
output_index: usize,
) -> Result<TranscodeProgress, Self::Error> {
self.engine.transcode(input, input_index, output, output_index)
}
/// Finishes internally retained output after EOF.
///
/// # Parameters
///
/// - `output`: Destination unit slice for finalization output.
/// - `output_index`: Absolute output index where writing starts.
///
/// # Returns
///
/// Returns the number of units written by finalization.
///
/// # Errors
///
/// Returns a finish error if retained output cannot be fully emitted.
#[inline(always)]
fn finish(&mut self, output: &mut [C::Unit], output_index: usize) -> Result<usize, FinishError<Self::Error>> {
self.engine.finish(output, output_index)
}
}
impl<C> BufferedEncoder<C::Value, C::Unit> for CodecBufferedEncoder<C> where C: Codec {}