rmp-serde

https://docs.rs/rmp-serde/latest/
Admin
This crate connects the Rust MessagePack library with Serde, enabling easy serialization and...
Tokens:199,771
Snippets:1,194
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Example Serde Implementation for Custom Type in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/constant.MSGPACK_EXT_STRUCT_NAME

Demonstrates how to implement Serde's Serialize and Deserialize traits for a custom type that needs to represent MessagePack Extension types. The example shows the use of #[serde(rename = "_ExtStruct")] to match the constant defined for extension types.

```rust
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename = "_ExtStruct")]
struct ExtStruct((i8, serde_bytes::ByteBuf));

test_round(ExtStruct((2, serde_bytes::ByteBuf::from(vec![5]))),
           Value::Ext(2, vec![5]));
```

--------------------------------

### Rust: Deserializer Construction and Accessors

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=u32+-%3E+bool

Provides methods for creating a Deserializer instance from a reader, accessing the underlying reader, and consuming the deserializer to get the inner reader.

```rust
pub fn new(rd: R) -> Self
```

```rust
pub fn get_ref(&self) -> &R
```

```rust
pub fn get_mut(&mut self) -> &mut R
```

```rust
pub fn into_inner(self) -> R
```

--------------------------------

### Rust: Access Underlying Reader in rmp-serde Deserializer

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=

Provides examples of how to get a reference or a mutable reference to the underlying reader (or byte slice) from a `Deserializer` instance. This can be useful for inspecting the reader's state or performing operations on it without consuming the deserializer.

```Rust
use rmp_serde::Deserializer;

// Assuming 'deserializer' is a Deserializer instance
// let reader_ref = deserializer.get_ref();
// let reader_mut = deserializer.get_mut();

```

--------------------------------

### Create New BinaryConfig Instance

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a constructor for BinaryConfig that takes an existing configuration and creates a new BinaryConfig instance, inheriting unchanged options. This is used to configure binary serialization.

```rust
pub const fn new(inner: C) -> Self
```

--------------------------------

### UnderlyingWrite Implementation for Serializer

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/encode.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the UnderlyingWrite trait for the Serializer, providing access to the underlying writer. This includes methods to get a reference to the writer, get a mutable reference, and consume the serializer to retrieve the writer.

```rust
impl<W: Write, C> UnderlyingWrite for Serializer<W, C> {
    type Write = W;

    #[inline(always)]
    fn get_ref(&self) -> &Self::Write {
        &self.wr
    }

    #[inline(always)]
    fn get_mut(&mut self) -> &mut Self::Write {
        &mut self.wr
    }

    #[inline(always)]
    fn into_inner(self) -> Self::Write {
        self.wr
    }
}
```

--------------------------------

### BinaryConfig API

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig

Provides details about the BinaryConfig struct, its constructor, and its associated trait implementations.

```APIDOC
## Struct BinaryConfig

### Description
`BinaryConfig` is a configuration wrapper that forces `Serializer::is_human_readable` and `Deserializer::is_human_readable` to return `false`, ensuring binary output.

### Constructor
#### `new(inner: C) -> Self`
Creates a `BinaryConfig` by inheriting unchanged configuration options from the provided configuration `inner`.

### Implementations

#### `Clone` for `BinaryConfig<C>`
- `clone(&self) -> BinaryConfig<C>`: Returns a duplicate of the `BinaryConfig`.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from a source `BinaryConfig`.

#### `Debug` for `BinaryConfig<C>`
- `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the `BinaryConfig` using the given formatter.

#### `Copy` for `BinaryConfig<C>`
- This struct implements the `Copy` trait, allowing for simple bitwise copies.

#### Auto Trait Implementations
- `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, `UnwindSafe` are implemented for `BinaryConfig<C>` based on the `C` type parameter's implementations.

#### Blanket Implementations
- `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `From`, `Into`, `ToOwned`, `TryFrom`, `TryInto`, `SerializerConfig` are implemented for `BinaryConfig<C>` under certain trait bounds, leveraging the implementations of the inner configuration type `C`.
```

--------------------------------

### Create New BinaryConfig Instance in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig_search=

Provides a constructor function `new` for BinaryConfig in Rust. This function takes an existing configuration `inner` and creates a new BinaryConfig instance, inheriting unchanged configuration options.

```rust
pub const fn new(inner: C) -> Self

```

--------------------------------

### Sequence Serialization

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtSerializer

Provides methods to start, serialize elements, and end the serialization of sequences.

```APIDOC
## POST /serialize/seq

### Description
Begins serialization of a variably or statically sized sequence.

### Method
POST

### Endpoint
`/serialize/seq`

### Parameters
#### Query Parameters
- **len** (integer) - Optional - The expected length of the sequence if known.

