diff --git a/Cargo.toml b/Cargo.toml index 3283c51..91b7964 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -der = "0.2.3" +# der = "0.2.3" [dependencies.heapless] version = "0.6.0" diff --git a/src/encoder.rs b/src/encoder.rs index f49e1a8..2a986cd 100644 --- a/src/encoder.rs +++ b/src/encoder.rs @@ -1,5 +1,5 @@ -use core::convert::TryInto; -use crate::{Encodable, ErrorKind, Header, Length, nested, Result, Tag}; +use core::convert::{TryFrom, TryInto}; +use crate::{Encodable, ErrorKind, header::Header, Length, Result, Tag}; /// SIMPLE-TLV encoder. #[derive(Debug)] @@ -59,7 +59,7 @@ impl<'a> Encoder<'a> { /// Encode a collection of values which impl the [`Encodable`] trait under a given tag. pub fn nested(&mut self, tag: Tag, encodables: &[&dyn Encodable]) -> Result<()> { - let expected_len = nested::encoded_len_inner(encodables)?; + let expected_len = Length::try_from(encodables)?; Header::new(tag, expected_len).and_then(|header| header.encode(self))?; let mut nested_encoder = Encoder::new(self.reserve(expected_len)?); diff --git a/src/error.rs b/src/error.rs index fe17688..2bf104f 100644 --- a/src/error.rs +++ b/src/error.rs @@ -143,7 +143,7 @@ pub enum ErrorKind { Truncated, /// Encoded message is shorter than the expected length - /// (i.e. an `Encodable` impl on a particular type has a buggy `encoded_len`) + /// (i.e. an `Encodable` impl on a particular type has a buggy `encoded_length`) Underlength { /// Expected length expected: Length, diff --git a/src/header.rs b/src/header.rs index 364722c..cdee189 100644 --- a/src/header.rs +++ b/src/header.rs @@ -40,8 +40,8 @@ impl Decodable<'_> for Header { } impl Encodable for Header { - fn encoded_len(&self) -> Result { - self.tag.encoded_len()? + self.length.encoded_len()? + fn encoded_length(&self) -> Result { + self.tag.encoded_length()? + self.length.encoded_length()? } fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { diff --git a/src/length.rs b/src/length.rs index 7e96ecb..6a10dc7 100644 --- a/src/length.rs +++ b/src/length.rs @@ -32,6 +32,18 @@ impl Length { } } +/// Calculate the sum of the encoded lengths of the encodables. +impl<'a> TryFrom<&'a [&'a dyn Encodable]> for Length { + type Error = Error; + fn try_from(encodables: &[&dyn Encodable]) -> Result { + encodables + .iter() + .fold(Ok(Length::zero()), |sum, encodable| { + sum + encodable.encoded_length()? + }) + } +} + impl Add for Length { type Output = Result; @@ -122,7 +134,7 @@ impl Decodable<'_> for Length { } impl Encodable for Length { - fn encoded_len(&self) -> Result { + fn encoded_length(&self) -> Result { match self.0 { 0..=0xFE => Ok(Length(1)), _ => Ok(Length(3)), diff --git a/src/lib.rs b/src/lib.rs index 562979e..79863ce 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -35,18 +35,18 @@ mod encoder; mod error; mod header; mod length; -mod nested; +mod slice; mod tag; -mod tagged_slice; +mod tagged; mod traits; -pub use tagged_slice::TaggedSlice; pub use decoder::Decoder; pub use encoder::Encoder; pub use error::{Error, ErrorKind, Result}; -pub(crate) use header::Header; +// pub(crate) use header::Header; pub use length::Length; -pub use nested::Nested; +pub use slice::Slice; pub use tag::Tag; -pub use traits::{Decodable, Encodable, Tagged}; +pub use tagged::{TaggedSlice, TaggedValue}; +pub use traits::{Decodable, Encodable, Taggable}; diff --git a/src/nested.rs b/src/nested.rs index a9cb0e8..5de6b01 100644 --- a/src/nested.rs +++ b/src/nested.rs @@ -1,20 +1,20 @@ -use crate::{Decoder, Encodable, Encoder, ErrorKind, Header, Length, Result, Tag, tagged_slice::ByteSlice, TaggedSlice}; +use crate::{Decoder, Encodable, Encoder, ErrorKind, Header, Length, Result, Slice, Tag, TaggedSlice}; /// Obtain the length of an ASN.1 `SEQUENCE` of [`Encodable`] values when /// serialized as ASN.1 DER, including the `SEQUENCE` tag and length prefix. -pub fn encoded_len(/*tag: Tag,*/ encodables: &[&dyn Encodable]) -> Result { - let inner_len = encoded_len_inner(encodables)?; - // Header::new(tag, inner_len)?.encoded_len() + inner_len - Header::new(crate::tag::MEANINGLESS_TAG, inner_len)?.encoded_len() + inner_len +pub fn encoded_length(/*tag: Tag,*/ encodables: &[&dyn Encodable]) -> Result { + let inner_len = encoded_length_inner(encodables)?; + // Header::new(tag, inner_len)?.encoded_length() + inner_len + Header::new(crate::tag::MEANINGLESS_TAG, inner_len)?.encoded_length() + inner_len } /// Obtain the inner length of a container of [`Encodable`] values /// excluding the tag and length. -pub(crate) fn encoded_len_inner(encodables: &[&dyn Encodable]) -> Result { +pub(crate) fn encoded_length_inner(encodables: &[&dyn Encodable]) -> Result { encodables .iter() .fold(Ok(Length::zero()), |sum, encodable| { - sum + encodable.encoded_len()? + sum + encodable.encoded_length()? }) } @@ -24,13 +24,13 @@ pub struct Nested<'a> { /// Tag pub(crate) tag: Tag, /// Inner value - pub(crate) slice: ByteSlice<'a>, + pub(crate) slice: Slice<'a>, } impl<'a> Nested<'a> { /// Create a new [`Nested`] from a slice pub fn new(tag: Tag, slice: &'a [u8]) -> Result { - ByteSlice::new(slice) + Slice::new(slice) .map(|slice| Self { tag, slice }) .map_err(|_| ErrorKind::Length { tag }.into()) } @@ -67,19 +67,19 @@ impl AsRef<[u8]> for Nested<'_> { impl<'a> From> for Nested<'a> { fn from(tagged_slice: TaggedSlice<'a>) -> Nested<'a> { - Self { tag: tagged_slice.tag(), slice: tagged_slice.slice } + Self { tag: tagged_slice.tag(), slice: tagged_slice.value } } } impl<'a> From> for TaggedSlice<'a> { fn from(nested: Nested<'a>) -> TaggedSlice<'a> { - TaggedSlice { tag: nested.tag(), slice: nested.slice } + TaggedSlice { tag: nested.tag(), value: nested.slice } } } impl<'a> Encodable for Nested<'a> { - fn encoded_len(&self) -> Result { - TaggedSlice::from(*self).encoded_len() + fn encoded_length(&self) -> Result { + TaggedSlice::from(*self).encoded_length() } fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { diff --git a/src/slice.rs b/src/slice.rs new file mode 100644 index 0000000..99b07b0 --- /dev/null +++ b/src/slice.rs @@ -0,0 +1,45 @@ +use core::convert::TryFrom; +use crate::{Length, Result}; + +/// Slice of at most `Length::max()` bytes. +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub struct Slice<'a> { + /// Inner value + inner: &'a [u8], + + /// Precomputed `Length` (avoids possible panicking conversions) + length: Length, +} + +impl<'a> Slice<'a> { + /// Create a new [`Slice`], ensuring that the provided `slice` value + /// is shorter than `Length::max()`. + pub fn new(slice: &'a [u8]) -> Result { + Ok(Self { + inner: slice, + length: Length::try_from(slice.len())?, + }) + } + + /// Borrow the inner byte slice + pub fn as_bytes(&self) -> &'a [u8] { + self.inner + } + + /// Get the [`Length`] of this [`Slice`] + pub fn length(self) -> Length { + self.length + } + + /// Is this [`Slice`] empty? + pub fn is_empty(self) -> bool { + self.length() == Length::zero() + } +} + +impl AsRef<[u8]> for Slice<'_> { + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + diff --git a/src/tag.rs b/src/tag.rs index 6651b2d..47dc174 100644 --- a/src/tag.rs +++ b/src/tag.rs @@ -5,8 +5,6 @@ use crate::{Decodable, Decoder, Encodable, Encoder, Error, ErrorKind, Length, Re #[derive(Clone, Copy, Eq, PartialEq)] pub struct Tag(u8); -pub(crate) const MEANINGLESS_TAG: Tag = Tag(42); - impl TryFrom for Tag { type Error = Error; fn try_from(tag_number: u8) -> Result { @@ -41,7 +39,7 @@ impl Decodable<'_> for Tag { } impl Encodable for Tag { - fn encoded_len(&self) -> Result { + fn encoded_length(&self) -> Result { Ok(1u8.into()) } diff --git a/src/tagged.rs b/src/tagged.rs new file mode 100644 index 0000000..8009be5 --- /dev/null +++ b/src/tagged.rs @@ -0,0 +1,159 @@ +// //! Common handling for types backed by byte slices with enforcement of the +// //! format-level length limitation of 65_535 bytes. + +use crate::{Decodable, Decoder, Encodable, Encoder, ErrorKind, header::Header, Length, Result, Slice, Tag}; + +/// SIMPLE-TLV data object +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct TaggedValue { + tag: Tag, + value: V, +} + +/// Raw SIMPLE-TLV data object: TaggedValue with Slice as value. +pub type TaggedSlice<'a> = TaggedValue>; + +impl TaggedValue +{ + pub fn new(tag: Tag, value: V) -> Self { + Self { tag, value } + } + + pub fn tag(&self) -> Tag { + self.tag + } +} + + +impl<'a, E> TaggedValue<&'a E> +where + E: Encodable +{ + fn header(&self) -> Result
{ + Ok(Header { + tag: self.tag(), + length: self.value.encoded_length()?, + }) + } +} + +impl<'a, E> Encodable for TaggedValue<&'a E> +where + E: Encodable +{ + fn encoded_length(&self) -> Result { + self.header()?.encoded_length()? + self.value.encoded_length()? + } + fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { + self.header()?.encode(encoder)?; + encoder.encode(self.value) + } +} + +impl<'a> TaggedSlice<'a> { + + /// Create a new tagged slice, checking lengths. + pub fn from(tag: Tag, slice: &'a [u8]) -> Result { + Slice::new(slice) + .map(|slice| Self { tag, value: slice }) + .map_err(|_| (ErrorKind::InvalidLength).into()) + } + + /// Borrow the inner byte slice. + pub fn as_bytes(&self) -> &'a [u8] { + self.value.as_bytes() + } + + /// Get the length of the inner byte slice. + pub fn length(&self) -> Length { + self.value.length() + } + + /// Is the inner byte slice empty? + pub fn is_empty(&self) -> bool { + self.value.is_empty() + } + + /// Get the SIMPLE-TLV [`Header`] for this [`TaggedSlice`] value + fn header(&self) -> Result
{ + Ok(Header { + tag: self.tag(), + length: self.length(), + }) + } + + /// Decode nested values, creating a new [`Decoder`] for + /// the data contained in the sequence's body and passing it to the provided + /// [`FnOnce`]. + pub fn decode_nested(&self, f: F) -> Result + where + F: FnOnce(&mut Decoder<'a>) -> Result, + { + let mut nested_decoder = Decoder::new(self.as_bytes()); + let result = f(&mut nested_decoder)?; + nested_decoder.finish(result) + } +} + +impl<'a> Decodable<'a> for TaggedSlice<'a> { + fn decode(decoder: &mut Decoder<'a>) -> Result> { + let header = Header::decode(decoder)?; + let tag = header.tag; + let len = header.length.to_usize(); + let value = decoder.bytes(len).map_err(|_| ErrorKind::Length { tag })?; + Self::from(tag, value) + } +} + +impl<'a> Encodable for TaggedSlice<'a> { + fn encoded_length(&self) -> Result { + self.header()?.encoded_length()? + self.length() + } + + fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { + self.header()?.encode(encoder)?; + encoder.bytes(self.as_bytes()) + } +} + +// /// Obtain the length of an ASN.1 `SEQUENCE` of [`Encodable`] values when +// /// serialized as ASN.1 DER, including the `SEQUENCE` tag and length prefix. +// pub fn encoded_length2(/*tag: Tag,*/ encodables: &[&dyn Encodable]) -> Result { +// let inner_len = Length::try_from(encodables)?; +// Header::new(crate::tag::MEANINGLESS_TAG, inner_len)?.encoded_length() + inner_len +// } + +// /// Obtain the inner length of a container of [`Encodable`] values +// /// excluding the tag and length. +// pub(crate) fn sum_encoded_lengths(encodables: &[&dyn Encodable]) -> Result { +// encodables +// .iter() +// .fold(Ok(Length::zero()), |sum, encodable| { +// sum + encodable.encoded_length()? +// }) +// } + + +#[cfg(test)] +mod tests { + use core::convert::TryFrom; + use crate::{Encodable, Tag, TaggedSlice}; + + #[test] + fn encode() { + let mut buf = [0u8; 1024]; + + let short = TaggedSlice::from(Tag::try_from(0x66).unwrap(), &[1, 2, 3]).unwrap(); + + assert_eq!( + short.encode_to_slice(&mut buf).unwrap(), + &[0x66, 0x3, 1, 2, 3] + ); + + let slice = &[43u8; 256]; + let long = TaggedSlice::from(Tag::try_from(0x66).unwrap(), slice).unwrap(); + let encoded = long.encode_to_slice(&mut buf).unwrap(); + assert_eq!(&encoded[..4], &[0x66, 0xFF, 0x01, 0x00]); + assert_eq!(&encoded[4..], slice); + } +} diff --git a/src/tagged_slice.rs b/src/tagged_slice.rs deleted file mode 100644 index 957903b..0000000 --- a/src/tagged_slice.rs +++ /dev/null @@ -1,199 +0,0 @@ -// //! Common handling for types backed by byte slices with enforcement of the -// //! format-level length limitation of 65_535 bytes. - -use crate::{Decodable, Decoder, Encodable, Encoder, ErrorKind, Header, Length, Nested, Result, Tag}; -use core::convert::TryFrom; - -/// Byte slice newtype which respects the `Length::max()` limit. -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -pub(crate) struct ByteSlice<'a> { - /// Inner value - inner: &'a [u8], - - /// Precomputed `Length` (avoids possible panicking conversions) - length: Length, -} - -impl<'a> ByteSlice<'a> { - /// Create a new [`ByteSlice`], ensuring that the provided `slice` value - /// is shorter than `Length::max()`. - pub fn new(slice: &'a [u8]) -> Result { - Ok(Self { - inner: slice, - length: Length::try_from(slice.len())?, - }) - } - - /// Borrow the inner byte slice - pub fn as_bytes(&self) -> &'a [u8] { - self.inner - } - - /// Get the [`Length`] of this [`ByteSlice`] - pub fn len(self) -> Length { - self.length - } - - /// Is this [`ByteSlice`] empty? - pub fn is_empty(self) -> bool { - self.len() == Length::zero() - } -} - -impl AsRef<[u8]> for ByteSlice<'_> { - fn as_ref(&self) -> &[u8] { - self.as_bytes() - } -} - -// pub fn TaggedAs(tag: Tag, data: &[u8]) -> impl Tagged<'_> { -// struct - -// todo!(); -// } - -/// SIMPLE-TLV data object -/// -/// TODO(nickray): rename to DataObject or similar (also module) -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub struct TaggedSlice<'a> { - pub(crate) tag: Tag, - pub(crate) slice: ByteSlice<'a>, -} - -// impl<'a, V: Decodable<'a> + Encodable> TaggedValue<'a, V> { -// pub fn new(tag: Tag, value: &'a V) -> Self { -// Self { tag, value } -// } - -// pub fn tag(&self) -> Tag { -// self.tag -// } - -// // pub fn value(&self) -> &'a V { -// // } - -// } - -impl<'a> TaggedSlice<'a> { - /// Create a new tagged slice, checking lengths. - pub fn new(tag: Tag, slice: &'a [u8]) -> Result { - ByteSlice::new(slice) - .map(|slice| Self { tag, slice }) - .map_err(|_| (ErrorKind::InvalidLength).into()) - } - - /// Borrow the inner byte slice. - pub fn as_bytes(&self) -> &'a [u8] { - self.slice.as_bytes() - } - - pub fn tag(&self) -> Tag { - self.tag - } - - /// Get the length of the inner byte slice. - pub fn len(&self) -> Length { - self.slice.len() - } - - /// Is the inner byte slice empty? - pub fn is_empty(&self) -> bool { - self.slice.is_empty() - } - - /// Get the SIMPLE-TLV [`Header`] for this [`TaggedSlice`] value - fn header(self) -> Result
{ - Ok(Header { - tag: self.tag, - length: self.len(), - }) - } - - /// Attempt to decode this value as nested TaggedSlices, creating a new - /// nested [`Decoder`] and calling the provided argument with it. - pub fn nested(self, f: F) -> Result - where - F: FnOnce(&mut Decoder<'a>) -> Result, - { - Nested::from(self).decode_nested(f) - } -} - -impl<'a> Decodable<'a> for TaggedSlice<'a> { - fn decode(decoder: &mut Decoder<'a>) -> Result> { - let header = Header::decode(decoder)?; - let tag = header.tag; - let len = header.length.to_usize(); - let value = decoder.bytes(len).map_err(|_| ErrorKind::Length { tag })?; - Self::new(tag, value) - } -} - -impl<'a> Encodable for TaggedSlice<'a> { - fn encoded_len(&self) -> Result { - self.header()?.encoded_len()? + self.len() - } - - fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { - self.header()?.encode(encoder)?; - encoder.bytes(self.as_bytes()) - } -} - -// #[derive(Clone, Copy, Debug, Eq, PartialEq)] -// pub struct TaggedValue { -// pub(crate) tag: Tag, -// pub(crate) value: PhantomData, -// } - -// impl<'a, V> Decodable<'a> for TaggedValue<'a, V> -// where -// V: Decodable<'a> + Encodable, -// { -// fn decode(decoder: &mut Decoder<'a>) -> Result { -// let tagged_slice: TaggedSlice = decoder.decode()?; -// // tagged_slice.tag().assert_eq(self.tag())?; -// let value: &'a V = Decoder::new(tagged_slice.as_bytes()).decode()?; -// Ok(Self { tag: tagged_slice.tag(), value }) -// } -// } - -// impl<'a, V> Encodable for TaggedValue<'a, V> -// where -// V: Decodable<'a> + Encodable, -// { -// fn encoded_len(&self) -> Result { -// self.header()?.encoded_len()? + self.len() -// } - -// fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { -// self.header()?.encode(encoder)?; -// encoder.bytes(self.value.as_bytes()) -// } -// } - - -#[cfg(test)] -mod tests { - use core::convert::TryFrom; - use crate::{Encodable, Tag, TaggedSlice}; - - #[test] - fn encode() { - let mut buf = [0u8; 1024]; - - let short = TaggedSlice::new(Tag::try_from(0x66).unwrap(), &[1, 2, 3]).unwrap(); - - assert_eq!( - short.encode_to_slice(&mut buf).unwrap(), - &[0x66, 0x3, 1, 2, 3] - ); - - let slice = &[43u8; 256]; - let long = TaggedSlice::new(Tag::try_from(0x66).unwrap(), slice).unwrap(); - let encoded = long.encode_to_slice(&mut buf).unwrap(); - assert_eq!(&encoded[..4], &[0x66, 0xFF, 0x01, 0x00]); - assert_eq!(&encoded[4..], slice); - } -} diff --git a/src/traits.rs b/src/traits.rs index f9b9839..3f33721 100644 --- a/src/traits.rs +++ b/src/traits.rs @@ -2,7 +2,7 @@ //! Trait definitions use core::convert::TryFrom; -use crate::{Decoder, Encoder, Error, Header, Length, nested, Result, Tag, TaggedSlice}; +use crate::{Decoder, Encoder, Error, header::Header, Length, Result, Tag, TaggedSlice, TaggedValue}; #[cfg(feature = "alloc")] use { @@ -17,7 +17,9 @@ use { crate::{Error, ErrorKind}, }; -/// Decoding trait. +/// Decoding trait: +/// +/// Decode out of decoder, which essentially is a slice of bytes. pub trait Decodable<'a>: Sized { /// Attempt to decode this message using the provided decoder. fn decode(decoder: &mut Decoder<'a>) -> Result; @@ -41,10 +43,14 @@ where } } -/// Encoding trait. +/// Encoding trait +/// +/// Encode into encoder, which essentially is a mutable slice of bytes. +/// +/// Additionally, the encoded length needs to be known without actually encoding. pub trait Encodable { /// Compute the length of this value in bytes when encoded as SIMPLE-TLV - fn encoded_len(&self) -> Result; + fn encoded_length(&self) -> Result; /// Encode this value as SIMPLE-TLV using the provided [`Encoder`]. fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()>; @@ -62,7 +68,7 @@ pub trait Encodable { #[cfg(feature = "alloc")] #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] fn encode_to_vec(&self, buf: &mut Vec) -> Result { - let expected_len = self.encoded_len()?.to_usize(); + let expected_len = self.encoded_length()?.to_usize(); let current_len = buf.len(); buf.reserve(expected_len); buf.extend(iter::repeat(0).take(expected_len)); @@ -98,7 +104,7 @@ pub trait Encodable { #[cfg(feature = "heapless")] #[cfg_attr(docsrs, doc(cfg(feature = "heapless")))] fn encode_to_heapless_vec>(&self, buf: &mut heapless::Vec) -> Result { - let expected_len = self.encoded_len()?.to_usize(); + let expected_len = self.encoded_length()?.to_usize(); let current_len = buf.len(); // TODO(nickray): add a specific error for "Overcapacity" conditional on heapless feature? buf.resize_default(current_len + expected_len).map_err(|_| Error::from(ErrorKind::Overlength))?; @@ -128,49 +134,14 @@ pub trait Encodable { } } -pub trait Taggable: Sized + Encodable { - fn tagged(&self, tag: Tag) -> Tagged<'_, Self> { - Tagged { tag, encodable: self } +/// Types that have can be tagged. +pub trait Taggable: Sized { + fn tagged(&self, tag: Tag) -> TaggedValue<&Self> { + TaggedValue::new(tag, self) } } -impl Taggable for X where X: Sized + Encodable {} - -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -// pub struct Tagged<'a, E: Encodable> { -pub struct Tagged<'a, E> { - tag: Tag, - encodable: &'a E, -} - -impl<'a, E> Tagged<'a, E> -where - E: Encodable -{ - pub fn from(encodable: &'a E, tag: Tag) -> Self { - Tagged { tag, encodable } - } - - fn header(&self) -> Result
{ - Ok(Header { - tag: self.tag, - length: self.encodable.encoded_len()?, - }) - } -} - -impl<'a, E> Encodable for Tagged<'a, E> -where - E: Encodable -{ - fn encoded_len(&self) -> Result { - self.header()?.encoded_len()? + self.encodable.encoded_len()? - } - fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { - self.header()?.encode(encoder)?; - encoder.encode(self.encodable) - } -} +impl Taggable for X where X: Sized {} // /// Types with an associated SIMPLE-TLV [`Tag`]. // pub trait Tagged { @@ -204,8 +175,9 @@ impl<'a, M> Encodable for M where M: Message<'a>, { - fn encoded_len(&self) -> Result { - self.fields(nested::encoded_len) + fn encoded_length(&self) -> Result { + let value_length = self.fields(|encodables| Length::try_from(encodables))?; + Header::new(Self::tag(), value_length)?.encoded_length() + value_length } fn encode(&self, encoder: &mut Encoder<'_>) -> Result<()> { @@ -213,22 +185,15 @@ where } } -//impl<'a, M> Tagged for M -//where -// M: Message<'a>, -//{ -// const TAG: Tag = Tag::Sequence; -//} - #[cfg(test)] mod tests { use core::convert::{TryFrom, TryInto}; - use crate::{Decodable, Decoder, Encodable, Encoder, Error, Length, Result, Tag, TaggedSlice}; - use super::{Message, Taggable}; + use crate::{Decodable, Decoder, Encodable, Encoder, Error, Length, Result, Tag, Taggable, TaggedSlice}; + use super::Message; impl Encodable for [u8; 2] { - fn encoded_len(&self) -> Result { + fn encoded_length(&self) -> Result { Ok(2u8.into()) } @@ -239,7 +204,7 @@ mod tests { } impl Encodable for [u8; 3] { - fn encoded_len(&self) -> Result { + fn encoded_length(&self) -> Result { Ok(3u8.into()) } @@ -250,7 +215,7 @@ mod tests { } impl Encodable for [u8; 4] { - fn encoded_len(&self) -> Result { + fn encoded_length(&self) -> Result { Ok(4u8.into()) } @@ -305,7 +270,7 @@ mod tests { fn try_from(tagged_slice: TaggedSlice<'a>) -> Result { tagged_slice.tag().assert_eq(Tag::try_from(0xAA).unwrap())?; - tagged_slice.nested(|decoder| { + tagged_slice.decode_nested(|decoder| { let x = decoder.decode_tag(Tag::try_from(0x11).unwrap())?; let y = decoder.decode_tag(Tag::try_from(0x22).unwrap())?; let z = decoder.decode_tag(Tag::try_from(0x33).unwrap())?; @@ -368,7 +333,7 @@ mod tests { fn try_from(tagged_slice: TaggedSlice<'a>) -> Result { tagged_slice.tag().assert_eq(Tag::try_from(0xBB).unwrap())?; - tagged_slice.nested(|decoder| { + tagged_slice.decode_nested(|decoder| { let s = decoder.decode_tag(Tag::try_from(0x01).unwrap())?; let t = decoder.decode_tag(Tag::try_from(0x02).unwrap())?; @@ -434,7 +399,7 @@ mod tests { fn try_from(tagged_slice: TaggedSlice<'a>) -> Result { tagged_slice.tag().assert_eq(Tag::try_from(0xCC).unwrap())?; - tagged_slice.nested(|decoder| { + tagged_slice.decode_nested(|decoder| { let s = decoder.decode()?; let t = decoder.decode_tag(Tag::try_from(0x02).unwrap())?;