Struct ZigZagCodec 

pub struct ZigZagCodec<T, P = NonStrict> { /* private fields */ }

Type-level unchecked ZigZag + unsigned LEB128 codec.

Type Parameters

• T: Signed integer value type to decode from ZigZag-encoded LEB128 bytes and encode into ZigZag-encoded LEB128 bytes.
• P: Type-level decoding policy implementing Leb128DecodePolicy for the underlying unsigned LEB128 payload. Use crate::Strict to reject non-canonical inputs, or NonStrict to accept non-canonical inputs.

Examples

use qubit_codec_binary::{
    NonStrict,
    ZigZagCodec,
};

let mut output = [0_u8; ZigZagCodec::<i64, NonStrict>::MAX_UNITS_PER_VALUE];
let written = unsafe {
    ZigZagCodec::<i64, NonStrict>::encode_unchecked(-42, &mut output, 0)
};
assert_eq!(1, written);

let (decoded, consumed) = unsafe {
    ZigZagCodec::<i64, NonStrict>::decode_unchecked(&output[..written], 0)
}.expect("canonical ZigZag LEB128 value should decode");
assert_eq!(-42, decoded);
assert_eq!(1, consumed.get());

Implementations

impl<P> ZigZagCodec<i8, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<u8, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(i8, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: i8, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

impl<P> ZigZagCodec<i16, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<u16, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(i16, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: i16, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

impl<P> ZigZagCodec<i32, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<u32, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(i32, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: i32, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

impl<P> ZigZagCodec<i64, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<u64, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(i64, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: i64, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

impl<P> ZigZagCodec<i128, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<u128, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(i128, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: i128, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

impl<P> ZigZagCodec<isize, P>

where P: Leb128DecodePolicy,

pub const MIN_UNITS_PER_VALUE: usize = 1

Minimum number of bytes that can represent a complete value.

pub const MAX_UNITS_PER_VALUE: usize = Leb128Codec<usize, NonStrict>::MAX_UNITS_PER_VALUE

Maximum number of bytes required to encode or decode this type.

pub unsafe fn decode_unchecked( input: &[u8], index: usize, ) -> Result<(isize, NonZeroUsize), Leb128DecodeError>

Decodes a value from input starting at index without bounds checks.

Parameters

• input: Source byte buffer.
• index: Start index in input.

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 index is a valid boundary and at least Self::MIN_UNITS_PER_VALUE byte is readable from index.

pub unsafe fn encode_unchecked( value: isize, output: &mut [u8], index: usize, ) -> usize

Encodes value into output starting at index without bounds checks.

Parameters

• value: Value to encode.
• output: Destination byte buffer.
• index: Start index in output.

Returns

Returns the number of written bytes.

Safety

The caller must guarantee that output.as_mut_ptr().add(index) is valid to write Self::MAX_UNITS_PER_VALUE bytes.

Trait Implementations

impl<T: Clone, P: Clone> Clone for ZigZagCodec<T, P>

fn clone(&self) -> ZigZagCodec<T, P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P> Codec for ZigZagCodec<i128, P>

where P: Leb128DecodePolicy,

type Value = i128

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(i128, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &i128, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<P> Codec for ZigZagCodec<i16, P>

where P: Leb128DecodePolicy,

type Value = i16

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(i16, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &i16, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<P> Codec for ZigZagCodec<i32, P>

where P: Leb128DecodePolicy,

type Value = i32

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(i32, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &i32, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<P> Codec for ZigZagCodec<i64, P>

where P: Leb128DecodePolicy,

type Value = i64

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(i64, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &i64, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<P> Codec for ZigZagCodec<i8, P>

where P: Leb128DecodePolicy,

type Value = i8

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(i8, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &i8, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<P> Codec for ZigZagCodec<isize, P>

where P: Leb128DecodePolicy,

type Value = isize

Logical value decoded from or encoded into the buffer.

type Unit = u8

Buffer unit used by the encoded representation.

type DecodeError = Leb128DecodeError

Error reported when decoding malformed units.

type EncodeError = Infallible

Error reported when encoding an unsupported value.

fn min_units_per_value(&self) -> NonZeroUsize

Returns the minimum possible unit count for one encoded value.

fn max_units_per_value(&self) -> NonZeroUsize

Returns the maximum non-zero unit count needed to encode or decode one value.

unsafe fn decode_unchecked( &self, input: &[u8], index: usize, ) -> Result<(isize, NonZeroUsize), Self::DecodeError>

Decodes one value from input starting at index.

unsafe fn encode_unchecked( &self, value: &isize, output: &mut [u8], index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one borrowed value into output starting at index.

impl<T: Copy, P: Copy> Copy for ZigZagCodec<T, P>

impl<T: Debug, P: Debug> Debug for ZigZagCodec<T, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, P: Default> Default for ZigZagCodec<T, P>

fn default() -> ZigZagCodec<T, P>

Returns the “default value” for a type.

impl<T: Eq, P: Eq> Eq for ZigZagCodec<T, P>

impl<T: PartialEq, P: PartialEq> PartialEq for ZigZagCodec<T, P>

fn eq(&self, other: &ZigZagCodec<T, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, P> StructuralPartialEq for ZigZagCodec<T, P>