### Request Body
- **elements** (array) - Required - An array of elements to serialize within the sequence.

### Request Example
```json
{
  "elements": [1, 2, 3]
}
```

### Response
#### Success Response (200)
- **Ok** (any) - The result of the serialization.

#### Response Example
```json
{
  "Ok": "serialized_sequence_data"
}
```
```

--------------------------------

### Get TypeId for Any trait

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer

Method to retrieve the `TypeId` of a type implementing the `Any` trait. This is useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId

```

--------------------------------

### Deserializer Construction and Configuration

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer

Provides methods for creating and configuring the `Deserializer`. This includes constructing it from a reader, accessing or consuming the underlying reader, and switching between human-readable and binary deserialization modes.

```rust
pub struct Deserializer<R, C = DefaultConfig> { /* private fields */ }

pub fn new(rd: R) -> Self

 gets a reference to the underlying reader in this decoder.
pub fn get_ref(&self) -> &R

Gets a mutable reference to the underlying reader in this decoder.
pub fn get_mut(&mut self) -> &mut R

Consumes this deserializer returning the underlying reader.
pub fn into_inner(self) -> R

Consumes this deserializer and returns a new one, which will deserialize types with human-readable representations (`Deserializer::is_human_readable` will return `true`).
This is primarily useful if you need to interoperate with serializations produced by older versions of `rmp-serde`.
pub fn with_human_readable(self) -> Deserializer<R, HumanReadableConfig<C>>

Consumes this deserializer and returns a new one, which will deserialize types with binary representations (`Deserializer::is_human_readable` will return `false`).
This is the default MessagePack deserialization mechanism, consuming the most compact representation.
pub fn with_binary(self) -> Deserializer<R, BinaryConfig<C>>
```

```rust
pub fn from_read_ref(rd: &'de R) -> Self

Gets a reference to the underlying reader in this decoder.
pub fn get_ref(&self) -> &R
```

--------------------------------

### Rust: Generic Blanket Implementations for T

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig

Details several blanket implementations for any type T, indicating that BinaryConfig can leverage these common Rust traits. These include Any, Borrow, BorrowMut, CloneToUninit, From, Into, ToOwned, TryFrom, and TryInto.

```rust
impl<T> Any for T where T: 'static + ?Sized

impl<T> Borrow<T> for T where T: ?Sized

impl<T> BorrowMut<T> for T where T: ?Sized

impl<T> CloneToUninit for T where T: Clone

impl<T> From<T> for T

impl<T, U> Into<U> for T where U: From<T>

impl<T> ToOwned for T where T: Clone

impl<T, U> TryFrom<U> for T where U: Into<T>

impl<T, U> TryInto<U> for T where U: TryFrom<T>

```

--------------------------------

### Struct Variant Serialization

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.Serializer_search=

Starts the serialization of a struct variant within an enum. This must be followed by field serialization and `end`.

```APIDOC
## POST /serialize/struct_variant

### Description
Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`.

### Method
POST

### Endpoint
/serialize/struct_variant

