Cml Core

https://docs.rs/cml-core/6.2.0/
Admin
Cml Core is a Rust crate offering fundamental data structures, serialization, and core components...
Tokens:16,916
Snippets:130
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### LinkedHashMap: Get Front Entry (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Shows how to get the first entry (key-value pair) from a LinkedHashMap using the `front()` method in Rust. This is useful for accessing the oldest inserted element without removing it.

```Rust
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();
map.insert(1, 10);
map.insert(2, 20);
assert_eq!(map.front(), Some((&1, &10)));
```

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

### Rust: OrderedHashMap Get and Refresh Entry

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

The `get_refresh` method retrieves a mutable reference to a value and moves its entry to the end of the insertion order, useful for LRU cache implementations.

```Rust
pub fn get_refresh<Q>(&mut self, k: &Q) -> Option<&mut V>
where K: Borrow<Q>, Q: Eq + Hash + ?Sized,
Returns the value corresponding to the key in the map.
If value is found, it is moved to the end of the list. This operation can be used in implemenation of LRU cache.
##### §Examples
```
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();

map.insert(1, "a");
map.insert(2, "b");
map.insert(3, "d");

assert_eq!(map.get_refresh(&2), Some(&mut "b"));

assert_eq!((&2, &"b"), map.iter().rev().next().unwrap());
```
```

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

### LinkedHashMap: Get Back Entry (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Demonstrates retrieving the last entry (key-value pair) from a LinkedHashMap using the `back()` method in Rust. This allows inspection of the most recently inserted element.

```Rust
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();
map.insert(1, 10);
map.insert(2, 20);
assert_eq!(map.back(), Some((&2, &20)));
```

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

### Rust: OrderedHashMap Entry Manipulation

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Allows in-place manipulation of map entries using the `entry` method. It returns an `Entry` enum which can be used to get or insert values.

```Rust
pub fn entry(&mut self, k: K) -> Entry<'_, K, V, S>
Gets the given key’s corresponding entry in the map for in-place manipulation.
```

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

### Rust: Insert and Retrieve Key-Value Pairs in OrderedHashMap

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Methods for inserting and retrieving values associated with keys in an OrderedHashMap. `insert` adds or updates a key-value pair, returning the old value if it existed. `get` retrieves a reference to the value, while `get_mut` provides mutable access.

```Rust
pub fn insert(&mut self, k: K, v: V) -> Option<V>
Inserts a key-value pair into the map. If the key already existed, the old value is returned.
##### §Examples
```
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();

map.insert(1, "a");
map.insert(2, "b");
assert_eq!(map[&1], "a");
assert_eq!(map[&2], "b");
```
```

```Rust
pub fn get<Q>(&self, k: &Q) -> Option<&V>
where K: Borrow<Q>, Q: Eq + Hash + ?Sized,
Returns the value corresponding to the key in the map.
##### §Examples
```
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();

map.insert(1, "a");
map.insert(2, "b");
map.insert(2, "c");
map.insert(3, "d");

assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), Some(&"c"));
```
```

```Rust
pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
where K: Borrow<Q>, Q: Eq + Hash + ?Sized,
Returns the mutable reference corresponding to the key in the map.
##### §Examples
```
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();

map.insert(1, "a");
map.insert(2, "b");

*map.get_mut(&1).unwrap() = "c";
assert_eq!(map.get(&1), Some(&"c"));
```
```

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

### Get Maximum Value for CBOR Sz Type in Rust

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

The `sz_max` function calculates the maximum value that can be represented by a given `cbor_event::Sz` type. This is essential for determining if a given length fits within a specific encoding size, aiding in efficient CBOR serialization. It handles `Sz::Inline`, `Sz::One`, `Sz::Two`, `Sz::Four`, and `Sz::Eight`.

```rust
#[inline]
pub fn sz_max(sz: cbor_event::Sz) -> u64 {
    match sz {
        Sz::Inline => 23u64,
        Sz::One => u8::MAX as u64,
        Sz::Two => u16::MAX as u64,
        Sz::Four => u32::MAX as u64,
        Sz::Eight => u64::MAX,
    }
}
```

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

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/cml-core/6.2.0/help

This snippet lists keyboard shortcuts for navigating the rustdoc documentation interface. These shortcuts provide quick access to help, search, and result navigation.

```text
`?`
    Show this help dialog

`S` / `/`
    Focus the search field

`↑`
    Move up in search results

`↓`
    Move down in search results

`←` / `→`
    Switch result tab (when results focused)

`⏎`
    Go to active search result

`+`
    Expand all sections

`-`
    Collapse all sections

`_`
    Collapse all sections, including impl blocks
```

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

### Rustdoc Search Tricks and Syntax

Source: https://docs.rs/cml-core/6.2.0/help

