pub struct ZigZagCodec<T, P> { /* private fields */ }Expand description
Type-level unchecked ZigZag + unsigned LEB128 codec.
Encoding is always canonical; P only affects decoding. Encoding-only
callers should conventionally use NonStrict because no decoding policy
is applied on that path.
§Type Parameters
T: Signed integer value type to decode from ZigZag-encoded LEB128 bytes and encode into ZigZag-encoded LEB128 bytes.P: Required type-level decoding policy implementingLeb128DecodePolicyfor the underlying unsigned LEB128 payload. Usecrate::Strictto reject non-canonical inputs, orNonStrictto accept non-canonical inputs. This parameter does not affect canonical encoding.
The decoding policy is intentionally required so wire-format callers make
the canonicality contract explicit.
The underlying unsigned LEB128 payload remains subject to its target
integer’s maximum decode width and terminal payload bits, including under
NonStrict. See that policy’s documentation for the width limits.
use qubit_codec_binary::ZigZagCodec;
let _ = ZigZagCodec::<i64>::default();§Examples
use qubit_codec_binary::{
NonStrict,
ZigZagCodec,
};
let mut output = [0_u8; ZigZagCodec::<i64, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE];
let written = unsafe {
ZigZagCodec::<i64, NonStrict>::encode(-42, &mut output, 0)
};
assert_eq!(1, written);
let (decoded, consumed) = unsafe {
ZigZagCodec::<i64, NonStrict>::decode(&output[..written], 0)
}.expect("canonical ZigZag LEB128 value should decode");
assert_eq!(-42, decoded);
assert_eq!(1, consumed.get());Implementations§
Source§impl<P> ZigZagCodec<i8, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<i8, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(i8, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(i8, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(value: i8, output: &mut [u8], output_index: usize) -> usize
pub unsafe fn encode(value: i8, output: &mut [u8], output_index: usize) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Source§impl<P> ZigZagCodec<i16, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<i16, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(i16, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(i16, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(
value: i16,
output: &mut [u8],
output_index: usize,
) -> usize
pub unsafe fn encode( value: i16, output: &mut [u8], output_index: usize, ) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Source§impl<P> ZigZagCodec<i32, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<i32, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(i32, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(i32, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(
value: i32,
output: &mut [u8],
output_index: usize,
) -> usize
pub unsafe fn encode( value: i32, output: &mut [u8], output_index: usize, ) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Source§impl<P> ZigZagCodec<i64, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<i64, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(i64, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(i64, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(
value: i64,
output: &mut [u8],
output_index: usize,
) -> usize
pub unsafe fn encode( value: i64, output: &mut [u8], output_index: usize, ) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Source§impl<P> ZigZagCodec<i128, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<i128, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(i128, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(i128, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(
value: i128,
output: &mut [u8],
output_index: usize,
) -> usize
pub unsafe fn encode( value: i128, output: &mut [u8], output_index: usize, ) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Source§impl<P> ZigZagCodec<isize, P>where
P: Leb128DecodePolicy,
impl<P> ZigZagCodec<isize, P>where
P: Leb128DecodePolicy,
Sourcepub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
pub const MIN_UNITS_PER_VALUE: usize = <Self as Codec>::MIN_UNITS_PER_VALUE
Minimum number of bytes that can represent a complete value.
Sourcepub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
pub const MAX_ENCODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_ENCODE_UNITS_PER_VALUE
Maximum number of bytes emitted when encoding this type.
Sourcepub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
pub const MAX_DECODE_UNITS_PER_VALUE: usize = <Self as Codec>::MAX_DECODE_UNITS_PER_VALUE
Maximum number of bytes consumed when decoding this type.
Sourcepub unsafe fn decode(
input: &[u8],
input_index: usize,
) -> Result<(isize, NonZeroUsize), Leb128DecodeError>
pub unsafe fn decode( input: &[u8], input_index: usize, ) -> Result<(isize, NonZeroUsize), Leb128DecodeError>
Decodes a value from input starting at input_index without
bounds checks.
§Parameters
input: Source byte buffer.input_index: Start index ininput.
§Returns
Returns the decoded value and the non-zero number of consumed bytes.
§Errors
Returns Leb128DecodeError if the underlying LEB128 bytes are
incomplete, malformed, or non-canonical under strict policy.
§Safety
The caller must guarantee that input_index is a valid boundary
and at least Self::MIN_UNITS_PER_VALUE byte is readable
from input_index.
Sourcepub unsafe fn encode(
value: isize,
output: &mut [u8],
output_index: usize,
) -> usize
pub unsafe fn encode( value: isize, output: &mut [u8], output_index: usize, ) -> usize
Encodes value into output starting at output_index without
bounds checks.
§Parameters
value: Value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of written bytes.
§Safety
The caller must guarantee that the canonical ZigZag LEB128 byte
width of value is writable starting at output_index.
Reserving Self::MAX_ENCODE_UNITS_PER_VALUE bytes always satisfies
this requirement; for a known value, the exact
Codec::encode_len is sufficient.
Trait Implementations§
Source§impl<P> Codec for ZigZagCodec<i8, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<i8, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u8, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u8, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u8, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u8, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &i8) -> usize
fn encode_len(&self, value: &i8) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(i8, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(i8, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &i8,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &i8, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read moreSource§impl<P> Codec for ZigZagCodec<i16, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<i16, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u16, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u16, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u16, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u16, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &i16) -> usize
fn encode_len(&self, value: &i16) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(i16, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(i16, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &i16,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &i16, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read moreSource§impl<P> Codec for ZigZagCodec<i32, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<i32, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u32, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u32, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u32, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u32, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &i32) -> usize
fn encode_len(&self, value: &i32) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(i32, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(i32, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &i32,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &i32, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read moreSource§impl<P> Codec for ZigZagCodec<i64, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<i64, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u64, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u64, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u64, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u64, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &i64) -> usize
fn encode_len(&self, value: &i64) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(i64, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(i64, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &i64,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &i64, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read moreSource§impl<P> Codec for ZigZagCodec<i128, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<i128, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u128, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<u128, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u128, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<u128, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &i128) -> usize
fn encode_len(&self, value: &i128) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(i128, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(i128, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &i128,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &i128, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read moreSource§impl<P> Codec for ZigZagCodec<isize, P>where
P: Leb128DecodePolicy,
impl<P> Codec for ZigZagCodec<isize, P>where
P: Leb128DecodePolicy,
Source§const MIN_UNITS_PER_VALUE: usize = 1
const MIN_UNITS_PER_VALUE: usize = 1
Minimum bytes readable before decoding can be attempted.
Source§const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<usize, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
const MAX_ENCODE_UNITS_PER_VALUE: usize = Leb128Codec<usize, NonStrict>::MAX_ENCODE_UNITS_PER_VALUE
Maximum bytes emitted by canonical ZigZag plus unsigned LEB128 encoding.
Source§const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<usize, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
const MAX_DECODE_UNITS_PER_VALUE: usize = Leb128Codec<usize, NonStrict>::MAX_DECODE_UNITS_PER_VALUE
Maximum bytes consumed by decoding this signed integer type.
Source§type DecodeError = Leb128DecodeError
type DecodeError = Leb128DecodeError
Detailed errors for incomplete, malformed, or policy-rejected input.
Source§type EncodeError = !
type EncodeError = !
Encoding is infallible for every value of this signed integer type.
Source§fn encode_len(&self, value: &isize) -> usize
fn encode_len(&self, value: &isize) -> usize
Returns the exact width of the canonical unsigned LEB128 encoding
of value after ZigZag mapping.
§Parameters
value: Signed integer value whose encoded width is queried.
§Returns
Returns a width of at least one byte and no more than
Self::MAX_ENCODE_UNITS_PER_VALUE. The decoding policy does not
affect this length.
Source§unsafe fn decode(
&mut self,
input: &[u8],
input_index: usize,
) -> Result<(isize, NonZeroUsize), DecodeFailure<Self::DecodeError>>
unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<(isize, NonZeroUsize), DecodeFailure<Self::DecodeError>>
Decodes one ZigZag-mapped unsigned LEB128 value and reports its byte consumption.
§Parameters
input: Source bytes.input_index: Start index of the encoded value.
§Returns
Returns the signed value and the non-zero number of bytes consumed.
§Errors
Returns DecodeFailure::Incomplete with the detailed error
retained as its source and a minimum total byte requirement when
a valid prefix needs more input. Returns DecodeFailure::Invalid
with the detailed error and consumed-byte count for malformed
input or, under crate::Strict, a non-canonical underlying
unsigned LEB128 representation. The required count is a lower
bound, not a guarantee that decoding will succeed at that length.
The consumed count is not a guaranteed protocol-field recovery
boundary. Non-strict decoding still enforces the target integer’s
maximum width and terminal payload-bit limits.
§Safety
input_index must be a valid boundary and at least
Self::MIN_UNITS_PER_VALUE bytes must be readable there.
Source§unsafe fn encode(
&mut self,
value: &isize,
output: &mut [u8],
output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode( &mut self, value: &isize, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>
Encodes one value using canonical ZigZag mapping followed by unsigned LEB128 encoding.
§Parameters
value: Signed integer value to encode.output: Destination byte buffer.output_index: Start index inoutput.
§Returns
Returns the number of bytes written, equal to
Self::encode_len for value.
§Errors
This implementation uses Infallible; every value of the
signed integer type can be encoded.
§Safety
The caller must ensure Codec::can_encode_value returned
true for value. Starting at output_index, provide either
the exact Self::encode_len capacity for value or at least
Self::MAX_ENCODE_UNITS_PER_VALUE writable bytes.
Source§const MAX_ENCODE_RESET_UNITS: usize = 0
const MAX_ENCODE_RESET_UNITS: usize = 0
Source§const MAX_ENCODE_FINISH_UNITS: usize = 0
const MAX_ENCODE_FINISH_UNITS: usize = 0
Source§const MAX_DECODE_RESET_VALUES: usize = 0
const MAX_DECODE_RESET_VALUES: usize = 0
Source§const MAX_DECODE_FINISH_VALUES: usize = 0
const MAX_DECODE_FINISH_VALUES: usize = 0
Source§fn can_encode_value(&self, _value: &Self::Value) -> bool
fn can_encode_value(&self, _value: &Self::Value) -> bool
value is in this codec’s encodable value domain. Read moreSource§unsafe fn encode_reset(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn encode_finish(
&mut self,
_output: &mut [Self::Unit],
_output_index: usize,
) -> Result<usize, Self::EncodeError>
unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>
Source§unsafe fn decode_reset(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
Source§unsafe fn decode_eof(
&mut self,
input: &[Self::Unit],
input_index: usize,
) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>
Source§unsafe fn decode_finish(
&mut self,
_output: &mut [Self::Value],
_output_index: usize,
) -> Result<usize, Self::DecodeError>
unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>
output. Read more