List of all items
Structs
Enums
Traits
Functions
- cbor_deserialize
- cbor_serialize
- cbor_serialize_bytes
- cbor_serialize_extending_bytes
- de::from_bytes
- de::take_from_bytes
pub fn from_bytes<'a, T>(s: &'a [u8]) -> Result<T>where
+from_bytes in cbor_smol::de - Rust Function cbor_smol::de::from_bytes
source · pub fn from_bytes<'a, T>(s: &'a [u8]) -> Result<T>where
T: Deserialize<'a>,
Expand description
Deserialize a message of type T from a byte slice. The unused portion (if any)
of the byte slice is returned for further usage
take_from_bytes in cbor_smol::de - Rust Function cbor_smol::de::take_from_bytes
source · pub fn take_from_bytes<'a, T>(s: &'a [u8]) -> Result<(T, &'a [u8])>where
+take_from_bytes in cbor_smol::de - Rust Function cbor_smol::de::take_from_bytes
source · pub fn take_from_bytes<'a, T>(s: &'a [u8]) -> Result<(T, &'a [u8])>where
T: Deserialize<'a>,
Expand description
Deserialize a message of type T from a byte slice. The unused portion (if any)
of the byte slice is returned for further usage
cbor_smol::de - Rust Structs§
- A structure for deserializing a cbor-smol message.
Functions§
- Deserialize a message of type
T from a byte slice. The unused portion (if any)
+cbor_smol::de - Rust Structs§
- A structure for deserializing a cbor-smol message.
Functions§
- Deserialize a message of type
T from a byte slice. The unused portion (if any)
of the byte slice is returned for further usage - Deserialize a message of type
T from a byte slice. The unused portion (if any)
of the byte slice is returned for further usage
Deserializer in cbor_smol::de - Rust Struct cbor_smol::de::Deserializer
source · pub struct Deserializer<'de> { /* private fields */ }
Expand description
A structure for deserializing a cbor-smol message.
+Deserializer in cbor_smol::de - Rust Struct cbor_smol::de::Deserializer
source · pub struct Deserializer<'de> { /* private fields */ }
Expand description
A structure for deserializing a cbor-smol message.
Implementations§
source§impl<'de> Deserializer<'de>
sourcepub fn from_bytes(input: &'de [u8]) -> Self
Obtain a Deserializer from a slice of bytes
-Trait Implementations§
source§impl<'de, 'a> Deserializer<'de> for &'a mut Deserializer<'de>
Trait Implementations§
source§impl<'de, 'a> Deserializer<'de> for &'a mut Deserializer<'de>
source§fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Require the Deserializer to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>where
@@ -15,60 +15,60 @@ on what data type is in the input. Visitor<'de>,
Hint that the Deserialize type is expecting a u64 value.source§fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a f32 value.source§fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a f64 value.source§fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>where
- V: Visitor<'de>,
Hint that the Deserialize type is expecting a char value.source§fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>where
+ V: Visitor<'de>,
Hint that the Deserialize type is expecting a char value.source§fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
-Deserializer. Read moresource§fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>where
+Deserializer. Read more
source§fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
-Deserializer. Read moresource§fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
-Deserializer. Read moresource§fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
-Deserializer. Read moresource§fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>where
- V: Visitor<'de>,
Hint that the Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>where
- V: Visitor<'de>,
Hint that the Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
+Deserializer. Read more
source§fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>where
+ V: Visitor<'de>,
Hint that the Deserialize type is expecting an optional value. Read moresource§fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>where
+ V: Visitor<'de>,
Hint that the Deserialize type is expecting a unit value.source§fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a unit struct with a
-particular name.source§fn deserialize_newtype_struct<V>(
+particular name.
source§fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V,
) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a newtype struct with a
-particular name.source§fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>where
- V: Visitor<'de>,
Hint that the Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>where
+particular name.
source§fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>where
+ V: Visitor<'de>,
Hint that the Deserialize type is expecting a sequence of values.source§fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a sequence of values and
-knows how many values there are without looking at the serialized data.source§fn deserialize_tuple_struct<V>(
+knows how many values there are without looking at the serialized data.
source§fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
len: usize,
visitor: V,
) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a tuple struct with a
-particular name and number of fields.source§fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>where
- V: Visitor<'de>,
Hint that the Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
+particular name and number of fields.
source§fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>where
+ V: Visitor<'de>,
Hint that the Deserialize type is expecting a map of key-value pairs.source§fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting a struct with a particular
-name and fields.source§fn deserialize_enum<V>(
+name and fields.
source§fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting an enum value with a
-particular name and possible variants.source§fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>where
+particular name and possible variants.
source§fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type is expecting the name of a struct
-field or the discriminant of an enum variant.source§fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>where
+field or the discriminant of an enum variant.
source§fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>where
V: Visitor<'de>,
Hint that the Deserialize type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn deserialize_i128<V>(
self,
diff --git a/cbor_smol/error/enum.Error.html b/cbor_smol/error/enum.Error.html
index 57fd3d0..630ab07 100644
--- a/cbor_smol/error/enum.Error.html
+++ b/cbor_smol/error/enum.Error.html
@@ -1,4 +1,4 @@
-Error in cbor_smol::error - Rust #[repr(u8)]pub enum Error {
+Error in cbor_smol::error - Rust #[repr(u8)]pub enum Error {
Show 22 variants
WontImplement,
NotYetImplemented,
SerializeBufferFull(usize),
@@ -44,7 +44,7 @@
§SerdeSerCustom
Serde Serialization Error
§SerdeDeCustom
Serde Deserialization Error
§SerdeMissingField
Serde Missing required value
-
Trait Implementations§
source§impl Error for Error
Trait Implementations§
source§impl Error for Error
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more1.0.0 · source§fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()source§impl Error for Error
source§fn custom<T>(msg: T) -> Selfwhere
T: Display,
Raised when there is general error when deserializing a type. Read moresource§fn missing_field(field: &'static str) -> Self
Raised when a Deserialize struct type expected to receive a required
field with a particular name but that field was not present in the
input.source§fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self
Raised when a Deserialize receives a type different from what it was
@@ -53,7 +53,7 @@ is wrong for some other reason. Read moresource§fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self
Raised when a Deserialize enum type received a variant with an
unrecognized name.source§fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self
Raised when a Deserialize struct type received a field with an
unrecognized name.source§fn duplicate_field(field: &'static str) -> Self
Raised when a Deserialize struct type received more than one of the
-same field.source§impl Error for Error
1.30.0 · source§fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more1.0.0 · source§fn description(&self) -> &str
👎Deprecated since 1.42.0: use the Display impl or to_string()source§impl PartialEq for Error
source§fn eq(&self, other: &Error) -> bool
This method tests for self and other values to be equal, and is used
by ==.1.0.0 · source§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always
diff --git a/cbor_smol/error/index.html b/cbor_smol/error/index.html
index 2930cee..69c8099 100644
--- a/cbor_smol/error/index.html
+++ b/cbor_smol/error/index.html
@@ -1 +1 @@
-cbor_smol::error - Rust cbor_smol::error - Rust Result in cbor_smol::error - Rust pub type Result<T> = Result<T, Error>;
Expand description
This is the Result type used by cbor-smol.
+Result in cbor_smol::error - Rust pub type Result<T> = Result<T, Error>;
Expand description
This is the Result type used by cbor-smol.
Aliased Type§
enum Result<T> {
Ok(T),
Err(Error),
diff --git a/cbor_smol/fn.cbor_deserialize.html b/cbor_smol/fn.cbor_deserialize.html
index 7271ba9..1cd35ca 100644
--- a/cbor_smol/fn.cbor_deserialize.html
+++ b/cbor_smol/fn.cbor_deserialize.html
@@ -1,3 +1,3 @@
-cbor_deserialize in cbor_smol - Rust Function cbor_smol::cbor_deserialize
source · pub fn cbor_deserialize<'de, T: Deserialize<'de>>(
+cbor_deserialize in cbor_smol - Rust Function cbor_smol::cbor_deserialize
source · pub fn cbor_deserialize<'de, T: Deserialize<'de>>(
buffer: &'de [u8],
) -> Result<T>
cbor_serialize in cbor_smol - Rust Function cbor_smol::cbor_serialize
source · pub fn cbor_serialize<'a, T: ?Sized + Serialize>(
+cbor_serialize in cbor_smol - Rust cbor_serialize_bytes in cbor_smol - Rust Function cbor_smol::cbor_serialize_bytes
source · pub fn cbor_serialize_bytes<T: ?Sized + Serialize, const N: usize>(
+cbor_serialize_bytes in cbor_smol - Rust cbor_serialize_extending_bytes in cbor_smol - Rust Function cbor_smol::cbor_serialize_extending_bytes
source · pub fn cbor_serialize_extending_bytes<T: ?Sized + Serialize, const N: usize>(
+cbor_serialize_extending_bytes in cbor_smol - Rust Function cbor_smol::cbor_serialize_extending_bytes
source · pub fn cbor_serialize_extending_bytes<T: ?Sized + Serialize, const N: usize>(
object: &T,
bytes: &mut Bytes<N>,
) -> Result<usize>
Expand description
Append serialization of object to existing bytes, returning length of serialized object.
diff --git a/cbor_smol/index.html b/cbor_smol/index.html
index 188e585..cde90cf 100644
--- a/cbor_smol/index.html
+++ b/cbor_smol/index.html
@@ -1 +1 @@
-cbor_smol - Rust cbor_smol - Rust cbor_smol::ser - Rust cbor_smol::ser - Rust Serializer in cbor_smol::ser - Rust Struct cbor_smol::ser::Serializer
source · pub struct Serializer<W> {
+Serializer in cbor_smol::ser - Rust Struct cbor_smol::ser::Serializer
source · pub struct Serializer<W> {
pub writer: W,
}
Fields§
§writer: WImplementations§
source§impl<W: Writer> Serializer<W>
sourcepub fn new(writer: W) -> Self
sourcepub fn into_inner(self) -> W
Unwrap the Writer from the Serializer.
Trait Implementations§
source§impl<'a, W> SerializeStruct for &'a mut Serializer<W>where
- W: Writer,
source§impl<'a, W> SerializeStructVariant for &'a mut Serializer<W>where
- W: Writer,
source§impl<'a, W> SerializeTuple for &'a mut Serializer<W>where
+ W: Writer,
source§impl<'a, W> SerializeStructVariant for &'a mut Serializer<W>where
+ W: Writer,
source§impl<'a, W> SerializeTuple for &'a mut Serializer<W>where
W: Writer,
source§impl<'a, W> SerializeTupleStruct for &'a mut Serializer<W>where
W: Writer,
source§impl<'a, W> SerializeTupleVariant for &'a mut Serializer<W>where
W: Writer,
source§impl<'a, W> Serializer for &'a mut Serializer<W>where
- W: Writer,
§type Ok = ()
The output type produced by this Serializer during successful
+ W: Writer,§type Ok = ()
The output type produced by this Serializer during successful
serialization. Most serializers that produce text or binary output
should set Ok = () and serialize into an io::Write or buffer
contained within the Serializer instance. Serializers that build
in-memory data structures may be simplified by using Ok to propagate
-the data structure around.§type SerializeSeq = CollectionSerializer<'a, W>
Type returned from serialize_seq for serializing the content of the
+the data structure around.§type SerializeSeq = CollectionSerializer<'a, W>
Type returned from serialize_seq for serializing the content of the
sequence.§type SerializeTuple = &'a mut Serializer<W>
Type returned from serialize_tuple for serializing the content of
the tuple.§type SerializeTupleStruct = &'a mut Serializer<W>
Type returned from serialize_tuple_struct for serializing the
content of the tuple struct.§type SerializeTupleVariant = &'a mut Serializer<W>
Type returned from serialize_tuple_variant for serializing the
diff --git a/cbor_smol/ser/struct.SliceWriter.html b/cbor_smol/ser/struct.SliceWriter.html
index ac8d247..b2ce67d 100644
--- a/cbor_smol/ser/struct.SliceWriter.html
+++ b/cbor_smol/ser/struct.SliceWriter.html
@@ -1,4 +1,4 @@
-SliceWriter in cbor_smol::ser - Rust Struct cbor_smol::ser::SliceWriter
source · pub struct SliceWriter<'a> { /* private fields */ }
Implementations§
source§impl<'a> SliceWriter<'a>
sourcepub fn new(slice: &'a mut [u8]) -> SliceWriter<'a>
Wraps a mutable slice so it can be used as a Writer.
+SliceWriter in cbor_smol::ser - Rust Struct cbor_smol::ser::SliceWriter
source · pub struct SliceWriter<'a> { /* private fields */ }
Implementations§
source§impl<'a> SliceWriter<'a>
sourcepub fn new(slice: &'a mut [u8]) -> SliceWriter<'a>
Wraps a mutable slice so it can be used as a Writer.
sourcepub fn bytes_written(&self) -> usize
Returns the number of bytes written to the underlying slice.
sourcepub fn into_inner(self) -> &'a mut [u8]
Returns the underlying slice.
Trait Implementations§
source§impl<'a> Debug for SliceWriter<'a>
Auto Trait Implementations§
§impl<'a> Freeze for SliceWriter<'a>
§impl<'a> RefUnwindSafe for SliceWriter<'a>
§impl<'a> Send for SliceWriter<'a>
§impl<'a> Sync for SliceWriter<'a>
§impl<'a> Unpin for SliceWriter<'a>
§impl<'a> !UnwindSafe for SliceWriter<'a>
Blanket Implementations§
source§impl<T> Any for Twhere
diff --git a/cbor_smol/ser/trait.Writer.html b/cbor_smol/ser/trait.Writer.html
index f137c0d..15031fb 100644
--- a/cbor_smol/ser/trait.Writer.html
+++ b/cbor_smol/ser/trait.Writer.html
@@ -1,4 +1,4 @@
-Writer in cbor_smol::ser - Rust pub trait Writer {
+Writer in cbor_smol::ser - Rust pub trait Writer {
type Error: Into<Error>;
// Required method
diff --git a/cbor_smol/struct.Bytes.html b/cbor_smol/struct.Bytes.html
index 4fec05a..4fdaeb0 100644
--- a/cbor_smol/struct.Bytes.html
+++ b/cbor_smol/struct.Bytes.html
@@ -1,4 +1,4 @@
-Bytes in cbor_smol - Rust pub struct Bytes<const N: usize> { /* private fields */ }
Implementations§
§impl<const N: usize> Bytes<N>
pub fn new() -> Bytes<N>
Construct a new, empty Bytes<N>.
+Bytes in cbor_smol - Rust pub struct Bytes<const N: usize> { /* private fields */ }
Implementations§
§impl<const N: usize> Bytes<N>
pub fn into_inner(self) -> Vec<u8, N>
Unwraps the Vec<u8, N>, same as into_vec.
diff --git a/search-index.js b/search-index.js
index bdb4205..6e9fdc8 100644
--- a/search-index.js
+++ b/search-index.js
@@ -1,5 +1,5 @@
var searchIndex = new Map(JSON.parse('[\
-["cbor_smol",{"t":"FEENNNNNNHHHHNNCNNNNNCNNNNNNNNNNNNNNNNNNNCNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNHNNNPPPPPPPPPPPPPPPPGPPPIPPPPPNNNNNNNNNNNNNNNNRFFKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNO","n":["Bytes","Error","Result","as_mut","as_mut_slice","as_ref","as_slice","borrow","borrow_mut","cbor_deserialize","cbor_serialize","cbor_serialize_bytes","cbor_serialize_extending_bytes","clone","clone_to_uninit","de","default","deref","deref_mut","deserialize","eq","error","fmt","from","from","from","from_slice","hash","insert","insert_slice_at","into","into_inner","into_iter","into_iter","into_iter","into_vec","new","partial_cmp","remove","resize_default","resize_to_capacity","ser","serialize","to_bytes","try_convert_into","try_from","try_from","try_into","type_id","write_all","Deserializer","borrow","borrow_mut","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","from","from_bytes","from_bytes","into","take_from_bytes","try_from","try_into","type_id","DeserializeBadBool","DeserializeBadEnum","DeserializeBadI16","DeserializeBadI32","DeserializeBadI64","DeserializeBadI8","DeserializeBadMajor","DeserializeBadU16","DeserializeBadU32","DeserializeBadU64","DeserializeBadU8","DeserializeBadUtf8","DeserializeExpectedNull","DeserializeNonMinimal","DeserializeUnexpectedEnd","Err","Error","InexistentSliceToArrayError","NotYetImplemented","Ok","Result","SerdeDeCustom","SerdeMissingField","SerdeSerCustom","SerializeBufferFull","WontImplement","borrow","borrow_mut","clone","clone_to_uninit","clone_to_uninit","custom","custom","eq","fmt","fmt","from","into","missing_field","try_from","try_into","type_id","Error","Serializer","SliceWriter","Writer","borrow","borrow","borrow_mut","borrow_mut","bytes_written","collect_str","end","end","end","end","end","fmt","from","from","into","into","into_inner","into_inner","is_human_readable","new","new","serialize_bool","serialize_bytes","serialize_char","serialize_element","serialize_f32","serialize_f64","serialize_field","serialize_field","serialize_field","serialize_field","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","try_from","try_from","try_into","try_into","type_id","type_id","write_all","write_all","writer"],"q":[[0,"cbor_smol"],[50,"cbor_smol::de"],[90,"cbor_smol::error"],[132,"cbor_smol::ser"],[199,"heapless_bytes"],[200,"serde::de"],[201,"core::marker"],[202,"serde::ser"],[203,"core::result"],[204,"core::convert"],[205,"core::fmt"],[206,"heapless::vec"],[207,"core::hash"],[208,"core::cmp"],[209,"core::option"],[210,"core::ops::function"],[211,"core::any"]],"i":[0,0,0,2,2,2,2,2,2,0,0,0,0,2,2,0,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,0,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,0,27,27,0,27,27,27,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,6,0,31,31,6,0,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,36,0,0,0,35,34,35,34,34,35,35,35,35,35,35,34,35,34,35,34,35,34,35,35,34,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,34,35,34,35,34,36,34,35],"f":"```{{{f{bd}}}{{f{b{j{h}}}}}}0{{{f{d}}}{{f{{j{h}}}}}}0{{{f{c}}}{{f{e}}}{}{}}{{{f{bc}}}{{f{be}}}{}{}}{{{f{{j{h}}}}}{{l{c}}}n}{{{f{c}}{f{b{j{h}}}}}{{l{{f{{j{h}}}}}}}{A`Ab}}{{{f{c}}}{{l{d}}}{A`Ab}}{{{f{c}}{f{bd}}}{{l{Ad}}}{A`Ab}}{{{f{d}}}d}{{{f{c}}}Af{}}`{{}d}{{{f{d}}}f}{{{f{bd}}}{{f{b}}}}{c{{Ah{d}}}Aj}{{{f{d}}{f{c}}}Al{{An{{j{h}}}}A`}}`{{{f{d}}{f{bB`}}}{{Ah{AfBb}}}}{cc{}}{{{Bd{h}}}d}{cd{{Bf{{Bd{h}}}}}}{{{f{{j{h}}}}}{{Ah{dAf}}}}{{{f{d}}{f{bc}}}AfBh}{{{f{bd}}Adh}{{Ah{Afh}}}}{{{f{bd}}{f{{j{h}}}}Ad}{{Ah{AfAf}}}}{ce{}{}}{d{{Bd{h}}}}{{{f{bd}}}}{{{f{d}}}}{d}3{{}d}{{{f{d}}{f{c}}}{{Bl{Bj}}}{{An{{j{h}}}}A`}}{{{f{bd}}Ad}{{Ah{hAf}}}}{{{f{bd}}Ad}{{Ah{AfAf}}}}{{{f{bd}}}Af}`{{{f{d}}c}AhBn}{{{f{d}}}{{Ah{dAf}}}}0{c{{Ah{e}}}{}{}}{e{{Ah{dc}}}{}{{Cb{{f{b{j{h}}}}}{{C`{{Ah{Adc}}}}}}}}1{{{f{c}}}Cd{}}{{{f{b{f{bd}}}}{f{{j{h}}}}}{{l{Af}}}}`{{{f{c}}}{{f{e}}}{}{}}{{{f{bc}}}{{f{be}}}{}{}}{{{f{bCf}}c}lCh}0000{{{f{bCf}}{f{Cj}}{f{{j{{f{Cj}}}}}}c}lCh}111111111{{{f{bCf}}{f{Cj}}c}lCh}22221{{{f{bCf}}Adc}lCh}{{{f{bCf}}{f{Cj}}Adc}lCh}444442{cc{}}{{{f{{j{h}}}}}{{l{c}}}n}{{{f{{j{h}}}}}Cf}{ce{}{}}{{{f{{j{h}}}}}{{l{{Cl{c{f{{j{h}}}}}}}}}n}??=``````````````````````````;:{{{f{Cn}}}Cn}{{{f{c}}}Af{}}0{cCnD`}0{{{f{Cn}}{f{Cn}}}Al}{{{f{Cn}}{f{bB`}}}Db}096{{{f{Cj}}}Cn}{c{{Ah{e}}}{}{}}0{{{f{c}}}Cd{}}````{{{f{c}}}{{f{e}}}{}{}}0{{{f{bc}}}{{f{be}}}{}{}}0{{{f{Dd}}}Ad}{{{f{b{Df{c}}}}{f{e}}}{{l{g}}}Dh{D`A`}{}}{{{f{b{Df{c}}}}}{{l{Af}}}Dh}0000{{{f{Dd}}{f{bB`}}}Db}{cc{}}0{ce{}{}}0{{{Df{c}}}cDh}{Dd{{f{b{j{h}}}}}}{{{f{{f{b{Df{c}}}}}}}AlDh}{c{{Df{c}}}Dh}{{{f{b{j{h}}}}}Dd}{{{f{b{Df{c}}}}Al}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{f{{j{h}}}}}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Dj}{{l{Af}}}Dh}{{{f{b{f{b{Df{c}}}}}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}Dl}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Dn}{{l{Af}}}Dh}22{{{f{b{f{b{Df{c}}}}}}{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}0{{{f{b{Df{c}}}}E`}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Eb}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Ed}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Ef}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{Bl{Ad}}}{{l{{`{c}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}}{{l{Af}}}Dh}3{{{f{b{Df{c}}}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}{f{Cj}}}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Ad}{{l{e}}}Dh{}}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}Ad}{{l{e}}}Dh{}}{{{f{b{Df{c}}}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}Ej}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Eh}{{l{Af}}}Dh}{{{f{b{Df{c}}}}El}{{l{Af}}}Dh}{{{f{b{Df{c}}}}h}{{l{Af}}}Dh};9{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}}{{l{Af}}}Dh}{c{{Ah{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{b{Dh{}{{En{c}}}}}}{f{{j{h}}}}}{{Ah{Afc}}}{{Bf{Cn}}}}{{{f{bDd}}{f{{j{h}}}}}{{l{Af}}}}`","D":"Gb","p":[[0,"mut"],[5,"Bytes",0,199],[1,"reference"],[1,"u8"],[1,"slice"],[8,"Result",90],[10,"Deserialize",200],[10,"Sized",201],[10,"Serialize",202],[1,"usize"],[1,"unit"],[6,"Result",203],[10,"Deserializer",200],[1,"bool"],[10,"AsRef",204],[5,"Formatter",205],[5,"Error",205],[5,"Vec",206],[10,"Into",204],[10,"Hasher",207],[6,"Ordering",208],[6,"Option",209],[10,"Serializer",202],[17,"Output"],[10,"FnOnce",210],[5,"TypeId",211],[5,"Deserializer",50],[10,"Visitor",200],[1,"str"],[1,"tuple"],[6,"Error",90],[10,"Display",205],[8,"Result",205],[5,"SliceWriter",132],[5,"Serializer",132],[10,"Writer",132],[1,"char"],[1,"f32"],[1,"f64"],[1,"i16"],[1,"i32"],[1,"i64"],[1,"i8"],[1,"u32"],[1,"u16"],[1,"u64"],[17,"Error"]],"r":[[0,199],[1,90],[2,90]],"b":[[24,"impl-From%3CVec%3Cu8,+N%3E%3E-for-Bytes%3CN%3E"],[25,"impl-Bytes%3CN%3E"],[32,"impl-IntoIterator-for-%26mut+Bytes%3CN%3E"],[33,"impl-IntoIterator-for-%26Bytes%3CN%3E"],[34,"impl-IntoIterator-for-Bytes%3CN%3E"],[121,"impl-Error-for-Error"],[122,"impl-Error-for-Error"],[124,"impl-Debug-for-Error"],[125,"impl-Display-for-Error"],[142,"impl-SerializeStruct-for-%26mut+Serializer%3CW%3E"],[143,"impl-SerializeStructVariant-for-%26mut+Serializer%3CW%3E"],[144,"impl-SerializeTupleStruct-for-%26mut+Serializer%3CW%3E"],[145,"impl-SerializeTuple-for-%26mut+Serializer%3CW%3E"],[146,"impl-SerializeTupleVariant-for-%26mut+Serializer%3CW%3E"],[163,"impl-SerializeTupleVariant-for-%26mut+Serializer%3CW%3E"],[164,"impl-SerializeTupleStruct-for-%26mut+Serializer%3CW%3E"],[165,"impl-SerializeStructVariant-for-%26mut+Serializer%3CW%3E"],[166,"impl-SerializeStruct-for-%26mut+Serializer%3CW%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAI4AEwAAAAQABgAAAAgAAwAOAAkAGQAAABsAAwAhAAIAJgAFAC4AAAAwAAIANAAeAFgAAgB1AAkAgQADAIYABgCOAAYAmwABAJ4AJgDGAAEA"}]\
+["cbor_smol",{"t":"FEENNNNNNHHHHNNCNNNNNCNNNNNNNNNNNNNNNNNNNCNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNHNNNPPPPPPPPPPPPPPPPGPPPIPPPPPNNNNNNNNNNNNNNNNRFFKNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNO","n":["Bytes","Error","Result","as_mut","as_mut_slice","as_ref","as_slice","borrow","borrow_mut","cbor_deserialize","cbor_serialize","cbor_serialize_bytes","cbor_serialize_extending_bytes","clone","clone_to_uninit","de","default","deref","deref_mut","deserialize","eq","error","fmt","from","from","from","from_slice","hash","insert","insert_slice_at","into","into_inner","into_iter","into_iter","into_iter","into_vec","new","partial_cmp","remove","resize_default","resize_to_capacity","ser","serialize","to_bytes","try_convert_into","try_from","try_from","try_into","type_id","write_all","Deserializer","borrow","borrow_mut","deserialize_any","deserialize_bool","deserialize_byte_buf","deserialize_bytes","deserialize_char","deserialize_enum","deserialize_f32","deserialize_f64","deserialize_i16","deserialize_i32","deserialize_i64","deserialize_i8","deserialize_identifier","deserialize_ignored_any","deserialize_map","deserialize_newtype_struct","deserialize_option","deserialize_seq","deserialize_str","deserialize_string","deserialize_struct","deserialize_tuple","deserialize_tuple_struct","deserialize_u16","deserialize_u32","deserialize_u64","deserialize_u8","deserialize_unit","deserialize_unit_struct","from","from_bytes","from_bytes","into","take_from_bytes","try_from","try_into","type_id","DeserializeBadBool","DeserializeBadEnum","DeserializeBadI16","DeserializeBadI32","DeserializeBadI64","DeserializeBadI8","DeserializeBadMajor","DeserializeBadU16","DeserializeBadU32","DeserializeBadU64","DeserializeBadU8","DeserializeBadUtf8","DeserializeExpectedNull","DeserializeNonMinimal","DeserializeUnexpectedEnd","Err","Error","InexistentSliceToArrayError","NotYetImplemented","Ok","Result","SerdeDeCustom","SerdeMissingField","SerdeSerCustom","SerializeBufferFull","WontImplement","borrow","borrow_mut","clone","clone_to_uninit","clone_to_uninit","custom","custom","eq","fmt","fmt","from","into","missing_field","try_from","try_into","type_id","Error","Serializer","SliceWriter","Writer","borrow","borrow","borrow_mut","borrow_mut","bytes_written","collect_str","end","end","end","end","end","fmt","from","from","into","into","into_inner","into_inner","is_human_readable","new","new","serialize_bool","serialize_bytes","serialize_char","serialize_element","serialize_f32","serialize_f64","serialize_field","serialize_field","serialize_field","serialize_field","serialize_i16","serialize_i32","serialize_i64","serialize_i8","serialize_map","serialize_newtype_struct","serialize_newtype_variant","serialize_none","serialize_seq","serialize_some","serialize_str","serialize_struct","serialize_struct_variant","serialize_tuple","serialize_tuple_struct","serialize_tuple_variant","serialize_u16","serialize_u32","serialize_u64","serialize_u8","serialize_unit","serialize_unit_struct","serialize_unit_variant","try_from","try_from","try_into","try_into","type_id","type_id","write_all","write_all","writer"],"q":[[0,"cbor_smol"],[50,"cbor_smol::de"],[90,"cbor_smol::error"],[132,"cbor_smol::ser"],[199,"heapless_bytes"],[200,"serde::de"],[201,"core::marker"],[202,"serde::ser"],[203,"core::result"],[204,"core::convert"],[205,"core::fmt"],[206,"heapless::vec"],[207,"core::hash"],[208,"core::cmp"],[209,"core::option"],[210,"core::ops::function"],[211,"core::any"]],"i":[0,0,0,2,2,2,2,2,2,0,0,0,0,2,2,0,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,0,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,0,27,27,0,27,27,27,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,6,0,31,31,6,0,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,36,0,0,0,35,34,35,34,34,35,35,35,35,35,35,34,35,34,35,34,35,34,35,35,34,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,34,35,34,35,34,36,34,35],"f":"```{{{f{bd}}}{{f{b{j{h}}}}}}0{{{f{d}}}{{f{{j{h}}}}}}0{{{f{c}}}{{f{e}}}{}{}}{{{f{bc}}}{{f{be}}}{}{}}{{{f{{j{h}}}}}{{l{c}}}n}{{{f{c}}{f{b{j{h}}}}}{{l{{f{{j{h}}}}}}}{A`Ab}}{{{f{c}}}{{l{d}}}{A`Ab}}{{{f{c}}{f{bd}}}{{l{Ad}}}{A`Ab}}{{{f{d}}}d}{{{f{c}}}Af{}}`{{}d}{{{f{d}}}f}{{{f{bd}}}{{f{b}}}}{c{{Ah{d}}}Aj}{{{f{d}}{f{c}}}Al{{An{{j{h}}}}A`}}`{{{f{d}}{f{bB`}}}{{Ah{AfBb}}}}{cd{{Bf{{Bd{h}}}}}}{{{Bd{h}}}d}{cc{}}{{{f{{j{h}}}}}{{Ah{dAf}}}}{{{f{d}}{f{bc}}}AfBh}{{{f{bd}}Adh}{{Ah{Afh}}}}{{{f{bd}}{f{{j{h}}}}Ad}{{Ah{AfAf}}}}{ce{}{}}{d{{Bd{h}}}}{d}{{{f{bd}}}}{{{f{d}}}}3{{}d}{{{f{d}}{f{c}}}{{Bl{Bj}}}{{An{{j{h}}}}A`}}{{{f{bd}}Ad}{{Ah{hAf}}}}{{{f{bd}}Ad}{{Ah{AfAf}}}}{{{f{bd}}}Af}`{{{f{d}}c}AhBn}{{{f{d}}}{{Ah{dAf}}}}0{e{{Ah{dc}}}{}{{Cb{{f{b{j{h}}}}}{{C`{{Ah{Adc}}}}}}}}{c{{Ah{e}}}{}{}}0{{{f{c}}}Cd{}}{{{f{b{f{bd}}}}{f{{j{h}}}}}{{l{Af}}}}`{{{f{c}}}{{f{e}}}{}{}}{{{f{bc}}}{{f{be}}}{}{}}{{{f{bCf}}c}lCh}0000{{{f{bCf}}{f{Cj}}{f{{j{{f{Cj}}}}}}c}lCh}111111111{{{f{bCf}}{f{Cj}}c}lCh}22221{{{f{bCf}}Adc}lCh}{{{f{bCf}}{f{Cj}}Adc}lCh}444442{cc{}}{{{f{{j{h}}}}}{{l{c}}}n}{{{f{{j{h}}}}}Cf}{ce{}{}}{{{f{{j{h}}}}}{{l{{Cl{c{f{{j{h}}}}}}}}}n}>>=``````````````````````````;:{{{f{Cn}}}Cn}{{{f{c}}}Af{}}0{cCnD`}0{{{f{Cn}}{f{Cn}}}Al}{{{f{Cn}}{f{bB`}}}Db}096{{{f{Cj}}}Cn}{c{{Ah{e}}}{}{}}0{{{f{c}}}Cd{}}````{{{f{c}}}{{f{e}}}{}{}}0{{{f{bc}}}{{f{be}}}{}{}}0{{{f{Dd}}}Ad}{{{f{b{Df{c}}}}{f{e}}}{{l{g}}}Dh{D`A`}{}}{{{f{b{Df{c}}}}}{{l{Af}}}Dh}0000{{{f{Dd}}{f{bB`}}}Db}{cc{}}0{ce{}{}}0{{{Df{c}}}cDh}{Dd{{f{b{j{h}}}}}}{{{f{{f{b{Df{c}}}}}}}AlDh}{c{{Df{c}}}Dh}{{{f{b{j{h}}}}}Dd}{{{f{b{Df{c}}}}Al}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{f{{j{h}}}}}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Dj}{{l{Af}}}Dh}{{{f{b{f{b{Df{c}}}}}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}Dl}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Dn}{{l{Af}}}Dh}22{{{f{b{f{b{Df{c}}}}}}{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}0{{{f{b{Df{c}}}}E`}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Eb}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Ed}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Ef}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{Bl{Ad}}}{{l{{`{c}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}}{{l{Af}}}Dh}3{{{f{b{Df{c}}}}{f{e}}}{{l{Af}}}Dh{A`Ab}}{{{f{b{Df{c}}}}{f{Cj}}}{{l{Af}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Ad}{{l{e}}}Dh{}}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}Ad}{{l{e}}}Dh{}}{{{f{b{Df{c}}}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}Ad}{{l{{f{b{Df{c}}}}}}}Dh}{{{f{b{Df{c}}}}Ej}{{l{Af}}}Dh}{{{f{b{Df{c}}}}Eh}{{l{Af}}}Dh}{{{f{b{Df{c}}}}El}{{l{Af}}}Dh}{{{f{b{Df{c}}}}h}{{l{Af}}}Dh};9{{{f{b{Df{c}}}}{f{Cj}}Eh{f{Cj}}}{{l{Af}}}Dh}{c{{Ah{e}}}{}{}}000{{{f{c}}}Cd{}}0{{{f{b{Dh{}{{En{c}}}}}}{f{{j{h}}}}}{{Ah{Afc}}}{{Bf{Cn}}}}{{{f{bDd}}{f{{j{h}}}}}{{l{Af}}}}`","D":"Gb","p":[[0,"mut"],[5,"Bytes",0,199],[1,"reference"],[1,"u8"],[1,"slice"],[8,"Result",90],[10,"Deserialize",200],[10,"Sized",201],[10,"Serialize",202],[1,"usize"],[1,"unit"],[6,"Result",203],[10,"Deserializer",200],[1,"bool"],[10,"AsRef",204],[5,"Formatter",205],[5,"Error",205],[5,"Vec",206],[10,"Into",204],[10,"Hasher",207],[6,"Ordering",208],[6,"Option",209],[10,"Serializer",202],[17,"Output"],[10,"FnOnce",210],[5,"TypeId",211],[5,"Deserializer",50],[10,"Visitor",200],[1,"str"],[1,"tuple"],[6,"Error",90],[10,"Display",205],[8,"Result",205],[5,"SliceWriter",132],[5,"Serializer",132],[10,"Writer",132],[1,"char"],[1,"f32"],[1,"f64"],[1,"i16"],[1,"i32"],[1,"i64"],[1,"i8"],[1,"u32"],[1,"u16"],[1,"u64"],[17,"Error"]],"r":[[0,199],[1,90],[2,90]],"b":[[23,"impl-Bytes%3CN%3E"],[24,"impl-From%3CVec%3Cu8,+N%3E%3E-for-Bytes%3CN%3E"],[32,"impl-IntoIterator-for-Bytes%3CN%3E"],[33,"impl-IntoIterator-for-%26mut+Bytes%3CN%3E"],[34,"impl-IntoIterator-for-%26Bytes%3CN%3E"],[121,"impl-Error-for-Error"],[122,"impl-Error-for-Error"],[124,"impl-Display-for-Error"],[125,"impl-Debug-for-Error"],[142,"impl-SerializeStructVariant-for-%26mut+Serializer%3CW%3E"],[143,"impl-SerializeTupleVariant-for-%26mut+Serializer%3CW%3E"],[144,"impl-SerializeTupleStruct-for-%26mut+Serializer%3CW%3E"],[145,"impl-SerializeTuple-for-%26mut+Serializer%3CW%3E"],[146,"impl-SerializeStruct-for-%26mut+Serializer%3CW%3E"],[163,"impl-SerializeTupleVariant-for-%26mut+Serializer%3CW%3E"],[164,"impl-SerializeTupleStruct-for-%26mut+Serializer%3CW%3E"],[165,"impl-SerializeStruct-for-%26mut+Serializer%3CW%3E"],[166,"impl-SerializeStructVariant-for-%26mut+Serializer%3CW%3E"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAI4AEgAAAAQABgAAAAgAAwAOAAkAGQAAABsAAwAhAAIAJgAFAC8AAwA0AB4AWAACAHUACQCBAAMAhgAGAI4ABgCbAAEAngAmAMYAAQA="}]\
]'));
if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
else if (window.initSearch) window.initSearch(searchIndex);
diff --git a/search.desc/cbor_smol/cbor_smol-desc-0-.js b/search.desc/cbor_smol/cbor_smol-desc-0-.js
index d138d76..daff7a1 100644
--- a/search.desc/cbor_smol/cbor_smol-desc-0-.js
+++ b/search.desc/cbor_smol/cbor_smol-desc-0-.js
@@ -1 +1 @@
-searchState.loadedDescShard("cbor_smol", 0, "Returns a mutable slice view.\nReturns an immutable slice view.\nSerialize object into newly allocated Bytes.\nAppend serialization of object to existing bytes, …\nReturns the argument unchanged.\nWrap existing bytes in a Bytes<N>.\nCalls U::from(self).\nUnwraps the Vec<u8, N>, same as into_vec.\nUnwraps the Vec<u8, N>, same as into_inner.\nConstruct a new, empty Bytes<N>.\nFallible conversion into differently sized byte buffer.\nLow-noise conversion between lengths.\nSome APIs offer an interface of the form …\nA structure for deserializing a cbor-smol message.\nReturns the argument unchanged.\nDeserialize a message of type T from a byte slice. The …\nObtain a Deserializer from a slice of bytes\nCalls U::from(self).\nDeserialize a message of type T from a byte slice. The …\nFound a bool that wasn’t 0xf4 or 0xf5\nCould not parse an enum\nExpected a i16, was too large\nExpected a i32, was too large\nExpected a i64, was too large\nExpected a i8, was too large\nExpected a different major type\nExpected a u16\nExpected a u32\nExpected a u64\nExpected a u8\nTried to parse invalid utf-8\nExpected a NULL marker\nValue may be valid, but not encoded in minimal way\nHit the end of buffer, expected more data\nContains the error value\nThis is the error type used by cbor-smol\nInexistent slice-to-array cast error. Used here to avoid …\nThis is a feature that cbor-smol intends to support, but …\nContains the success value\nThis is the Result type used by cbor-smol.\nSerde Deserialization Error\nSerde Missing required value\nSerde Serialization Error\nThe serialize buffer is full\nThis is a feature that cbor-smol will never implement\nReturns the argument unchanged.\nCalls U::from(self).\nThe type of error returned when a write operation fails.\nReturns the number of bytes written to the underlying …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nUnwrap the Writer from the Serializer.\nReturns the underlying slice.\nWraps a mutable slice so it can be used as a Writer.\nAttempts to write an entire buffer into this write.")
\ No newline at end of file
+searchState.loadedDescShard("cbor_smol", 0, "Returns a mutable slice view.\nReturns an immutable slice view.\nSerialize object into newly allocated Bytes.\nAppend serialization of object to existing bytes, …\nWrap existing bytes in a Bytes<N>.\nReturns the argument unchanged.\nCalls U::from(self).\nUnwraps the Vec<u8, N>, same as into_vec.\nUnwraps the Vec<u8, N>, same as into_inner.\nConstruct a new, empty Bytes<N>.\nFallible conversion into differently sized byte buffer.\nLow-noise conversion between lengths.\nSome APIs offer an interface of the form …\nA structure for deserializing a cbor-smol message.\nReturns the argument unchanged.\nDeserialize a message of type T from a byte slice. The …\nObtain a Deserializer from a slice of bytes\nCalls U::from(self).\nDeserialize a message of type T from a byte slice. The …\nFound a bool that wasn’t 0xf4 or 0xf5\nCould not parse an enum\nExpected a i16, was too large\nExpected a i32, was too large\nExpected a i64, was too large\nExpected a i8, was too large\nExpected a different major type\nExpected a u16\nExpected a u32\nExpected a u64\nExpected a u8\nTried to parse invalid utf-8\nExpected a NULL marker\nValue may be valid, but not encoded in minimal way\nHit the end of buffer, expected more data\nContains the error value\nThis is the error type used by cbor-smol\nInexistent slice-to-array cast error. Used here to avoid …\nThis is a feature that cbor-smol intends to support, but …\nContains the success value\nThis is the Result type used by cbor-smol.\nSerde Deserialization Error\nSerde Missing required value\nSerde Serialization Error\nThe serialize buffer is full\nThis is a feature that cbor-smol will never implement\nReturns the argument unchanged.\nCalls U::from(self).\nThe type of error returned when a write operation fails.\nReturns the number of bytes written to the underlying …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nUnwrap the Writer from the Serializer.\nReturns the underlying slice.\nWraps a mutable slice so it can be used as a Writer.\nAttempts to write an entire buffer into this write.")
\ No newline at end of file
diff --git a/src/cbor_smol/de.rs.html b/src/cbor_smol/de.rs.html
index cc4a524..2014905 100644
--- a/src/cbor_smol/de.rs.html
+++ b/src/cbor_smol/de.rs.html
@@ -1292,7 +1292,6 @@
1292
1293
1294
-1295
use serde::Deserialize;
use serde::de::IntoDeserializer;
@@ -1894,8 +1893,7 @@
{
let major = self.peek_major()?;
match major {
- #[cfg(feature = "bytes-from-array")]
- MAJOR_ARRAY => {
+ MAJOR_ARRAY => {
let len = self.raw_deserialize_u32(MAJOR_ARRAY)?;
visitor.visit_seq(SeqAccess {
deserializer: self,