This snippet outlines advanced search features in rustdoc. It explains how to refine searches by item kind, type signature, exact naming, and item paths for more precise results.

```text
Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given item kind.
Accepted kinds are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.
Search functions by type signature (e.g., `vec -> usize` or `-> vec` or `String, enum:Cow -> bool`)
You can look for items with an exact name by putting double quotes around your request: `"string"`
Look for functions that accept or return slices and arrays by writing square brackets (e.g., `-> [u8]` or `[] -> Option`)
Look for items inside another one by searching for a path: `vec::Vec`
```

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

### Clone and Default for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Implements the `Clone` and `Default` traits for `ProtocolMagic`. `Clone` allows for creating copies of `ProtocolMagic` instances, while `Default` provides a standard way to create a default instance, often the zero value.

```rust
fn clone(&self) -> ProtocolMagic
fn clone_from(&mut self, source: &Self)
fn default() -> Self
```

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

### Rust Generic CloneToUninit Implementation (Nightly)

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Provides an experimental nightly-only implementation of `CloneToUninit` for types that implement `Clone`. It allows cloning a value into uninitialized memory.

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

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

### From Conversions for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Provides implementations for converting between `ProtocolMagic` and `u32`. This allows for seamless integration with other parts of the code that use `u32` values, simplifying the creation and usage of `ProtocolMagic` instances.

```rust
fn from(val: ProtocolMagic) -> Self
fn from(inner: u32) -> Self
```

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

### Implement Generic Conversion Traits in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/struct

Demonstrates blanket implementations of common generic conversion traits such as `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`. These implementations enable flexible type conversions and interoperability.

```rust
impl<T> Any for T where T: 'static + ?Sized
	fn type_id(&self) -> TypeId
```

```rust
impl<T> Borrow<T> for T where T: ?Sized
	fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T where T: ?Sized
	fn borrow_mut(&mut self) -> &mut T
```

```rust
impl<T> From<T> for T
	fn from(t: T) -> T
```

```rust
impl<T, U> Into<U> for T where U: From<T>
	fn into(self) -> U
```

```rust
impl<T, U> TryFrom<U> for T where U: Into<T>
	type Error = Infallible
	fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
impl<T, U> TryInto<U> for T where U: TryFrom<T>
	type Error = <U as TryFrom<T>>::Error
	fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Rust: Implement Error::provide for DeserializeError (Nightly-only)

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Implements the experimental `provide` method from the `Error` trait for `DeserializeError`. This is a nightly-only API intended for providing type-based access to error context, typically used in error reporting frameworks.

```rust
fn provide<'a>(&'a self, request: &mut Request<'a>)
```

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

### Implement CBORReadLen Methods in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/struct

Provides implementations for key methods of the CBORReadLen struct, including creating a new instance, reading length, reading elements, and finishing the read operation. Error handling for deserialization is included.

```rust
pub fn new(len: LenSz) -> Self
```

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

```rust
pub fn read_elems(&mut self, count: usize) -> Result<(), DeserializeFailure>
```

```rust
pub fn finish(&self) -> Result<(), DeserializeFailure>
```

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

### Rust StringEncoding From<StringLenSz> Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Provides a conversion from `StringLenSz` into `StringEncoding`. The `from` function takes a `StringLenSz` and constructs the appropriate `StringEncoding` variant.

```rust
fn from(len_sz: StringLenSz) -> Self
```

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

### Comparison Traits for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Implements comparison traits (`PartialOrd`, `Ord`, `PartialEq`) for `ProtocolMagic`. This allows instances of `ProtocolMagic` to be compared using standard operators like `<`, `>`, `==`, and `!=`, facilitating sorting and conditional logic.

```rust
fn cmp(&self, other: &ProtocolMagic) -> Ordering
fn partial_cmp(&self, other: &ProtocolMagic) -> Option<Ordering>
fn eq(&self, other: &ProtocolMagic) -> bool
fn ne(&self, other: &Rhs) -> bool
```

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

### Rust Generic TryFrom<U> Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Provides a blanket implementation of `TryFrom<U>` for `T` where `U` implements `Into<T>`. This allows attempting a conversion from `U` to `T` that might fail, returning a `Result`.

```rust
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Hashing Implementation for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Provides a `Hash` implementation for `ProtocolMagic`, enabling its use in hash-based data structures like `HashMap` and `HashSet`. This is essential for efficient lookups and data organization.

```rust
fn hash<__H: Hasher>(&self, state: &mut __H)
fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,
```

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

### StringEncoding Trait Implementations

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Details on various trait implementations for the StringEncoding enum, including Clone, Debug, Default, PartialEq, Eq, and others, defining its behavior and interoperability.

