Trait bytecodec::Decode
[−]
[src]
pub trait Decode { type Item; fn decode(&mut self, buf: &[u8], eos: Eos) -> Result<usize>; fn finish_decoding(&mut self) -> Result<Self::Item>; fn requiring_bytes(&self) -> ByteCount; fn is_idle(&self) -> bool { ... } }
This trait allows for decoding items from a byte sequence incrementally.
Associated Types
type Item
The type of items to be decoded.
Required Methods
fn decode(&mut self, buf: &[u8], eos: Eos) -> Result<usize>
Consumes the given buffer (a part of a byte sequence), and proceeds the decoding process.
It returns the number of bytes consumed from the input buffer.
If an item is completely decoded, the next invocation of is_idle
method will return true
.
And if is_idle
method returns true
, decode
method should consume no bytes.
The decoder must consume as many bytes in the buffer as possible.
If an item is not yet decoded but the number of consumed bytes in the last decode
invocation
is smaller than the length of buf
, it means the decoder has been suspended its work in any reasons.
In that case the decoder may require some instructions from clients to resume the work,
but its concrete method is beyond the scope of this trait.
Errors
The following errors may be returned by the decoder:
ErrorKind::DecoderTerminated
:- If all decodable items have been decoded,
the decoder must return this kind of error when
decode
method is called.
- If all decodable items have been decoded,
the decoder must return this kind of error when
ErrorKind::UnexpectedEos
:- The invocation of
eos.is_reached()
returnstrue
despite of the decoder requires more bytes to decode the next item.
- The invocation of
ErrorKind::InvalidInput
:- Decoded items have invalid values
- Invalid parameters were given to decoders
ErrorKind::InconsistentState
:- The state of the decoder bocame inconsistent
- This means the implementation contains a bug
ErrorKind::Other
:- Other errors
fn finish_decoding(&mut self) -> Result<Self::Item>
Finishes the current decoding process and returns the decoded item.
Errors
The following errors may be returned by the decoder:
ErrorKind::IncompleteDecoding
:- The decoding process has not been completed
ErrorKind::DecoderTerminated
:- The decoder has terminated (i.e., cannot decode any more items)
ErrorKind::InconsistentState
:- The state of the decoder bocame inconsistent
- This means the implementation contains a bug
ErrorKind::Other
:- Other errors
fn requiring_bytes(&self) -> ByteCount
Returns the lower bound of the number of bytes needed to decode the next item.
If the decoder does not know the value, it will return ByteCount::Unknown
(e.g., null-terminated strings have no pre-estimable length).
If the decoder returns ByteCount::Finite(0)
, it means one of the followings:
- (a) There is an already decoded item
- The next invocation of
decode()
will return it without consuming any bytes
- The next invocation of
- (b) There are no decodable items
- All decodable items have been decoded, and the decoder cannot do any further works
- In this case, the next invocation of
decode
method will fail.
Provided Methods
fn is_idle(&self) -> bool
Returns true
if there are no items to be decoded by the decoder
at the next invocation of decode
method, otherwise false
.
Typically, true
means the decoder already has a decoded item and
it is waiting for finish_decoding
to be called.
The default implementation returns the result of self.requiring_bytes() == ByteCount::Finite(0)
.
Implementations on Foreign Types
impl<'a, D: ?Sized + Decode> Decode for &'a mut D
[src]
impl<D: ?Sized + Decode> Decode for Box<D>
[src]
Implementors
impl<T> Decode for BincodeDecoder<T> where
T: for<'de> Deserialize<'de>, type Item = T;impl<B: AsRef<[u8]> + AsMut<[u8]> + Copy> Decode for CopyableBytesDecoder<B> type Item = B;
impl<B: AsRef<[u8]> + AsMut<[u8]>> Decode for BytesDecoder<B> type Item = B;
impl Decode for RemainingBytesDecoder type Item = Vec<u8>;
impl<D> Decode for Utf8Decoder<D> where
D: Decode<Item = Vec<u8>>, type Item = String;impl<D, T, F> Decode for Map<D, T, F> where
D: Decode,
F: Fn(D::Item) -> T, type Item = T;impl<D, E, F> Decode for MapErr<D, E, F> where
D: Decode,
F: Fn(Error) -> E,
Error: From<E>, type Item = D::Item;impl<D0, D1, F> Decode for AndThen<D0, D1, F> where
D0: Decode,
D1: Decode,
F: Fn(D0::Item) -> D1, type Item = D1::Item;impl<D: Decode> Decode for Omittable<D> type Item = Option<D::Item>;
impl<D, T: Default> Decode for Collect<D, T> where
D: Decode,
T: Extend<D::Item>, type Item = T;impl<D: Decode> Decode for Length<D> type Item = D::Item;
impl<D, T> Decode for CollectN<D, T> where
D: Decode,
T: Default + Extend<D::Item>, type Item = T;impl<D, T, E, F> Decode for TryMap<D, T, E, F> where
D: Decode,
F: Fn(D::Item) -> Result<T, E>,
Error: From<E>, type Item = T;impl<D: Decode> Decode for MaxBytes<D> type Item = D::Item;
impl<D: Decode> Decode for Slice<D> type Item = D::Item;
impl<D: Decode> Decode for Peekable<D> type Item = D::Item;
impl<D: Decode> Decode for MaybeEos<D> type Item = D::Item;
impl Decode for U8Decoder type Item = u8;
impl Decode for I8Decoder type Item = i8;
impl Decode for U16beDecoder type Item = u16;
impl Decode for U16leDecoder type Item = u16;
impl Decode for I16beDecoder type Item = i16;
impl Decode for I16leDecoder type Item = i16;
impl Decode for U24beDecoder type Item = u32;
impl Decode for U24leDecoder type Item = u32;
impl Decode for U32beDecoder type Item = u32;
impl Decode for U32leDecoder type Item = u32;
impl Decode for I32beDecoder type Item = i32;
impl Decode for I32leDecoder type Item = i32;
impl Decode for U40beDecoder type Item = u64;
impl Decode for U40leDecoder type Item = u64;
impl Decode for U48beDecoder type Item = u64;
impl Decode for U48leDecoder type Item = u64;
impl Decode for U56beDecoder type Item = u64;
impl Decode for U56leDecoder type Item = u64;
impl Decode for U64beDecoder type Item = u64;
impl Decode for U64leDecoder type Item = u64;
impl Decode for I64beDecoder type Item = i64;
impl Decode for I64leDecoder type Item = i64;
impl Decode for F32beDecoder type Item = f32;
impl Decode for F32leDecoder type Item = f32;
impl Decode for F64beDecoder type Item = f64;
impl Decode for F64leDecoder type Item = f64;
impl<T> Decode for JsonDecoder<T> where
T: for<'de> Deserialize<'de>, type Item = T;impl<D: MonolithicDecode> Decode for MonolithicDecoder<D> type Item = D::Item;
impl Decode for NullDecoder type Item = ();
impl Decode for PaddingDecoder type Item = ();
impl<D0, D1> Decode for TupleDecoder<(D0, D1)> where
D0: Decode,
D1: Decode, type Item = (D0::Item, D1::Item);impl<D0, D1, D2> Decode for TupleDecoder<(D0, D1, D2)> where
D0: Decode,
D1: Decode,
D2: Decode, type Item = (D0::Item, D1::Item, D2::Item);impl<D0, D1, D2, D3> Decode for TupleDecoder<(D0, D1, D2, D3)> where
D0: Decode,
D1: Decode,
D2: Decode,
D3: Decode, type Item = (D0::Item, D1::Item, D2::Item, D3::Item);impl<D0, D1, D2, D3, D4> Decode for TupleDecoder<(D0, D1, D2, D3, D4)> where
D0: Decode,
D1: Decode,
D2: Decode,
D3: Decode,
D4: Decode, type Item = (D0::Item, D1::Item, D2::Item, D3::Item, D4::Item);impl<D0, D1, D2, D3, D4, D5> Decode for TupleDecoder<(D0, D1, D2, D3, D4, D5)> where
D0: Decode,
D1: Decode,
D2: Decode,
D3: Decode,
D4: Decode,
D5: Decode, type Item = (D0::Item, D1::Item, D2::Item, D3::Item, D4::Item, D5::Item);impl<D0, D1, D2, D3, D4, D5, D6> Decode for TupleDecoder<(D0, D1, D2, D3, D4, D5, D6)> where
D0: Decode,
D1: Decode,
D2: Decode,
D3: Decode,
D4: Decode,
D5: Decode,
D6: Decode, type Item = (D0::Item, D1::Item, D2::Item, D3::Item, D4::Item, D5::Item, D6::Item);impl<D0, D1, D2, D3, D4, D5, D6, D7> Decode for TupleDecoder<(D0, D1, D2, D3, D4, D5, D6, D7)> where
D0: Decode,
D1: Decode,
D2: Decode,
D3: Decode,
D4: Decode,
D5: Decode,
D6: Decode,
D7: Decode, type Item = (D0::Item, D1::Item, D2::Item, D3::Item, D4::Item, D5::Item, D6::Item, D7::Item);