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
/*******************************************************************************
*
* Copyright (c) 2026 Haixing Hu.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0.
*
******************************************************************************/
//! Policy hooks used by the default codec-backed buffered converter.
use super::{
buffered_convert_hooks::BufferedConvertHooks,
codec_buffered_decode_hooks::CodecBufferedDecodeHooks,
codec_buffered_encode_hooks::CodecBufferedEncodeHooks,
};
use crate::{
Codec,
CodecConvertError,
CodecDecodeError,
CodecEncodeError,
};
/// Policy hooks for [`super::CodecBufferedConverter`].
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub(super) struct CodecBufferedConvertHooks;
impl CodecBufferedConvertHooks {
/// Creates codec-backed converter hooks.
///
/// # Returns
///
/// Returns stateless converter hooks.
#[must_use]
#[inline(always)]
pub(super) const fn new() -> Self {
Self
}
}
impl<D, E> BufferedConvertHooks<D, E> for CodecBufferedConvertHooks
where
D: Codec,
E: Codec<Value = D::Value>,
{
type DecodeError = CodecDecodeError<D::DecodeError>;
type DecodeHooks = CodecBufferedDecodeHooks;
type EncodeError = CodecEncodeError<E::EncodeError>;
type EncodeHooks = CodecBufferedEncodeHooks;
type Error = CodecConvertError<D::DecodeError, E::EncodeError>;
/// Creates strict codec-backed decode hooks.
///
/// # Parameters
///
/// - `_decode_codec`: Source codec for reference only.
/// - `_encode_codec`: Target codec for reference only.
///
/// # Returns
///
/// Returns decode hooks that map decode failures directly to codec decode errors.
#[inline(always)]
fn create_decode_hooks(&self, _decode_codec: &D, _encode_codec: &E) -> Self::DecodeHooks {
CodecBufferedDecodeHooks
}
/// Creates strict codec-backed encode hooks.
///
/// # Parameters
///
/// - `_decode_codec`: Source codec for reference only.
/// - `_encode_codec`: Target codec for reference only.
///
/// # Returns
///
/// Returns encode hooks that map encode failures directly to codec encode errors.
#[inline(always)]
fn create_encode_hooks(&self, _decode_codec: &D, _encode_codec: &E) -> Self::EncodeHooks {
CodecBufferedEncodeHooks
}
/// Maps decoder errors into converter decode errors.
///
/// # Parameters
///
/// - `error`: Decode-side error from the source codec layer.
///
/// # Returns
///
/// Returns a converter-level decode error.
#[inline(always)]
fn map_decode_error(&self, error: Self::DecodeError) -> Self::Error {
CodecConvertError::decode(error)
}
/// Maps encoder errors into converter encode errors.
///
/// # Parameters
///
/// - `error`: Encode-side error from the target codec layer.
///
/// # Returns
///
/// Returns a converter-level encode error.
#[inline]
fn map_encode_error(&self, error: Self::EncodeError) -> Self::Error {
CodecConvertError::encode(error)
}
/// Creates an invalid source input index error.
///
/// # Parameters
///
/// - `_decode_codec`: Source codec for which the caller-supplied index is invalid.
/// - `index`: Invalid source input index.
/// - `input_len`: Length of the source input slice.
///
/// # Returns
///
/// Returns a converter-level error describing the invalid source index.
#[inline(always)]
fn invalid_input_index(&self, _decode_codec: &D, index: usize, input_len: usize) -> Self::Error {
CodecConvertError::decode(CodecDecodeError::invalid_input_index(index, input_len))
}
/// Resets stateless codec-backed converter hooks.
///
/// # Parameters
///
/// - `self`: Converter hooks instance.
///
/// # Returns
///
/// Returns unit `()`.
#[inline(always)]
fn reset(&mut self) {}
}