```APIDOC
## Trait Implementations for StringEncoding

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

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

### impl Default for StringEncoding
*   `default() -> Self`: Returns the default value for the type.

### impl From<StringLenSz> for StringEncoding
*   `from(len_sz: StringLenSz) -> Self`: Converts to `StringEncoding` from `StringLenSz`.

### impl PartialEq for StringEncoding
*   `eq(&self, other: &StringEncoding) -> bool`: Tests for equality between two `StringEncoding` values.
*   `ne(&self, other: &Rhs) -> bool`: Tests for inequality.

### impl Eq for StringEncoding
(Indicates that equality is reflexive, symmetric, and transitive.)

### impl StructuralPartialEq for StringEncoding
(Indicates that partial equality is structurally implemented.)

### Auto Trait Implementations
Includes `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, `UnwindSafe`.

### Blanket Implementations
Includes implementations for generic traits like `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `DynClone`, `From<T>`, `Into<U>`, `ToOwned`, `TryFrom<U>`, and `TryInto<U>`.
```

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

### Implement Display for Key Enum in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code demonstrates the implementation of the `Display` trait for the `Key` enum. This enables the `Key` enum to be formatted as a user-friendly string, typically used for outputting information to the console or logs. It includes the `fmt` method signature.

```rust
impl Display for Key {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

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

### Rust: Test Int::from_cbor_bytes for Unsigned Integers

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

These tests verify the serialization and deserialization of `Int::Uint` from CBOR byte representations. They cover the minimum unsigned integer (0) and the maximum representable unsigned integer (u64::MAX), asserting that the conversion to `i128` and back to bytes is consistent.

```rust
    #[test]
    fn int_uint_min() {
        let bytes = [0x00];
        let x = Int::from_cbor_bytes(&bytes).unwrap();
        assert_eq!(bytes, x.to_cbor_bytes().as_slice());
        assert_eq!(Into::<i128>::into(&x), u64::MIN as i128);
        assert_eq!(x.to_string(), "0");
    }

    #[test]
    fn int_uint_max() {
        let bytes = [0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
        let x = Int::from_cbor_bytes(&bytes).unwrap();
        assert_eq!(bytes, x.to_cbor_bytes().as_slice());
        assert_eq!(Into::<i128>::into(&x), u64::MAX as i128);
        assert_eq!(x.to_string(), "18446744073709551615");
    }
```

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

### Rust Generic Any Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Shows the blanket implementation of the `Any` trait for any type `T`. This allows runtime type identification.

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

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

### JsonSchema Implementation for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Implements `JsonSchema` for `ProtocolMagic`, enabling automatic generation of JSON schemas. This is valuable for API documentation and interoperability with systems that rely on schema validation.

```rust
fn schema_name() -> String
fn schema_id() -> Cow<'static, str>
fn json_schema(generator: &mut SchemaGenerator) -> Schema
fn is_referenceable() -> bool
```

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

### Rust StringEncoding PartialEq Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Implements the `PartialEq` trait for StringEncoding, allowing comparison of two `StringEncoding` values for equality using `eq()` and inequality using `ne()`.

```rust
fn eq(&self, other: &StringEncoding) -> bool
fn ne(&self, other: &Rhs) -> bool
```

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

### Rust: Implement TryFrom<i128> for Int

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

This implementation provides a fallible conversion from `i128` to `Int`. It uses `u64::try_from` to safely convert the absolute values, returning a `TryFromIntError` if the `i128` value is out of the representable range for `u64` after adjustment for negative integers.

```rust
impl std::convert::TryFrom<i128> for Int {
    type Error = std::num::TryFromIntError;

    fn try_from(x: i128) -> Result<Self, Self::Error> {
        if x >= 0 {
            u64::try_from(x).map(|x| Self::Uint {
                value: x,
                encoding: None,
            })
        } else {
            u64::try_from((x + 1).abs()).map(|x| Self::Nint {
                value: x,
                encoding: None,
            })
        }
    }
}
```

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

### Rust: Implement DeserializeError::new Constructor

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Provides a constructor function `new` for `DeserializeError`. This function allows creating an instance of `DeserializeError` by taking a location (which can be any type convertible into a String) and a `DeserializeFailure` enum variant. This is the primary way to instantiate this error type with specific failure information.

```rust
pub fn new<T: Into<String>>(location: T, failure: DeserializeFailure) -> Self
```

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

### Rust: Implement From<i64> for Int

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

This implementation allows converting an `i64` value into an `Int` enum. Positive `i64` values are mapped to `Int::Uint`, while negative values are mapped to `Int::Nint` with appropriate adjustments for the negative integer representation in CBOR.

```rust
impl From<i64> for Int {
    fn from(x: i64) -> Self {
        if x >= 0 {
            Self::Uint {
                value: x as u64,
                encoding: None,
            }
        } else {
            Self::Nint {
                value: (x + 1).unsigned_abs(),
                encoding: None,
            }
        }
    }
}
```

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

### Rust StringEncoding Debug Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Implements the `Debug` trait for StringEncoding, enabling formatted output for debugging purposes. The `fmt` method is used to write the enum's representation to a formatter.

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

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

### Serialization and Deserialization for ProtocolMagic (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Implements `Deserialize` and `Serialize` traits for `ProtocolMagic` using the `serde` crate. This enables the struct to be easily converted to and from various data formats like CBOR and JSON, crucial for data persistence and network communication.

```rust
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>

fn deserialize<R: BufRead>( raw: &mut Deserializer<R>, ) -> Result<Self, DeserializeError>

fn from_cbor_bytes(data: &[u8]) -> Result<Self, DeserializeError>
where Self: Sized,
```

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

### Hash, Serialize, Deserialize, and JsonSchema for OrderedHashMap in Rust

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/ordered_hash_map

Implements Hash, serde::Serialize, serde::de::Deserialize, and schemars::JsonSchema for OrderedHashMap. These traits enable hashing, serialization/deserialization via serde, and schema generation for JSON.

```Rust
#[allow(clippy::derived_hash_with_manual_eq)]
impl<K, V> Hash for OrderedHashMap<K, V>
where
    K: Hash + Eq + Ord,
    V: Hash,
{
    fn hash<H: Hasher>(&self, h: &mut H) {
        self.0.hash(h);
    }
}

impl<K, V> serde::Serialize for OrderedHashMap<K, V>
where
    K: Hash + Eq + Ord + serde::Serialize,
    V: serde::Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let map = self.iter().collect::<std::collections::BTreeMap<_, _>>();
        map.serialize(serializer)
    }
}