### Parameters
#### Query Parameters
- **name** (&'static str) - Required - The name of the enum.
- **variant** (&'static str) - Required - The name of the struct variant.
- **len** (usize) - Required - The number of fields in the struct variant.

### Request Body
(Not applicable for this method, data is serialized via subsequent calls)

### Response
#### Success Response (200)
- **SerializeStructVariant** - An object representing the struct variant serialization context.

#### Response Example
```json
{
  "message": "Struct variant serialization initiated successfully"
}
```
```

--------------------------------

### RawRef Constructor and Conversion Methods in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/lib.rs_search=u32+-%3E+bool

Provides methods for creating and inspecting `RawRef` instances. Includes a constructor `new` for valid strings, a deprecated `from_utf8` for byte slices, and helper methods like `is_str`, `is_err`, `as_str`, `as_err`, and `as_bytes` to query the content.

```rust
impl<'a> RawRef<'a> {
    /// Constructs a new `RawRef` from the UTF-8 string.
    #[inline]
    #[must_use]
    pub fn new(v: &'a str) -> Self {
        Self { s: Ok(v) }
    }

    #[deprecated(note = "This feature has been removed")]
    #[must_use]
    pub fn from_utf8(v: &'a [u8]) -> Self {
        match str::from_utf8(v) {
            Ok(v) => RawRef::new(v),
            Err(err) => Self { s: Err((v, err)) },
        }
    }

    /// Returns `true` if the raw is valid UTF-8.
    #[inline]
    #[must_use]
    pub fn is_str(&self) -> bool {
        self.s.is_ok()
    }

    /// Returns `true` if the raw contains invalid UTF-8 sequence.
    #[inline]
    #[must_use]
    pub fn is_err(&self) -> bool {
        self.s.is_err()
    }

    /// Returns the string reference if the raw is valid UTF-8, or else `None`.
    #[inline]
    #[must_use]
    pub fn as_str(&self) -> Option<&str> {
        self.s.ok()
    }

    /// Returns the underlying `Utf8Error` if the raw contains invalid UTF-8 sequence, or
    /// else `None`.
    #[inline]
    #[must_use]
    pub fn as_err(&self) -> Option<&Utf8Error> {
        match self.s {
            Ok(..) => None,
            Err((_, ref err)) => Some(err),
        }
    }

    /// Returns a byte slice of this raw's contents.
    #[inline]
    #[must_use]
    pub fn as_bytes(&self) -> &[u8] {
        match self.s {
            Ok(s) => s.as_bytes(),
            Err((bytes, _err)) => bytes,
        }
    }
}
```

--------------------------------

### Create New `ExtFieldSerializer`

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/encode.rs_search=u32+-%3E+bool

Initializes a new `ExtFieldSerializer`. It gets a mutable reference to the underlying writer and sets initial states for `tag` and `finish`.

```Rust
#[inline]
fn new<C>(ser: &'a mut Serializer<W, C>) -> Self {
    Self {
        wr: UnderlyingWrite::get_mut(ser),
        tag: None,
        finish: false,
    }
}
```

--------------------------------

### Implement Debug for BinaryConfig in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig_search=

Demonstrates the implementation of the `Debug` trait for BinaryConfig in Rust. The `fmt` method allows the BinaryConfig struct to be formatted for debugging purposes using a given formatter.

```rust
impl<C: Debug> Debug for BinaryConfig<C>

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

```

--------------------------------

### Rust: Construct rmp-serde Deserializer from Reader

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=

Demonstrates how to create a new `Deserializer` instance by providing a reader (e.g., from a file or network stream). This is the primary method for initializing the deserializer when reading from a dynamic source.

```Rust
use rmp_serde::Deserializer;
use std::io::Read;

// Assuming 'reader' is a type that implements std::io::Read
// let mut deserializer = Deserializer::new(reader);

```

--------------------------------

### Get underlying reader mutable reference in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/decode.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `get_mut` method returns a mutable reference to the underlying reader (`R`) wrapped by `ReadReader`. This allows modifying the reader in place.

```Rust
pub fn get_mut(&mut self) -> &mut R {
    &mut self.rd.rd
}
```

--------------------------------

### Get underlying reader reference in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/decode.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `get_ref` method returns an immutable reference to the underlying reader (`R`) wrapped by `ReadReader`. This allows inspecting the reader without consuming it.

```Rust
pub fn get_ref(&self) -> &R {
    &self.rd.rd
}
```

--------------------------------

### Implement Clone for BinaryConfig in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig_search=

Shows the implementation of the `Clone` trait for BinaryConfig in Rust. It includes the `clone` method to create a duplicate of the BinaryConfig value and `clone_from` for copy-assignment.

```rust
impl<C: Clone> Clone for BinaryConfig<C>

fn clone(&self) -> BinaryConfig<C>

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

```

--------------------------------

### Rust: Deserializer Position and Creation from Byte Slice

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=u32+-%3E+bool

Enables getting the current position (bytes read) of the deserializer and constructing a deserializer directly from a byte slice reference.

```rust
pub fn position(&self) -> u64
```

```rust
pub fn from_read_ref(rd: &'de R) -> Self
```

```rust
pub fn get_ref(&self) -> &R
```

--------------------------------

### BinaryConfig Constructor and SerializerConfig Implementation

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/config.rs_search=std%3A%3Avec

Defines the `BinaryConfig` struct and its constructor `new`. It implements the `SerializerConfig` trait, overriding `is_human_readable` to always return `false`, thus enforcing binary output.

```Rust
impl<C> BinaryConfig<C> {
    /// Creates a `BinaryConfig` inheriting unchanged configuration options from the given configuration.
    #[inline(always)]
    pub const fn new(inner: C) -> Self {
        Self(inner)
    }
}

impl<C> sealed::SerializerConfig for BinaryConfig<C>
where
    C: sealed::SerializerConfig,
{
    #[inline(always)]
    fn is_named(&self) -> bool {
        self.0.is_named()
    }

    #[inline(always)]
    fn is_human_readable(&self) -> bool {
        false
    }

    fn bytes(&self) -> BytesMode {
        self.0.bytes()
    }
}
```

--------------------------------

### Rust: Deserializer Trait Implementations for Visitor Pattern

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=u32+-%3E+bool

Demonstrates the implementation of various `Deserialize` trait methods for the `Deserializer`. These methods drive the Visitor pattern, allowing flexible deserialization of different data types like sequences, options, enums, and primitives.

```rust
fn is_human_readable(&self) -> bool
```

```rust
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_enum<V>( self, _name: &str, _variants: &[&str], visitor: V, ) -> Result<V::Value, Error>
```

```rust
fn deserialize_newtype_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, Error>
```

```rust
fn deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
```

```rust
fn deserialize_tuple<V>( self, _len: usize, visitor: V, ) -> Result<V::Value, Self::Error>
```

--------------------------------

### Get Underlying Reader from Deserializer in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/decode.rs

Retrieves a reference to the underlying reader used by the deserializer. This can be useful for inspecting the data source or performing operations directly on the reader.

```rust
impl<'de, R>
Deserializer<ReadRefReader<'de, R>>
where
    R: AsRef<[u8]> + ?Sized,
{
    /// Gets a reference to the underlying reader in this decoder.
    #[inline(always)]
    #[must_use]
    pub fn get_ref(&self) -> &R {
        self.rd.whole_slice
    }
}
```

--------------------------------

### Access Underlying Writer

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.Serializer_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods to access the underlying writer (`W`) of the `Serializer`. This includes getting an immutable reference, a mutable reference, or taking ownership of the writer.

```rust
type Write = W

fn get_ref(&self) -> &Self::Write

fn get_mut(&mut self) -> &mut Self::Write

fn into_inner(self) -> Self::Write
```

--------------------------------

### ReadRefReader Blanket Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.ReadRefReader

Details the blanket implementations for ReadRefReader, including Any, Borrow, BorrowMut, From, Into, RmpRead, and TryFrom.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId

**Description:** Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T

**Description:** Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T

**Description:** Mutably borrows from an owned value.

### impl<T> From<T> for T

#### fn from(t: T) -> T

**Description:** Returns the argument unchanged.

### impl<T, U> Into<U> for T

#### fn into(self) -> U

**Description:** Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T> RmpRead for T

#### type Error = Error

#### fn read_exact_buf( &mut self, buf: &mut [u8], ) -> Result<(), <T as RmpRead>::Error>

**Description:** Read the exact number of bytes needed to fill the specified buffer.

#### fn read_u8(&mut self) -> Result<u8, Self::Error>

**Description:** Read a single (unsigned) byte from this stream

### impl<T, U> TryFrom<U> for T
```

--------------------------------

### StructTupleConfig Configuration

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.StructTupleConfig

Documentation for the StructTupleConfig struct and its associated methods.

```APIDOC
## Struct StructTupleConfig

rmp_serde::config

# Struct StructTupleConfig Copy item path
Source
Search
Settings
Help

### Summary

```rust
pub struct StructTupleConfig<C>(/* private fields */);
```

Config wrapper that overrides struct serlization by packing as a tuple without field names.

### Implementations

#### impl<C> StructTupleConfig<C>

##### pub const fn new(inner: C) -> Self

Creates a `StructTupleConfig` inheriting unchanged configuration options from the given configuration.

### Trait Implementations

#### impl<C: Clone> Clone for StructTupleConfig<C>

##### fn clone(&self) -> StructTupleConfig<C>

Returns a duplicate of the value.

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

Performs copy-assignment from `source`.

#### impl<C: Debug> Debug for StructTupleConfig<C>

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

Formats the value using the given formatter.

#### impl<C: Copy> Copy for StructTupleConfig<C>

### Auto Trait Implementations

#### impl<C> Freeze for StructTupleConfig<C>

#### impl<C> RefUnwindSafe for StructTupleConfig<C>

#### impl<C> Send for StructTupleConfig<C>

#### impl<C> Sync for StructTupleConfig<C>

#### impl<C> Unpin for StructTupleConfig<C>

#### impl<C> UnwindSafe for StructTupleConfig<C>

### Blanket Implementations

#### impl<T> Any for T

##### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.

#### impl<T> Borrow<T> for T

##### fn borrow(&self) -> &T

Immutably borrows from an owned value.

#### impl<T> BorrowMut<T> for T

##### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

#### impl<T> CloneToUninit for T

##### unsafe fn clone_to_uninit(&self, dest: *mut u8)

Performs copy-assignment from `self` to `dest`.

#### impl<T> From<T> for T

##### fn from(t: T) -> T

Returns the argument unchanged.

#### impl<T, U> Into<U> for T

##### fn into(self) -> U

Calls `U::from(self)`.

#### impl<T> ToOwned for T

##### type Owned = T

The resulting type after obtaining ownership.

##### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning.

##### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning.

#### impl<T, U> TryFrom<U> for T

##### type Error = Infallible

The type returned in the event of a conversion error.

##### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

#### impl<T, U> TryInto<U> for T

##### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

##### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

#### impl<T> SerializerConfig for T

```

--------------------------------

### Serialize Structs and Variants in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtSerializer_search=std%3A%3Avec

Handles the serialization of structs, tuple structs, and their corresponding enum variants. This includes methods for starting the serialization, adding fields, and ending the serialization process.

```rust
fn serialize_newtype_variant<T>( self, _name: &'static str, _idx: u32, _variant: &'static str, _value: &T, ) -> Result<Self::Ok, Self::Error>
where T: Serialize + ?Sized,
Serialize a newtype variant like `E::N` in `enum E { N(u8) }`. Read more
Source§

fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeTupleStruct, Error>
Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`. Read more
Source§

fn serialize_tuple_variant( self, _name: &'static str, _idx: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeTupleVariant, Error>
Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8) }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`. Read more
Source§

fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Error>
Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`. Read more
Source§

fn serialize_struct_variant( self, _name: &'static str, _idx: u32, _variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant, Error>
Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`. Read more
Source§
```

--------------------------------

### Serialize Tuple Struct - Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtFieldSerializer_search=u32+-%3E+bool

Starts the serialization process for a tuple struct (e.g., `struct Rgb(u8, u8, u8)`). It necessitates calling `serialize_field` for each field and concluding with `end`.

```rust
fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Error>
```

--------------------------------

### BinaryConfig Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig_search=u32+-%3E+bool

Details on the implementations of traits for the BinaryConfig struct, including Clone, Debug, Copy, and various auto-trait and blanket implementations.

```APIDOC
## Implementations for BinaryConfig<C>

### `impl<C: Clone> Clone for BinaryConfig<C>`
#### `clone(&self) -> BinaryConfig<C>`
Returns a duplicate of the value.

#### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl<C: Debug> Debug for BinaryConfig<C>`
#### `fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `impl<C: Copy> Copy for BinaryConfig<C>`

### Auto Trait Implementations
- `Freeze` for `BinaryConfig<C>` where `C: Freeze`
- `RefUnwindSafe` for `BinaryConfig<C>` where `C: RefUnwindSafe`
- `Send` for `BinaryConfig<C>` where `C: Send`
- `Sync` for `BinaryConfig<C>` where `C: Sync`
- `Unpin` for `BinaryConfig<C>` where `C: Unpin`
- `UnwindSafe` for `BinaryConfig<C>` where `C: UnwindSafe`

### Blanket Implementations
- `impl<T> Any for T where T: 'static + ?Sized`
- `impl<T> Borrow<T> for T where T: ?Sized`
- `impl<T> BorrowMut<T> for T where T: ?Sized`
- `impl<T> CloneToUninit for T where T: Clone`
- `impl<T> From<T> for T`
- `impl<T, U> Into<U> for T where U: From<T>`
- `impl<T> ToOwned for T where T: Clone`
- `impl<T, U> TryFrom<U> for T where U: Into<T>`
- `impl<T, U> TryInto<U> for T where U: TryFrom<T>`
- `impl<T> SerializerConfig for T where T: SerializerConfig`
```

--------------------------------

### Rust Blanket Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtSerializer_search=std%3A%3Avec

Illustrates various blanket implementations in Rust, which apply traits to many types automatically. This includes implementations for `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, and `TryFrom`, showcasing common Rust programming patterns.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§

fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,
Source§

fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,
Source§

fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T
Source§

fn from(t: T) -> T
Returns the argument unchanged.
Source§

impl<T, U> Into<U> for T
where U: From<T>,
Source§

fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,
Source§

type Error = Infallible
The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
Source§
```

--------------------------------

### Serializer Configuration

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.Serializer_search=u32+-%3E+bool

The `Serializer` struct in rmp-serde allows for flexible MessagePack serialization with various configuration options. You can construct a new serializer, get references to the underlying writer, or convert it back into the writer.

```APIDOC
## Serializer API

### `Serializer::new(wr: W) -> Serializer<W, DefaultConfig>`

**Description**: Constructs a new MessagePack serializer that outputs to the provided writer. This is the default constructor, producing the most compact representation for structs and enums.

**Method**: `new`

**Endpoint**: N/A (struct method)

### `Serializer::get_ref(&self) -> &W`

**Description**: Returns a reference to the underlying writer.

**Method**: `get_ref`

**Endpoint**: N/A (struct method)

### `Serializer::get_mut(&mut self) -> &mut W`

**Description**: Returns a mutable reference to the underlying writer. Direct writes to the writer are inadvisable.

**Method**: `get_mut`

**Endpoint**: N/A (struct method)

### `Serializer::into_inner(self) -> W`

**Description**: Consumes the serializer and returns the underlying writer.

**Method**: `into_inner`

**Endpoint**: N/A (struct method)

### `Serializer::with_struct_map(self) -> Serializer<W, StructMapConfig<C>>`

**Description**: Returns a new serializer that encodes structs as maps. This is useful when the default tuple representation is not suitable.

**Method**: `with_struct_map`

**Endpoint**: N/A (struct method)

### `Serializer::with_struct_tuple(self) -> Serializer<W, StructTupleConfig<C>>`

**Description**: Returns a new serializer that encodes structs as tuples without field names, adhering to the default compact MessagePack representation.

**Method**: `with_struct_tuple`

**Endpoint**: N/A (struct method)

### `Serializer::with_human_readable(self) -> Serializer<W, HumanReadableConfig<C>>`

**Description**: Returns a new serializer that encodes certain types in a human-readable string format. This is primarily for interoperability with older `rmp-serde` versions.

**Method**: `with_human_readable`

**Endpoint**: N/A (struct method)

### `Serializer::with_binary(self) -> Serializer<W, BinaryConfig<C>>`

**Description**: Returns a new serializer that encodes types using the default compact binary representation. `is_human_readable` will return `false`.

**Method**: `with_binary`

**Endpoint**: N/A (struct method)

### `Serializer::with_bytes(self, mode: BytesMode) -> Self`

**Description**: Configures the serializer to prefer encoding `u8` sequences as bytes. This can reduce overhead but might affect compatibility with Serde types that don't implement `visit_bytes`.

**Parameters**:

#### Query Parameters

- **mode** (BytesMode) - Required - Specifies the byte encoding mode (e.g., `ForceAll`).

**Request Example**:
```json
{
  "example": "use serde::ser::Serialize;\nlet mut msgpack_data = Vec::new();\nlet mut serializer = rmp_serde::Serializer::new(&mut msgpack_data)\n    .with_bytes(rmp_serde::config::BytesMode::ForceAll);\nvec![255u8; 100].serialize(&mut serializer).unwrap();"
}
```
```

--------------------------------

### UnderlyingWrite Trait Definition (Rust)

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/trait.UnderlyingWrite

Defines the UnderlyingWrite trait, which allows access to the underlying writer. It has an associated type 'Write' and methods to get a reference, a mutable reference, or consume the serializer.

```rust
pub trait UnderlyingWrite {
    type Write: Write;

    // Required methods
    fn get_ref(&self) -> &Self::Write;
    fn get_mut(&mut self) -> &mut Self::Write;
    fn into_inner(self) -> Self::Write;
}
```

--------------------------------

### Implement Clone for DefaultConfig

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.DefaultConfig_search=std%3A%3Avec

Provides the ability to clone the DefaultConfig struct. This allows for creating duplicate instances of the default configuration, which can be useful for managing serialization settings.

```rust
impl Clone for DefaultConfig {
    fn clone(&self) -> DefaultConfig {
        // Implementation details would be here
    }

    fn clone_from(&mut self, source: &Self) {
        // Implementation details would be here
    }
}

```

--------------------------------

### Create HumanReadableConfig Instance in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.HumanReadableConfig_search=

Provides a constructor function for HumanReadableConfig. This function initializes the config wrapper by taking an existing configuration of type C and returning a new HumanReadableConfig instance.

```rust
pub const fn new(inner: C) -> Self;

```

--------------------------------

### Get current position of Deserializer in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/decode.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `position` method returns the current position (number of bytes read) of the deserializer. This is applicable when the underlying reader is a `Cursor` wrapping a byte slice, allowing tracking of deserialization progress.

```Rust
pub fn position(&self) -> u64 {
    self.rd.rd.position()
}
```

--------------------------------

### Rust: Configure rmp-serde Deserializer for Binary Output

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=

Demonstrates converting a `Deserializer` to use the standard binary MessagePack representation. This is the default and most compact format for MessagePack data, offering optimal performance.

```Rust
use rmp_serde::Deserializer;

// Assuming 'deserializer' is an existing Deserializer instance
// let binary_deserializer = deserializer.with_binary();

```

--------------------------------

### Rust: Consume rmp-serde Deserializer to Get Inner Reader

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=

Shows how to consume a `Deserializer` instance and retrieve the underlying reader. This operation transfers ownership of the reader from the deserializer, effectively taking it back for further use.

```Rust
use rmp_serde::Deserializer;

// Assuming 'deserializer' is a Deserializer instance
// let reader = deserializer.into_inner();

```

--------------------------------

### Trait Implementations for DefaultConfig

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.DefaultConfig

Documentation for various trait implementations available for the DefaultConfig struct.

```APIDOC
## Trait Implementations for DefaultConfig

### `Clone` Trait
- `clone(&self) -> DefaultConfig`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.

### `Debug` Trait
- `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the value using the given formatter.

### `Copy` Trait
(This trait is implemented for DefaultConfig, indicating it can be copied by simply copying its bits.)

### Auto Trait Implementations
- `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, `UnwindSafe`
  (These indicate thread safety and memory safety properties.)

### Blanket Implementations (Generic)
- `Any` for `T` where `T: 'static + ?Sized`
  - `type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.
- `Borrow<T>` for `T` where `T: ?Sized`
  - `borrow(&self) -> &T`: Immutably borrows from an owned value.
- `BorrowMut<T>` for `T` where `T: ?Sized`
  - `borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.
- `CloneToUninit` for `T` where `T: Clone` (Nightly-only experimental API)
  - `clone_to_uninit(&self, dest: *mut u8)`: Performs copy-assignment from `self` to `dest`.
- `From<T>` for `T`
  - `from(t: T) -> T`: Returns the argument unchanged.
- `Into<U>` for `T` where `U: From<T>`
  - `into(self) -> U`: Calls `U::from(self)`.
- `ToOwned` for `T` where `T: Clone`
  - `Owned = T`: The resulting type after obtaining ownership.
  - `to_owned(&self) -> T`: Creates owned data from borrowed data, usually by cloning.
  - `clone_into(&self, target: &mut T)`: Uses borrowed data to replace owned data, usually by cloning.
- `TryFrom<U>` for `T` where `U: Into<T>`
  - `Error = Infallible`: The type returned in the event of a conversion error.
  - `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.
- `TryInto<U>` for `T` where `U: TryFrom<T>`
  - `Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.
  - `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
- `SerializerConfig` for `T` where `T: SerializerConfig`
  (This indicates that types implementing `SerializerConfig` can be used in contexts expecting it.)
```

--------------------------------

### Serialize Struct - Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtFieldSerializer_search=u32+-%3E+bool

Starts the serialization of a struct with named fields (e.g., `struct Rgb { r: u8, g: u8, b: u8 }`). Each field must be serialized using `serialize_field`, followed by `end`.

```rust
fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Error>
```

--------------------------------

### Implement Clone for HumanReadableConfig

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.HumanReadableConfig

This snippet shows the implementation of the `Clone` trait for `HumanReadableConfig`. It allows for creating copies of the configuration wrapper. The `clone_from` method is also provided for efficient copying.

```rust
impl<C: Clone> Clone for HumanReadableConfig<C> {
    fn clone(&self) -> HumanReadableConfig<C>;
    fn clone_from(&mut self, source: &Self);
}
```

--------------------------------

### Serialize Struct - Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.ExtFieldSerializer_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the serialization of a struct with named fields (e.g., `struct Rgb { r: u8, g: u8, b: u8 }`). The serialization proceeds by calling `serialize_field` for each field, concluding with `end`.

```rust
fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Error>
```

--------------------------------

### UnderlyingWrite Trait - Required Methods - Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/trait.UnderlyingWrite_search=

Details the required methods for the UnderlyingWrite trait: `get_ref` to get a reference to the writer, `get_mut` for a mutable reference (with a warning against direct use), and `into_inner` to consume the structure and return the writer.

```rust
fn get_ref(&self) -> &Self::Write;
fn get_mut(&mut self) -> &mut Self::Write;
fn into_inner(self) -> Self::Write;
```

--------------------------------

### Rust: BinaryConfig Auto Trait Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.BinaryConfig

Lists the auto-trait implementations for BinaryConfig, which are derived based on the properties of the inner configuration type C. These include traits like Send, Sync, Unpin, Freeze, RefUnwindSafe, and UnwindSafe.

```rust
impl<C> Freeze for BinaryConfig<C> where C: Freeze

impl<C> RefUnwindSafe for BinaryConfig<C> where C: RefUnwindSafe

impl<C> Send for BinaryConfig<C> where C: Send

impl<C> Sync for BinaryConfig<C> where C: Sync

impl<C> Unpin for BinaryConfig<C> where C: Unpin

impl<C> UnwindSafe for BinaryConfig<C> where C: UnwindSafe

```

--------------------------------

### Deserializer Blanket Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates blanket implementations for the Deserializer struct with common Rust traits.

```APIDOC
## Deserializer Blanket Implementations

### `impl<R, C> Unpin for Deserializer<R, C>`

This implementation indicates that `Deserializer` is `Unpin` if its underlying reader `R` and configuration `C` are also `Unpin`.

### `impl<R, C> UnwindSafe for Deserializer<R, C>`

This implementation indicates that `Deserializer` is `UnwindSafe` if its underlying reader `R` and configuration `C` are also `UnwindSafe`.

### Method
`Unpin`, `UnwindSafe`

### Endpoint
N/A (Rust trait implementation)

### Parameters
None

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Rust: Get Current Position of rmp-serde Deserializer

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer_search=

Demonstrates retrieving the current byte position (number of bytes read) from a `Deserializer` that wraps a `Cursor`. This is useful for tracking progress or understanding how much data has been processed.

```Rust
use rmp_serde::Deserializer;

// Assuming 'deserializer' is a Deserializer instance wrapping a Cursor
// let current_position = deserializer.position();

```

--------------------------------

### Deserializer Trait Implementations

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/struct.Deserializer

Demonstrates the implementation of the `Deserializer` trait, which defines the core deserialization behavior, including handling various data types and visitor patterns.

```rust
type Error = Error

Determine whether `Deserialize` implementations should expect to deserialize their human-readable form. Read more
fn is_human_readable(&self) -> bool

Require the `Deserializer` to figure out how to drive the visitor based on what data type is in the input. Read more
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an optional value. Read more
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an enum value with a particular name and possible variants.
fn deserialize_enum<V>( self, _name: &str, _variants: &[&str], visitor: V, ) -> Result<V::Value, Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a newtype struct with a particular name.
fn deserialize_newtype_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit struct with a particular name.
fn deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i128` value. Read more
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `u128` value. Read more
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a sequence of values.
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: Visitor<'de>,
```

--------------------------------

### rmp_serde::decode::from_slice

Source: https://docs.rs/rmp-serde/latest/rmp_serde/decode/fn.from_slice_search=

Deserializes a temporary scope-bound instance of type `T` from a slice, with zero-copy if possible. Deserialization will be performed in a zero-copy manner whenever possible, borrowing the data from the slice itself. For example, strings and byte-arrays won’t be copied.

```APIDOC
## POST /rmp_serde/decode/from_slice

### Description
Deserializes a temporary scope-bound instance of type `T` from a slice, with zero-copy if possible. Deserialization will be performed in a zero-copy manner whenever it is possible, borrowing the data from the slice itself. For example, strings and byte-arrays won’t copied.

### Method
POST

### Endpoint
/rmp_serde/decode/from_slice

### Parameters
#### Request Body
- **input** (bytes) - Required - The byte slice to deserialize from.
- **T** (generic type) - Required - The type to deserialize into, must implement `Deserialize<'a>`.

### Request Example
```json
{
  "input": "[byte data]",
  "T": "TargetType"
}
```

### Response
#### Success Response (200)
- **Deserialized Data** (T) - The deserialized data of type `T`.

#### Response Example
```json
{
  "example": "[Deserialized Data]"
}
```

### Errors
This conversion can fail if the structure of the Value does not match the structure expected by `T`. It can also fail if the structure is correct but `T`’s implementation of `Deserialize` decides that something is wrong with the data, for example required struct fields are missing.
```

--------------------------------

### Implement Clone for HumanReadableConfig in Rust

Source: https://docs.rs/rmp-serde/latest/rmp_serde/config/struct.HumanReadableConfig_search=

Demonstrates the implementation of the Clone trait for HumanReadableConfig when the inner configuration type C also implements Clone. It includes the clone and clone_from methods.

```rust
fn clone(&self) -> HumanReadableConfig<C>;
fn clone_from(&mut self, source: &Self);

```

--------------------------------

### Implement UnderlyingWrite Trait for Serializer in Rust

Source: https://docs.rs/rmp-serde/latest/src/rmp_serde/encode.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This trait defines methods for accessing the underlying writer of a MessagePack serializer. It allows retrieving immutable or mutable references to the writer and consuming the serializer to get ownership of the writer.

```rust
/// Obtain the underlying writer.
pub trait UnderlyingWrite {
    /// Underlying writer type.
    type Write: Write;

    /// Gets a reference to the underlying writer.
    fn get_ref(&self) -> &Self::Write;

    /// Gets a mutable reference to the underlying writer.
    ///
    /// It is inadvisable to directly write to the underlying writer.
    fn get_mut(&mut self) -> &mut Self::Write;

    /// Unwraps this `Serializer`, returning the underlying writer.
    fn into_inner(self) -> Self::Write;
}
```

--------------------------------

### Get mutable reference to underlying writer

Source: https://docs.rs/rmp-serde/latest/rmp_serde/encode/struct.Serializer_search=

Provides mutable access to the underlying writer (`W`) within the `Serializer`. This allows for modifying the writer's state or directly writing to it. The `UnderlyingWrite` trait signifies that the serializer encapsulates a writer.

```rust
fn get_mut(&mut self) -> &mut Self::Write
```
Tokens:
Raw