impl<'de, K, V> serde::de::Deserialize<'de> for OrderedHashMap<K, V>
where
    K: Hash + Eq + Ord + serde::Deserialize<'de>,
    V: serde::Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::de::Deserializer<'de>,
    {
        let map = <std::collections::BTreeMap<_, _> as serde::de::Deserialize>::deserialize(
            deserializer,
        )?;
        Ok(Self(map.into_iter().collect()))
    }
}

impl<K, V> schemars::JsonSchema for OrderedHashMap<K, V>
where
    K: Hash + Eq + Ord + schemars::JsonSchema,
    V: schemars::JsonSchema,
{
    fn schema_name() -> String {
        format!("OrderedHashMap<{}, {}>", K::schema_name(), V::schema_name())
    }
    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
        std::collections::BTreeMap::<K, V>::json_schema(gen)
    }
    fn is_referenceable() -> bool {
        std::collections::BTreeMap::<K, V>::is_referenceable()
    }
}
```

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

### Rust: Implement Error::source for DeserializeError

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Implements the `source` method from the `Error` trait for `DeserializeError`. This method returns an `Option` containing a reference to the underlying error that caused this `DeserializeError`, if any. This is crucial for error chaining and debugging.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

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

### Rust: Implement Serialize for Int

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

This implementation enables serializing the `Int` enum into CBOR format using a `Serializer`. It distinguishes between `Int::Uint` and `Int::Nint`, writing them to the serializer with appropriate CBOR tags and sizes determined by `fit_sz`.

```rust
impl Serialize for Int {
    fn serialize<'se, W: Write>(
        &self,
        serializer: &'se mut Serializer<W>,
        force_canonical: bool,
    ) -> cbor_event::Result<&'se mut Serializer<W>> {
        match self {
            Self::Uint { value, encoding } => serializer
                .write_unsigned_integer_sz(*value, fit_sz(*value, *encoding, force_canonical)),
            Self::Nint { value, encoding } => serializer.write_negative_integer_sz(
                -( (*value as i128) + 1),
                fit_sz(*value, *encoding, force_canonical),
            ),
        }
    }
}
```

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

### Rust: Implement Display for DeserializeError

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Implements the `Display` trait for `DeserializeError`. This allows the error to be formatted into a human-readable string using the `fmt` method, typically used for user-facing error messages or logging.

```rust
impl Display for DeserializeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

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

### Implement TryInto<U> for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code snippet illustrates a blanket implementation of the `TryInto<U>` trait for type `T`, provided `U` implements `TryFrom<T>`. This enables fallible conversions from `T` to `U`, returning a `Result` to manage potential conversion failures. It defines the `try_into` method and its associated `Error` type.

```rust
impl<T, U>
TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

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

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

### Rust: Implement Error::description for DeserializeError (Deprecated)

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Provides the `description` method as part of the `Error` trait implementation for `DeserializeError`. This method is deprecated since Rust 1.42.0 and users are advised to use the `Display` implementation or `to_string()` instead.

```rust
fn description(&self) -> &str
```

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

### Implement Generic Traits for CBORReadLen in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/struct

Shows blanket implementations of standard Rust traits like `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, and `UnwindSafe` for the `CBORReadLen` struct, indicating its safety and compatibility with various Rust features.

```rust
impl Freeze for CBORReadLen
```

```rust
impl RefUnwindSafe for CBORReadLen
```

```rust
impl Send for CBORReadLen
```

```rust
impl Sync for CBORReadLen
```

```rust
impl Unpin for CBORReadLen
```

```rust
impl UnwindSafe for CBORReadLen
```

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

### StringEncoding Implementations

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Documentation for the `to_str_len_sz` method implemented for the StringEncoding enum, used for converting string length information.

```APIDOC
## impl StringEncoding

### pub fn to_str_len_sz(&self, len: u64, force_canonical: bool) -> StringLenSz

Converts the `StringEncoding` into a `StringLenSz` representation based on the provided length and a flag to force canonical encoding.
```

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

### Rust StringEncoding Eq Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Implements the `Eq` trait for StringEncoding, indicating that equality comparison is reflexive, symmetric, and transitive. This is a marker trait that builds upon `PartialEq`.

```rust

```

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

### Implement Display for DeserializeError in Rust

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/error

This snippet implements the `std::fmt::Display` trait for the `DeserializeError` enum. This allows `DeserializeError` to be formatted as a string, providing user-friendly error messages. It relies on an internal `fmt_indent` method for formatting.

```rust
impl std::fmt::Display for DeserializeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.fmt_indent(f, 0)
    }
}
```

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

### Implement From Trait for CBORReadLen in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/struct

Implements the `From<Len>` trait for `CBORReadLen`, allowing conversion from a `Len` type to a `CBORReadLen` instance. This simplifies the creation of `CBORReadLen` objects.

```rust
fn from(len: Len) -> Self
```

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

### Rust: Define Network Magic Constants and ProtocolMagic

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/network

Defines static network magic constants for different Cardano networks and implements the ProtocolMagic struct with various traits for serialization, deserialization, and display.

```rust
use crate::{error::DeserializeError, serialization::Deserialize};
use cbor_event::de::Deserializer;
use cbor_event::se::Serializer;
use schemars::JsonSchema;
use std::io::{BufRead, Write};

pub static BYRON_MAINNET_NETWORK_MAGIC: u32 = 764824073;
pub static BYRON_TESTNET_NETWORK_MAGIC: u32 = 1097911063;
pub static SANCHO_TESTNET_NETWORK_MAGIC: u32 = 4;
pub static PREPROD_NETWORK_MAGIC: u32 = 1;
pub static PREVIEW_NETWORK_MAGIC: u32 = 2;

impl std::fmt::Display for ProtocolMagic {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

#[derive(
    Clone,
    Copy,
    Debug,
    Eq,
    Ord,
    PartialEq,
    PartialOrd,
    Hash,
    serde::Serialize,
    serde::Deserialize,
    JsonSchema,
)]
pub struct ProtocolMagic(u32);

impl From<ProtocolMagic> for u32 {
    fn from(val: ProtocolMagic) -> Self {
        val.0
    }
}

impl From<u32> for ProtocolMagic {
    fn from(inner: u32) -> Self {
        ProtocolMagic(inner)
    }
}

impl ::std::ops::Deref for ProtocolMagic {
    type Target = u32;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl Default for ProtocolMagic {
    fn default() -> Self {
        Self(764824073)
    }
}

impl cbor_event::se::Serialize for ProtocolMagic {
    fn serialize<'se, W: Write>(
        &self,
        serializer: &'se mut Serializer<W>,
    ) -> cbor_event::Result<&'se mut Serializer<W>> {
        serializer.write_unsigned_integer(self.0 as u64)
    }
}

impl Deserialize for ProtocolMagic {
    fn deserialize<R: BufRead>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        Ok(Self(raw.unsigned_integer()? as u32))
    }
}
```

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

### Implement Debug for Key Enum in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code snippet shows the implementation of the `Debug` trait for the `Key` enum. This allows instances of the `Key` enum to be formatted for debugging purposes, making it easier to inspect their values during development. It defines the `fmt` method required by the `Debug` trait.

```rust
impl Debug for Key {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

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

### Implement From<T> for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code snippet illustrates the blanket implementation of the `From<T>` trait for any type `T`. This standard library feature allows for easy conversion into a type from itself, essentially returning the argument unchanged. It defines the `from` method.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T
}
```

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

### Rust Generic TryInto<U> Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Implements the `TryInto<U>` trait for any type `T` where `U` implements `TryFrom<T>`. This allows attempting to convert `T` into `U` which might fail, returning a `Result`.

```rust
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Rust Generic DynClone Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Implements the `DynClone` trait for types that implement `Clone`. This is used for dynamic cloning, typically with trait objects.

```rust
fn __clone_box(&self, _: Private) -> *mut ()
```

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

### Implement TryInto<U> for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/enum

This snippet shows the generic implementation of the `TryInto<U>` trait for a type `T` in Rust. It allows `T` to be converted into `U` with a possibility of failure, leveraging the `TryFrom<T>` implementation for `U`.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> {
        // ... implementation details ...
    }
}
```

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

### Rust CBOR Deserialization Interface

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

Defines the interface for deserializing data from CBOR format into Rust data structures. Includes a helper for deserializing directly from byte slices.

```rust
pub trait Deserialize {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError>
    where
        Self: Sized;

    /// from-bytes using the exact CBOR format specified in the CDDL binary spec.
    /// For hashes/addresses/etc this will include the CBOR bytes type/len/etc.
    fn from_cbor_bytes(data: &[u8]) -> Result<Self, DeserializeError>
    where
        Self: Sized,
    {
        let mut raw = Deserializer::from(std::io::Cursor::new(data));
        Self::deserialize(&mut raw)
    }
}

```

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

### Rust: OrderedHashMap Capacity Management

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Methods for managing the capacity of an OrderedHashMap. `reserve` ensures space for additional elements, while `shrink_to_fit` reduces capacity to the minimum required.

```Rust
pub fn reserve(&mut self, additional: usize)
Reserves capacity for at least `additional` more elements to be inserted into the map. The map may reserve more space to avoid frequent allocations.
##### §Panics
Panics if the new allocation size overflows `usize.`
```

```Rust
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.
```

```Rust
pub fn capacity(&self) -> usize
Returns the maximum number of key-value pairs the map can hold without reallocating.
##### §Examples
```
use linked_hash_map::LinkedHashMap;
let mut map: LinkedHashMap<i32, &str> = LinkedHashMap::new();
let capacity = map.capacity();
```
```

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

### Rust: Test Int::from_cbor_bytes for Negative Integers

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

These tests verify the serialization and deserialization of `Int::Nint` from CBOR byte representations. They cover the maximum negative integer (-18446744073709551616) and the minimum negative integer (-1), asserting byte consistency and correct conversion to `i128`.

```rust
    #[test]
    fn int_nint_min() {
        let bytes = [0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
        let x = Int::from_cbor_bytes(&bytes).unwrap();
        assert_eq!(bytes, x.to_cbor_bytes().as_slice());
        assert_eq!(Into::<i128>::into(&x), -((u64::MAX as i128) + 1));
        assert_eq!(x.to_string(), "-18446744073709551616");
    }

    #[test]
    fn int_nint_max() {
        let bytes = [0x20];
        let x = Int::from_cbor_bytes(&bytes).unwrap();
        assert_eq!(bytes, x.to_cbor_bytes().as_slice());
        assert_eq!(Into::<i128>::into(&x), -1i128);
        assert_eq!(x.to_string(), "-1");
        let y = Int::from(-1i64);
        assert_eq!(x.to_canonical_cbor_bytes(), y.to_canonical_cbor_bytes());
    }
```

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

### Implement ToString for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code demonstrates the blanket implementation of the `ToString` trait for any type `T` that also implements the `Display` trait. This provides a convenient way to convert displayable types into `String` objects. It includes the `to_string` method signature.

```rust
impl<T> ToString for T
where
    T: Display + ?Sized,
{
    fn to_string(&self) -> String
}
```

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

### Try Convert Value into Another Type

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

The `try_into` method attempts a conversion between types that may fail. It returns a `Result`, indicating success or the specific error encountered during conversion.

```rust
type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Rust: Implement DeserializeError::annotate Method

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Adds an `annotate` method to `DeserializeError`. This method allows chaining additional location information to an existing `DeserializeError` instance, returning a modified self. This can be useful for providing more context about where a deserialization error occurred.

```rust
pub fn annotate<T: Into<String>>(self, location: T) -> Self
```

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

### ProtocolMagic Constants (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Exposes constants associated with the `ProtocolMagic` struct, including the minimum value (MIN), maximum value (MAX), and the number of bits (BITS) it represents. These constants are derived from its underlying u32 type.

```rust
pub const MIN: u32 = 0u32;
pub const MAX: u32 = 4_294_967_295u32;
pub const BITS: u32 = 32u32;
```

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

### Serialize Value using Serde Serializer

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

Implement the `Serialize` trait to allow a value to be serialized into a given Serde serializer. This is a common pattern for data serialization in Rust.

```rust
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer
```

```rust
fn serialize<'se, W: Write>(
    &self,
    serializer: &'se mut Serializer<W>,
) -> Result<&'se mut Serializer<W>>
```

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

### Convert Value to String

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

The `to_string` method converts a value into a `String`. This requires the type to implement the `Display` trait.

```rust
fn to_string(&self) -> String
```

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

### Rust StringEncoding Clone Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Provides the `Clone` trait implementation for the StringEncoding enum. This allows creating a duplicate of an existing StringEncoding value using `clone()` or performing copy-assignment with `clone_from()`.

```rust
fn clone(&self) -> StringEncoding
fn clone_from(&mut self, source: &Self)
```

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

### LinkedHashMap: Insert, Remove Front, and Assertions (Rust)

Source: https://docs.rs/cml-core/6.2.0/cml_core/ordered_hash_map/struct

Demonstrates inserting elements into a LinkedHashMap, removing the front element, and asserting the state of the map using Rust. It utilizes the `linked_hash_map` crate.

```Rust
use linked_hash_map::LinkedHashMap;
let mut map = LinkedHashMap::new();
map.insert(1, 10);
map.insert(2, 20);
map.pop_front();
assert_eq!(map.get(&1), None);
assert_eq!(map.get(&2), Some(&20));
```

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

### Fit Sz for CBOR Encoding Size in Rust

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

The `fit_sz` function determines the appropriate `cbor_event::Sz` for a given length. It prioritizes using a provided `sz` if the length fits within its maximum value, otherwise, it falls back to `Sz::canonical` for the most efficient encoding. The `force_canonical` flag can be used to always use canonical encoding.

```rust
#[inline]
pub fn fit_sz(len: u64, sz: Option<cbor_event::Sz>, force_canonical: bool) -> Sz {
    match sz {
        Some(sz) => {
            if !force_canonical && len <= sz_max(sz) {
                sz
            } else {
                Sz::canonical(len)
            }
        }
        None => Sz::canonical(len),
    }
}
```

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

### Rust: Implement From<Error> for DeserializeError

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Implements the `From<Error>` trait for `DeserializeError`. This enables direct conversion of any type implementing the standard `Error` trait into a `DeserializeError`, facilitating error handling across different error types.

```rust
impl From<Error> for DeserializeError {
    fn from(err: Error) -> DeserializeError
}
```

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

### Rust: Implement Deserialize for Int

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

This implementation enables deserializing CBOR data into an `Int` enum. It reads from a `Deserializer`, checks the CBOR type, and then parses either an unsigned or negative integer, mapping them to `Int::Uint` or `Int::Nint` respectively. Errors are wrapped with context.

```rust
impl Deserialize for Int {
    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
        (|| -> Result<_, DeserializeError> {
            match raw.cbor_type()? {
                cbor_event::Type::UnsignedInteger => raw
                    .unsigned_integer_sz()
                    .map(|(x, enc)| Self::Uint {
                        value: x,
                        encoding: Some(enc),
                    })
                    .map_err(std::convert::Into::into),
                cbor_event::Type::NegativeInteger => raw
                    .negative_integer_sz()
                    .map(|(x, enc)| Self::Nint {
                        value: (-1 - x) as u64,
                        encoding: Some(enc),
                    })
                    .map_err(std::convert::Into::into),
                _ => Err(DeserializeFailure::NoVariantMatched.into()),
            }
        })()
        .map_err(|e| e.annotate("Int"))
    }
}
```

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

### Rust: Implement Raw Byte Serialization and Deserialization

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

This Rust code implements traits for converting data structures to and from raw byte slices. It includes methods for direct byte conversion and hexadecimal string representation, handling potential deserialization errors.

```Rust
trait RawBytesSerde {
    fn to_raw_bytes(&self) -> &[u8];

    fn from_raw_bytes(bytes: &[u8]) -> Result<Self, DeserializeError>
    where
        Self: Sized;

    fn to_raw_hex(&self) -> String {
        hex::encode(self.to_raw_bytes())
    }

    fn from_raw_hex(hex_str: &str) -> Result<Self, DeserializeError>
    where
        Self: Sized,
    {
        let bytes = hex::decode(hex_str).map_err(|e| {
            DeserializeError::from(DeserializeFailure::InvalidStructure(Box::new(e)))
        })?;
        Self::from_raw_bytes(bytes.as_ref())
    }
}
```

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

### Rust CBOR Serialization Interface

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

Defines the core interface for serializing data structures into CBOR format. Supports canonical encoding and conversion to byte vectors.

```rust
pub trait Serialize {
    fn serialize<'a, W: Write + Sized>(
        &self,
        serializer: &'a mut Serializer<W>,
        force_canonical: bool,
    ) -> cbor_event::Result<&'a mut Serializer<W>>;

    /// Bytes of a structure using the CBOR bytes as per the CDDL spec
    /// which for foo = bytes will include the CBOR bytes type/len, etc.
    /// This gives the original bytes in the case where this was created
    /// from bytes originally, or will use whatever the specific encoding
    /// details are present in any encoding details struct for the type.
    fn to_cbor_bytes(&self) -> Vec<u8> {
        let mut buf = Serializer::new_vec();
        self.serialize(&mut buf, false).unwrap();
        buf.finalize()
    }

    /// Bytes of a structure using the CBOR bytes as per the CDDL spec
    /// which for foo = bytes will include the CBOR bytes type/len, etc.
    /// This gives the canonically encoded CBOR bytes always
    fn to_canonical_cbor_bytes(&self) -> Vec<u8> {
        let mut buf = Serializer::new_vec();
        self.serialize(&mut buf, true).unwrap();
        buf.finalize()
    }
}

```

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

### Rust: Implement From<&Int> for i128

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/lib

This implementation converts an `Int` enum reference into an `i128`. It handles both `Int::Uint` by casting to `i128` and `Int::Nint` by converting the stored value and applying the negative offset.

```rust
impl From<&Int> for i128 {
    fn from(val: &Int) -> Self {
        match val {
            Int::Uint { value, .. } => (*value).into(),
            Int::Nint { value, .. } => -((*value as i128) + 1),
        }
    }
}
```

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

### Implement Into<U> for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code shows the blanket implementation of the `Into<U>` trait for type `T`, provided that `U` implements `From<T>`. This facilitates conversions between types by leveraging existing `From` implementations. It defines the `into` method.

```rust
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U
}
```

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

### StringEncoding Enum

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Details about the StringEncoding enum, its variants, and their purpose in serialization and string length representation.

```APIDOC
## Enum StringEncoding

### Summary
```rust
pub enum StringEncoding {
    Canonical,
    Indefinite(Vec<(u64, Sz)>),
    Definite(Sz),
}
```

### Variants

*   **Canonical**: Represents a canonical string encoding.
*   **Indefinite(Vec<(u64, Sz)>)**: Represents an indefinite string encoding with associated length and size information.
*   **Definite(Sz)**: Represents a definite string encoding with associated size information.
```

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

### Rust: Implement From<DeserializeFailure> for DeserializeError

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/struct

Provides an implementation for converting a `DeserializeFailure` enum into a `DeserializeError`. This allows for seamless conversion when a specific deserialization failure occurs, wrapping it within the more general `DeserializeError` type.

```rust
impl From<DeserializeFailure> for DeserializeError {
    fn from(failure: DeserializeFailure) -> DeserializeError
}
```

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

### Rust Trait for Converting to Bytes (Generic)

Source: https://docs.rs/cml-core/6.2.0/src/cml_core/serialization

A generic trait to convert any type implementing `cbor_event::se::Serialize` into a `Vec<u8>` using its default serialization.

```rust
// TODO: remove ToBytes / FromBytes after we regenerate the WASM wrappers.
// This is so the existing generated to/from bytes code works
// We are, however, using this in CIP25 as a way to get to bytes without
// caring about the encoding. We could move it to there or make it more explicit
// that this does not preserve encodings OR do canonical - it's just whatever
// CBOR format. All other parts of CML implement our own Serialize trait with
// the assumption that we preserve encodings. This is based off of cbor_event's
pub trait ToBytes {
    fn to_bytes(&self) -> Vec<u8>;
}

impl<T: cbor_event::se::Serialize> ToBytes for T {
    fn to_bytes(&self) -> Vec<u8> {
        let mut buf = Serializer::new_vec();
        self.serialize(&mut buf).unwrap();
        buf.finalize()
    }
}

```

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

### Create Owned Data from Borrowed Data

Source: https://docs.rs/cml-core/6.2.0/cml_core/network/struct

The `to_owned` method creates an owned version of the data from a borrowed reference, typically by cloning. The `Owned` associated type specifies the owned type.

```rust
type Owned = T;
fn to_owned(&self) -> T
```

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

### Implement TryFrom<U> for T in Rust

Source: https://docs.rs/cml-core/6.2.0/cml_core/error/enum

This Rust code shows a blanket implementation of the `TryFrom<U>` trait for type `T`, assuming `U` implements `Into<T>`. This allows for fallible conversions between types, returning a `Result` to handle potential errors. It defines the `try_from` method and its associated `Error` type.

```rust
impl<T, U>
TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible;

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

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

### Rust Generic From<T> Implementation

Source: https://docs.rs/cml-core/6.2.0/cml_core/serialization/enum

Shows the identity implementation of the `From<T>` trait for any type `T`. This means `T::from(value)` simply returns `value`.

```rust
fn from(t: T) -> T
```
Tokens:
Raw