Parity SCALE Codec

https://docs.rs/parity-scale-codec/
Admin
A Rust implementation of the SCALE (Simple Concatenated Aggregate Little-Endian) data format. It...
Tokens:609,076
Snippets:3,166
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Encode and MaxEncodedLen Example for Enums

Source: https://docs.rs/parity-scale-codec/3.7.5/src/parity_scale_codec/lib.rs_search=std%3A%3Avec

Illustrates deriving `Encode` and `MaxEncodedLen` for a generic enum. The `MaxEncodedLen` for an enum is the maximum of the encoded lengths of its variants. This example uses `u8` and `u128` to show generic application.

```rust
#[derive(Encode, MaxEncodedLen)]
enum GenericEnum<T> {
    A,
    B(T),
}

assert_eq!(GenericEnum::<u8>::max_encoded_len(), u8::max_encoded_len() + u8::max_encoded_len());
assert_eq!(GenericEnum::<u128>::max_encoded_len(), u8::max_encoded_len() + u128::max_encoded_len());
```

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

### Blanket Implementation: CloneToUninit for T

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.OptionBool_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Presents the experimental blanket implementation of 'CloneToUninit' for types 'T' that implement 'Clone'. This is a nightly-only API for copying data into uninitialized memory.

```rust
impl<T> CloneToUninit for T where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8);
}

```

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

### Implement TryInto for MemTrackingInput in Rust

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.MemTrackingInput_search=

Showcases the blanket implementation of 'TryInto<U>' for 'T' where 'U' implements 'TryFrom<T>'. This facilitates generic fallible conversions.

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

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

### Example Usage of Ref Struct in Rust

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.Ref_search=std%3A%3Avec

This example demonstrates how to use the `Ref` struct in a generic function. It shows storing a reference to `t` using `Ref::from(&t)` without moving the original value.

```rust
fn foo<T: EncodeLike<u8>>(t: T) -> T {
    store_t(Ref::from(&t)); // Store t without moving it, but only using a reference.
    t
}

fn store_t<T: EncodeLike<u8>>(t: T) {
}

```

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

### TryFrom and TryInto Implementations

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.OptionBool_search=std%3A%3Avec

Enables type conversions that may fail, providing `try_from` and `try_into` methods with associated error types.

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

### Description
Provides a fallible conversion from type `U` into type `T`.

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

### Endpoint
N/A (This is a Rust trait implementation, not a web endpoint)

### Parameters
- **value** (`U`) - The value to convert.

### Request Example
N/A

### Response
#### Success Response (Result Ok)
- **T** - The successfully converted value of type `T`.

#### Error Response (Result Err)
- **Error** (`<T as TryFrom<U>>::Error`) - The error type indicating conversion failure.

### Response Example
N/A
```

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

### Description
Provides a fallible conversion from type `T` into type `U`.

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

### Endpoint
N/A (This is a Rust trait implementation, not a web endpoint)

### Parameters
- **self** (`T`) - The value to convert.

### Request Example
N/A

### Response
#### Success Response (Result Ok)
- **U** - The successfully converted value of type `U`.

#### Error Response (Result Err)
- **Error** (`<U as TryFrom<T>>::Error`) - The error type indicating conversion failure.

### Response Example
N/A
```

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

### Encode and Decode Implementation for RangeInclusive<T> (Rust)

Source: https://docs.rs/parity-scale-codec/3.7.5/src/parity_scale_codec/codec.rs_search=std%3A%3Avec

Implements `Encode` and `Decode` for `RangeInclusive<T>`, where `T` must implement `Encode`. Encoding serializes the start and end bounds. Decoding reconstructs the `RangeInclusive` from its encoded start and end bounds.

```rust
impl<T> Encode for RangeInclusive<T>
		where
			T: Encode,
		{
			fn size_hint(&self) -> usize {
				2 * mem::size_of::<T>()
			}

			fn encode(&self) -> Vec<u8> {
				(self.start(), self.end()).encode()
			}
		}

		impl<T> Decode for RangeInclusive<T>
		where
			T: Decode,
		{
			fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
				let (start, end) = 
					<(T, T)>::decode(input).map_err(|e| e.chain("Could not decode `RangeInclusive<T>`"))?;
				Ok(RangeInclusive::new(start, end))
			}
		}

		impl<T: DecodeWithMemTracking> DecodeWithMemTracking for RangeInclusive<T> {}
```

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

### Generic Implementations for Any Type (Rust)

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.OptionBool_search=std%3A%3Avec

Demonstrates blanket implementations of common traits like Any, Borrow, BorrowMut, From, Into, and CloneToUninit for generic types that meet certain criteria. These are often provided by libraries to extend functionality.

```rust
impl<T> Any for T where T: 'static + ?Sized { fn type_id(&self) -> TypeId; }
impl<T> Borrow<T> for T where T: ?Sized { fn borrow(&self) -> &T; }
impl<T> BorrowMut<T> for T where T: ?Sized { fn borrow_mut(&mut self) -> &mut T; }
impl<T> CloneToUninit for T where T: Clone { unsafe fn clone_to_uninit(&self, dest: *mut u8); }
impl<T> From<T> for T { fn from(t: T) -> T; }
impl<T, U> Into<U> for T where U: From<T> { fn into(self) -> U; }
```

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

### Encode and Decode Implementation for Range<T> (Rust)

Source: https://docs.rs/parity-scale-codec/3.7.5/src/parity_scale_codec/codec.rs_search=std%3A%3Avec

Implements `Encode` and `Decode` for `Range<T>`, where `T` must implement `Encode`. Encoding serializes the start and end bounds of the range. Decoding reconstructs the `Range` from its encoded start and end bounds.

```rust
impl<T> Encode for Range<T>
		where
			T: Encode,
		{
			fn size_hint(&self) -> usize {
				2 * mem::size_of::<T>()
			}

			fn encode(&self) -> Vec<u8> {
				(&self.start, &self.end).encode()
			}
		}

		impl<T> Decode for Range<T>
		where
			T: Decode,
		{
			fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
				let (start, end) = 
					<(T, T)>::decode(input).map_err(|e| e.chain("Could not decode `Range<T>`"))?;
				Ok(Range { start, end })
			}
		}

		impl<T: DecodeWithMemTracking> DecodeWithMemTracking for Range<T> {}
```

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

### Blanket Implementations

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.Compact_search=

Provides information on various blanket implementations, including `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `DecodeAll`, `DecodeLimit`, `DecodeWithMemLimit`, `From<!>`, `From<T>`, `Into<U>`, `KeyedVec`, `ToOwned`, `TryFrom<U>`, and `TryInto<U>`.

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

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

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

### impl<T> CloneToUninit for T
where T: Clone,
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

### impl<T> DecodeAll for T
where T: Decode,
#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

### impl<T> DecodeLimit for T
where T: Decode,
#### fn decode_all_with_depth_limit( limit: u32, input: &mut &[u8], ) -> Result<T, Error>
#### fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where I: Input,

### impl<T> DecodeWithMemLimit for T
where T: DecodeWithMemTracking,
#### fn decode_with_mem_limit<I>(input: &mut I, mem_limit: usize) -> Result<T, Error>
where I: Input,

### impl<T> From<!> for T
#### fn from(t: !)

### impl<T> From<T> for T
#### fn from(t: T)

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

### impl<T> KeyedVec for T
where T: Codec,
#### fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8>

### impl<T> ToOwned for T
where T: Clone,
#### type Owned = T
#### fn to_owned(&self) -> T
#### fn clone_into(&self, target: &mut T)

### 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>

### 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>

### Description
This section outlines various blanket implementations for common Rust traits, providing extended functionality across different types within the codec library.

### Method
Various methods are provided by these trait implementations.

### Endpoint
None

### Parameters
None

### Request Example
None

### Response
None

### Response Example
None
```

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

### Rust: Collect type paths not starting or containing a specific ident

Source: https://docs.rs/parity-scale-codec/-derive/3.7.5/src/parity_scale_codec_derive/trait_bounds.rs

The `FindTypePathsNotStartOrContainIdent` struct traverses the AST and collects `TypePath` instances that do not start with or contain a specified `ident`. This is useful for filtering out specific types from a generic definition, such as excluding a 'Recursive' type.

```rust
struct FindTypePathsNotStartOrContainIdent<'a> {
	result: Vec<TypePath>,
	ident: &'a Ident,
}

impl<'a, 'ast> Visit<'ast> for FindTypePathsNotStartOrContainIdent<'a> {
	fn visit_type_path(&mut self, i: &'ast TypePath) {
		if type_path_or_sub_starts_with_ident(i, self.ident) {
			visit::visit_type_path(self, i);
		} else {
			self.result.push(i.clone());
		}
	}
}

/// Collects all type paths that do not start or contain the given ident in the given type.
///
/// Returns `T`, `N`, `A` for `Vec<(Recursive<T, N>, A)>` with `Recursive` as ident.
fn find_type_paths_not_start_or_contain_ident(ty: &Type, ident: &Ident) -> Vec<TypePath> {
	let mut visitor = FindTypePathsNotStartOrContainIdent { result: Vec::new(), ident };
	visitor.visit_type(ty);
	visitor.result
}
```

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

### Check Type Path Starts With Identifier - Rust

Source: https://docs.rs/parity-scale-codec/-derive/3.7.5/src/parity_scale_codec_derive/trait_bounds.rs_search=std%3A%3Avec

The `type_path_or_sub_starts_with_ident` function determines if a given type path or any of its sub-paths begin with a specific identifier. This is crucial for analyzing generic type arguments, such as checking if a type like `Vec<MyType>` starts with `MyType`.

```rust
/// Visits the ast and checks if the a type path starts with the given ident.
struct TypePathStartsWithIdent<'a> {
	result: bool,
	ident: &'a Ident,
}

impl<'a, 'ast> Visit<'ast> for TypePathStartsWithIdent<'a> {
	fn visit_type_path(&mut self, i: &'ast TypePath) {
		if let Some(segment) = i.path.segments.first() {
			if &segment.ident == self.ident {
				self.result = true;
				return;
			}
		}

		visit::visit_type_path(self, i);
	}
}

/// Checks if the given type path or any containing type path starts with the given ident.
fn type_path_or_sub_starts_with_ident(ty: &TypePath, ident: &Ident) -> bool {
	let mut visitor = TypePathStartsWithIdent { result: false, ident };
	visitor.visit_type_path(ty);
	visitor.result
}
```

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

### CloneToUninit Implementation

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.Compact

This nightly-only experimental API provides an `unsafe fn clone_to_uninit` for types `T` that implement `Clone`. It allows direct copying of data to an uninitialized memory location, which can be more performant in specific scenarios but requires careful handling due to its unsafe nature.

```rust
impl<T> CloneToUninit for T
where
    T: Clone,
{
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // Implementation details for unsafe cloning
    }
}
```

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

### CompactRef PartialEq Implementation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.CompactRef_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for comparing CompactRef instances for equality and inequality.

```APIDOC
## impl<'a, T: PartialEq> PartialEq for CompactRef<'a, T>

### Description
Implements the `PartialEq` trait for `CompactRef`, allowing comparison of `self` and `other` values for equality.

### Methods

#### fn eq(&self, other: &CompactRef<'a, T>) -> bool

- **Description**: Tests for `self` and `other` values to be equal. This method is used by the `==` operator.
- **Returns**: `true` if the values are equal, `false` otherwise.

#### fn ne(&self, other: &CompactRef<'a, T>) -> bool

- **Description**: Tests for inequality using the `!=` operator. The default implementation is usually sufficient and should not be overridden without strong justification.
- **Returns**: `true` if the values are not equal, `false` otherwise.
```

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

### Rust: EncodeLike Trait Definition and Usage Example

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/trait.EncodeLike_search=std%3A%3Avec

Defines the EncodeLike trait, which indicates that a type can be encoded to the same representation as another type. The example demonstrates how to use this trait with a generic function `encode_like` and various tuple types, showcasing its flexibility with references and values.

```Rust
pub trait EncodeLike<T: Encode = Self>: Sized + Encode { }

fn encode_like<T: Encode, R: EncodeLike<T>>(data: &R) {
    data.encode(); // Valid `T` encoded value.
}

fn main() {
    // Just pass the a reference to the normal tuple.
    encode_like::<(u32, u32), _>(&(1u32, 2u32));
    // Pass a tuple of references
    encode_like::<(u32, u32), _>(&(&1u32, &2u32));
    // Pass a tuple of a reference and a value.
    encode_like::<(u32, u32), _>(&(&1u32, 2u32));
}
```

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

### Rust: Collect Type Paths Not Starting or Containing Ident

Source: https://docs.rs/parity-scale-codec/-derive/3.7.5/src/parity_scale_codec_derive/trait_bounds.rs_search=

This snippet defines a visitor `FindTypePathsNotStartOrContainIdent` that collects `TypePath` elements from a Rust AST. It filters these paths, only collecting those that do not start with or contain a specified identifier. This is useful for identifying nested generic types that should not be processed further.

```rust
/// Visits the ast and collects all type paths that do not start or contain the given ident.
///
/// Returns `T`, `N`, `A` for `Vec<(Recursive<T, N>, A)>` with `Recursive` as ident.
struct FindTypePathsNotStartOrContainIdent<'a> {
	result: Vec<TypePath>,
	ident: &'a Ident,
}

impl<'a, 'ast> Visit<'ast> for FindTypePathsNotStartOrContainIdent<'a> {
	fn visit_type_path(&mut self, i: &'ast TypePath) {
		if type_path_or_sub_starts_with_ident(i, self.ident) {
			visit::visit_type_path(self, i);
		} else {
			self.result.push(i.clone());
		}
	}
}

/// Collects all type paths that do not start or contain the given ident in the given type.
///
/// Returns `T`, `N`, `A` for `Vec<(Recursive<T, N>, A)>` with `Recursive` as ident.
fn find_type_paths_not_start_or_contain_ident(ty: &Type, ident: &Ident) -> Vec<TypePath> {
	let mut visitor = FindTypePathsNotStartOrContainIdent { result: Vec::new(), ident };
	visitor.visit_type(ty);
	visitor.result
}
```

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

### CompactRef Auto Trait Implementations

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.CompactRef_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for auto trait implementations for CompactRef, including Freeze, RefUnwindSafe, Send, Sync, Unpin, and UnwindSafe.

```APIDOC
## Auto Trait Implementations for CompactRef<'a, T>

### impl<'a, T> Freeze for CompactRef<'a, T>

- **Description**: Implements the `Freeze` auto trait.

### impl<'a, T> RefUnwindSafe for CompactRef<'a, T>
where T: RefUnwindSafe,

- **Description**: Implements the `RefUnwindSafe` auto trait, indicating that it is safe to unwind past this type.

### impl<'a, T> Send for CompactRef<'a, T>
where T: Sync,

- **Description**: Implements the `Send` auto trait, indicating that it is safe to send across threads.

### impl<'a, T> Sync for CompactRef<'a, T>
where T: Sync,

- **Description**: Implements the `Sync` auto trait, indicating that it is safe to share across threads.

### impl<'a, T> Unpin for CompactRef<'a, T>

- **Description**: Implements the `Unpin` auto trait, indicating that it is pinned in memory.
```

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

### Rust: Visit AST for Type Path Starting with Ident

Source: https://docs.rs/parity-scale-codec/-derive/3.7.5/src/parity_scale_codec_derive/trait_bounds.rs_search=

This snippet defines a visitor `TypePathStartsWithIdent` to check if a type path within the AST starts with a specific identifier. It recursively visits type paths to find matching segments, useful for identifying specific generic parameters or types.

```rust
/// Visits the ast and checks if the a type path starts with the given ident.
struct TypePathStartsWithIdent<'a> {
	result: bool,
	ident: &'a Ident,
}

impl<'a, 'ast> Visit<'ast> for TypePathStartsWithIdent<'a> {
	fn visit_type_path(&mut self, i: &'ast TypePath) {
		if let Some(segment) = i.path.segments.first() {
			if &segment.ident == self.ident {
				self.result = true;
				return;
			}
		}

		visit::visit_type_path(self, i);
	}
}

/// Checks if the given type path or any containing type path starts with the given ident.
fn type_path_or_sub_starts_with_ident(ty: &TypePath, ident: &Ident) -> bool {
	let mut visitor = TypePathStartsWithIdent { result: false, ident };
	visitor.visit_type_path(ty);
	visitor.result
}

/// Checks if the given type or any containing type path starts with the given ident.
fn type_or_sub_type_path_starts_with_ident(ty: &Type, ident: &Ident) -> bool {
	let mut visitor = TypePathStartsWithIdent { result: false, ident };
	visitor.visit_type(ty);
	visitor.result
}
```

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

### CompactRef Blanket Implementations

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.CompactRef_search=u32+-%3E+bool

Details the blanket implementations for CompactRef, covering common traits like Any, Borrow, CloneToUninit, From, Into, ToOwned, TryFrom, and TryInto.

```APIDOC
## GET /websites/rs-parity-scale-codec/CompactRef/BlanketImplementations

### Description
This endpoint lists the blanket implementations available for `CompactRef<'a, T>`. Blanket implementations are traits that are implemented for a type based on the implementations of other traits. These include standard traits for type introspection, borrowing, cloning, conversion, and error handling.

- **Any**: Provides runtime type information.
- **Borrow<T>**: Allows immutable borrowing.
- **BorrowMut<T>**: Allows mutable borrowing.
- **CloneToUninit**: Experimental API for cloning to uninitialized memory.
- **From<T>**: Enables conversion from a type `T` to itself.
- **Into<U>**: Enables conversion into another type `U` if `U` implements `From<T>`.
- **ToOwned**: Allows creation of an owned version of the type.
- **TryFrom<U>**: Enables fallible conversion from a type `U`.
- **TryInto<U>**: Enables fallible conversion into a type `U` if `U` implements `TryFrom<T>`.

### Method
GET

### Endpoint
/websites/rs-parity-scale-codec/CompactRef/BlanketImplementations

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **implementations** (array) - A list of blanket traits implemented for CompactRef.

#### Response Example
```json
{
  "implementations": [
    "Any",
    "Borrow<T>",
    "BorrowMut<T>",
    "CloneToUninit",
    "From<T>",
    "Into<U>",
    "ToOwned",
    "TryFrom<U>",
    "TryInto<U>"
  ]
}
```
```

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

### Example Usage of EncodeAppend for Vec<u32> in Rust

Source: https://docs.rs/parity-scale-codec/latest/src/parity_scale_codec/encode_append.rs_search=u32+-%3E+bool

Demonstrates how to use the `EncodeAppend` trait to add elements to a SCALE-encoded vector. The example shows initializing an empty vector, appending a single element, and then appending multiple elements. This showcases the `append_or_new` function's ability to handle both initial encoding and subsequent appends.

```rust
# use parity_scale_codec::EncodeAppend;

// Some encoded data
let data = Vec::new();

let item = 8u32;
let encoded = <Vec<u32> as EncodeAppend>::append_or_new(data, std::iter::once(&item)).expect("Adds new element");

// Add multiple element
<Vec<u32> as EncodeAppend>::append_or_new(encoded, &[700u32, 800u32, 10u32]).expect("Adds new elements");
```

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

### From Implementation for CompactRef

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.CompactRef

Shows how to create a CompactRef from a reference to a type T.

```APIDOC
## impl<'a, T> From<&'a T> for CompactRef<'a, T>

### Description
Provides a way to construct a `CompactRef` from a reference `&'a T`.

### Method
`from`

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```rust
let value = 10;
let compact_ref = CompactRef::from(&value);
```

### Response
#### Success Response (200)
- **CompactRef<'a, T>** - A new `CompactRef` instance created from the provided reference.

#### Response Example
N/A
```

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

### Rust: Visit AST and check if type path starts with an ident

Source: https://docs.rs/parity-scale-codec/-derive/3.7.5/src/parity_scale_codec_derive/trait_bounds.rs

The `TypePathStartsWithIdent` struct traverses a Rust AST's type paths and checks if any segment of the path starts with a specified `ident`. It recursively visits nested type paths. This is helpful for identifying specific types or traits used within a definition.

```rust
struct TypePathStartsWithIdent<'a> {
	result: bool,
	ident: &'a Ident,
}

impl<'a, 'ast> Visit<'ast> for TypePathStartsWithIdent<'a> {
	fn visit_type_path(&mut self, i: &'ast TypePath) {
		if let Some(segment) = i.path.segments.first() {
			if &segment.ident == self.ident {
				self.result = true;
				return;
			}
		}

		visit::visit_type_path(self, i);
	}
}

/// Checks if the given type path or any containing type path starts with the given ident.
fn type_path_or_sub_starts_with_ident(ty: &TypePath, ident: &Ident) -> bool {
	let mut visitor = TypePathStartsWithIdent { result: false, ident };
	visitor.visit_type_path(ty);
	visitor.result
}

/// Checks if the given type or any containing type path starts with the given ident.
fn type_or_sub_type_path_starts_with_ident(ty: &Type, ident: &Ident) -> bool {
	let mut visitor = TypePathStartsWithIdent { result: false, ident };
	visitor.visit_type(ty);
	visitor.result
}
```

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

### Input Trait Implementation for MemTrackingInput

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.MemTrackingInput_search=std%3A%3Avec

Documentation for the Input trait methods implemented for MemTrackingInput, covering reading, memory allocation hooks, and reference handling.

```APIDOC
## Trait Implementations for MemTrackingInput

### impl<I: Input> Input for MemTrackingInput<'_, I>

#### `remaining_len(&mut self) -> Result<Option<usize>, Error>`
Should return the remaining length of the input data. If no information about the input length is available, `None` should be returned.

#### `read(&mut self, into: &mut [u8]) -> Result<(), Error>`
Read the exact number of bytes required to fill the given buffer.

#### `read_byte(&mut self) -> Result<u8, Error>`
Read a single byte from the input.

#### `descend_ref(&mut self) -> Result<(), Error>`
Descend into nested reference when decoding. This is called when decoding a new refence-based instance, such as `Vec` or `Box`. Currently, all such types are allocated on the heap.

#### `ascend_ref(&mut self)`
Ascend to previous structure level when decoding. This is called when decoding reference-based type is finished.

#### `on_before_alloc_mem(&mut self, size: usize) -> Result<(), Error>`
Hook that is called before allocating memory on the heap.
```

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

### CompactRef Trait Implementations

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.CompactRef_search=

Documents the various trait implementations for CompactRef, including Clone, Encode, and From, showcasing its behavior with different data types.

```APIDOC
## Trait Implementations for CompactRef

### impl<'a, T: Clone> Clone for CompactRef<'a, T>

#### fn clone(&self) -> CompactRef<'a, T>
Returns a duplicate of the value.

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

### impl<'a, T> From<&'a T> for CompactRef<'a, T>

#### fn from(x: &'a T) -> Self
Converts to this type from the input type.

### impl Encode for CompactRef<'_, ()>

#### fn encode_to<W: Output + ?Sized>(&self, _dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl<T> Encode for CompactRef<'_, T>
where T: CompactAs, for<'b> CompactRef<'b, T::As>: Encode,

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<Out: Output + ?Sized>(&self, dest: &mut Out)
Convert self to a slice and append it to the destination.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl Encode for CompactRef<'_, u128>

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<W: Output + ?Sized>(&self, dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl Encode for CompactRef<'_, u16>

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<W: Output + ?Sized>(&self, dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl Encode for CompactRef<'_, u32>

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<W: Output + ?Sized>(&self, dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl Encode for CompactRef<'_, u64>

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<W: Output + ?Sized>(&self, dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

### impl Encode for CompactRef<'_, u8>

#### fn size_hint(&self) -> usize
If possible give a hint of expected size of the encoding.

#### fn encode_to<W: Output + ?Sized>(&self, dest: &mut W)
Convert self to a slice and append it to the destination.

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
Convert self to a slice and then invoke the given closure with it.

#### fn encode(&self) -> Vec<u8>
Convert self to an owned vector.

#### fn encoded_size(&self) -> usize
Calculates the encoded size.

```

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

### Derive MaxEncodedLen for Structs and Enums with Examples

Source: https://docs.rs/parity-scale-codec/3.7.5/src/parity_scale_codec/lib.rs_search=u32+-%3E+bool

Demonstrates how to use the `MaxEncodedLen` derive macro for structs and enums in Rust. It shows examples for simple structs, tuple structs, and generic enums, including how to calculate the maximum encoded length by summing the lengths of individual fields or variants. This macro is conditional on the 'derive' and 'max-encoded-len' features.

```rust
#[derive(Encode, MaxEncodedLen)]
struct Example;
```

```rust
#[derive(Encode, MaxEncodedLen)]
struct TupleStruct(u8, u32);

assert_eq!(TupleStruct::max_encoded_len(), u8::max_encoded_len() + u32::max_encoded_len());
```

```rust
#[derive(Encode, MaxEncodedLen)]
enum GenericEnum<T> {
    A,
    B(T),
}

assert_eq!(GenericEnum::<u8>::max_encoded_len(), u8::max_encoded_len() + u8::max_encoded_len());
assert_eq!(GenericEnum::<u128>::max_encoded_len(), u8::max_encoded_len() + u128::max_encoded_len());
```

```rust
pub use parity_scale_codec as codec;

#[derive(Encode, MaxEncodedLen)]
#[codec(crate = $crate::codec)]
struct Example;
```

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

### TryFrom and TryInto Implementations

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.OptionBool_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Enables fallible conversions between types using `TryFrom` and `TryInto` traits.

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

#### Description
Allows attempting to convert a value of type `U` into type `T`, which may fail.

#### Type `Error`
`Infallible` - The type returned in the event of a conversion error. Note: `Infallible` indicates that this specific `TryFrom` implementation does not produce errors.

#### Function `try_from`
- **fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>**
  Performs the conversion from `U` to `T`.

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

#### Description
Allows attempting to convert a value of type `T` into type `U` using `TryFrom`, which may fail.

#### Type `Error`
`<U as TryFrom<T>>::Error` - The type returned in the event of a conversion error.

#### Function `try_into`
- **fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>**
  Performs the conversion from `T` to `U`.
```

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

### EncodeLike Trait Documentation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/trait.EncodeLike_search=u32+-%3E+bool

Details about the EncodeLike trait, its purpose, usage examples, and limitations.

```APIDOC
## Trait EncodeLike<T: Encode = Self>

### Description
A marker trait that tells the compiler that a type encodes to the same representation as another type. For example, `Vec<u8>` has the same encoded representation as `&[u8]`.

### Method
This documentation describes a trait, not a specific API endpoint with HTTP methods.

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Request Example
```rust
fn encode_like<T: Encode, R: EncodeLike<T>>(data: &R) {
    data.encode(); // Valid `T` encoded value.
}

fn main() {
    // Just pass the a reference to the normal tuple.
    encode_like::<(u32, u32), _>(&(1u32, 2u32));
    // Pass a tuple of references
    encode_like::<(u32, u32), _>(&(&1u32, &2u32));
    // Pass a tuple of a reference and a value.
    encode_like::<(u32, u32), _>(&(&1u32, 2u32));
}
```

### Response
N/A

### Warning
The relation is not symmetric. `T` implementing `EncodeLike<U>` does not mean `U` has the same representation as `T`. For instance, we could imagine a non-zero integer to be encoded to the same representation as the said integer, but not the other way around.

### Limitation
Not all possible implementations of `EncodeLike` are implemented (for instance `Box<Box<u32>>` does not implement `EncodeLike<u32>`). To bypass this issue, either open a PR to add the new combination or use `Ref` reference wrapper or define your own wrapper and implement `EncodeLike` on it.

```rust
fn encode_like<T: Encode, R: EncodeLike<T>>(data: &R) {
    data.encode(); // Valid `T` encoded value.
}

struct MyWrapper<'a>(&'a (Box<Box<u32>>, u32));
impl<'a> core::ops::Deref for MyWrapper<'a> { // Or use derive_deref crate
    type Target = (Box<Box<u32>>, u32);
    fn deref(&self) -> &Self::Target { &self.0 }
}

impl<'a> parity_scale_codec::WrapperTypeEncode for MyWrapper<'a> {}
impl<'a> parity_scale_codec::EncodeLike<(u32, u32)> for MyWrapper<'a> {}

fn main() {
    let v = (Box::new(Box::new(0)), 0);
    encode_like::<(u32, u32), _>(&MyWrapper(&v));
}
```

### Dyn Compatibility
This trait is **not** dyn compatible. In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

### Implementations on Foreign Types
- `bool`
- `f32`
- `f64`
- `i8`
- `i16`
- `i32`
- `i64`
- `i128`
- `u8`
- `u16`
- `u32`
- `u64`
- `u128`
- `()`
- `String`
- `Duration`
- `NonZeroI8`
- `NonZeroI16`
- `NonZeroI32`
- `NonZeroI64`
- `NonZeroI128`
- `NonZeroU8`
- `NonZeroU16`
- `NonZeroU32`
- `NonZeroU64`
- `NonZeroU128`
- `&str` for `String`
- `String` for `&str`

### Tuple Implementations
`EncodeLike` is implemented for tuples where each element `A0`, `B0`, etc. implements `EncodeLike<A1>`, `B1`, etc. respectively, and `A1`, `B1`, etc. implement `Encode`.
```

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

### MemTrackingInput Struct and Methods

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.MemTrackingInput_search=std%3A%3Avec

Details about the MemTrackingInput struct, including its constructor and method to get used memory.

```APIDOC
## Struct MemTrackingInput

### Description
`Input` implementation that can be used for limiting the heap memory usage while decoding.

### Methods

#### `new(input: &'a mut I, mem_limit: usize) -> Self`
Create a new instance of `MemTrackingInput`.

#### `used_mem(&self) -> usize`
Get the `used_mem` field.
```

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

### CompactLen Trait Documentation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/trait.CompactLen_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for the CompactLen trait, including its purpose, required methods, and dyn compatibility.

```APIDOC
## Trait CompactLen<T>

### Description
Something that can return the compact encoded length for a given value.

### Required Methods
#### fn compact_len(val: &T) -> usize
Returns the compact encoded length for the given value.

### Dyn Compatibility
This trait is **not** dyn compatible. In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
```

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

### EncodeAppend Trait Documentation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/trait.EncodeAppend_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for the EncodeAppend trait, including its associated types, methods, and examples.

```APIDOC
## Trait: EncodeAppend

### Description
Trait that allows to append items to an encoded representation without decoding all previous added items.

### Required Associated Types
#### type Item: Encode
- **Description**: The item that will be appended.

### Required Methods
#### fn append_or_new<EncodeLikeItem, I>(self_encoded: Vec<u8>, iter: I) -> Result<Vec<u8>, Error>
- **Description**: Appends all items in `iter` to the given `self_encoded` representation or if `self_encoded` value is empty, `iter` is encoded to the `Self` representation.
- **Parameters**:
  - `self_encoded` (Vec<u8>) - The existing encoded data.
  - `iter` (I) - An iterator of items to append, where `I` implements `IntoIterator` and its items implement `EncodeLike<Self::Item>`. The iterator must also be an `ExactSizeIterator`.
- **Returns**: `Result<Vec<u8>, Error>` - A `Vec<u8>` containing the updated encoded data or an `Error` if the operation fails.

### Example
```rust
// Some encoded data
let data = Vec::new();

let item = 8u32;
let encoded = <Vec<u32> as EncodeAppend>::append_or_new(data, std::iter::once(&item)).expect("Adds new element");

// Add multiple elements
<Vec<u32> as EncodeAppend>::append_or_new(encoded, &[700u32, 800u32, 10u32]).expect("Adds new elements");
```

### Dyn Compatibility
This trait is **not** dyn compatible.

### Implementations on Foreign Types
#### impl<T: Encode> EncodeAppend for VecDeque<T>
- **Type**: `T` where `T: Encode`
- **Method**: `append_or_new` (same signature as trait)

#### impl<T: Encode> EncodeAppend for Vec<T>
- **Type**: `T` where `T: Encode`
- **Method**: `append_or_new` (same signature as trait)
```

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

### Conversion and Creation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.Compact_search=std%3A%3Avec

Functions for creating and converting Compact<T> instances.

```APIDOC
## Conversion and Creation

### `impl<'a, T: Copy> From<&'a T> for Compact<T>`

#### `fn from(x: &'a T) -> Compact<T>`

Converts to this type from the input type.

### `impl From<Compact<()>> for ()`

#### `fn from(x: Compact<()>)`

Converts to this type from the input type.

### `impl From<Compact<u128>> for u128`

#### `fn from(x: Compact<u128>) -> u128`

Converts to this type from the input type.

### `impl From<Compact<u16>> for u16`

#### `fn from(x: Compact<u16>) -> u16`

Converts to this type from the input type.

### `impl From<Compact<u32>> for u32`

#### `fn from(x: Compact<u32>) -> u32`

Converts to this type from the input type.

### `impl From<Compact<u64>> for u64`

#### `fn from(x: Compact<u64>) -> u64`

Converts to this type from the input type.

### `impl From<Compact<u8>> for u8`

#### `fn from(x: Compact<u8>) -> u8`

Converts to this type from the input type.

### `impl<T> From<T> for Compact<T>`

#### `fn from(x: T) -> Compact<T>`

Converts to this type from the input type.
```

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

### MemTrackingInput: Get Used Memory (Rust)

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.MemTrackingInput

The `used_mem` function returns the current amount of memory that has been utilized by the `MemTrackingInput` instance.

```rust
pub fn used_mem(&self) -> usize
```

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

### CompactRef StructuralPartialEq Implementation

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.CompactRef_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Enables structural partial equality comparison for CompactRef.

```APIDOC
## impl<'a, T> StructuralPartialEq for CompactRef<'a, T>

### Description
Implements the `StructuralPartialEq` trait for `CompactRef`, allowing for structural comparison of its components.
```

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

### Get Read Byte Count - Rust

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.CountedInput_search=

Retrieves the number of bytes that have been successfully read by the `CountedInput` wrapper. This count is a `u64` value.

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

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

### Implement CloneToUninit (Nightly Only)

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.CompactRef_search=std%3A%3Avec

Implements the experimental `CloneToUninit` trait, allowing cloning of a value into an uninitialized memory location. This is a nightly-only feature and requires `unsafe` code.

```rust
impl<T: Clone> CloneToUninit for T {
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // Implementation involves pointer manipulation and cloning
        std::ptr::write(dest as *mut T, self.clone());
    }
}
```

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

### TypeID Function Implementation

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.CompactRef_search=

Provides a way to get the TypeId of any type T that implements the 'static and ?Sized traits. TypeId is used for runtime type identification.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source§
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
Source§
```

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

### Implement StructuralPartialEq for OptionBool in Rust

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.OptionBool_search=

Provides the implementation for StructuralPartialEq for OptionBool, enabling structural equality comparisons.

```rust
impl StructuralPartialEq for OptionBool {}
```

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

### Create and Use CountedInput

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.CountedInput

Demonstrates how to create a new `CountedInput` instance with a given mutable input reference and how to retrieve the total number of bytes successfully read from it.

```rust
pub fn new(input: &'a mut I) -> Self
Get the number of bytes successfully read.
pub fn count(&self) -> u64
```

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

### Implement Any for Generic Type T in Rust

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.Error_search=u32+-%3E+bool

Provides a way to get the `TypeId` of any type `T` that is `'static` and sized. This is part of the dynamic typing capabilities in Rust.

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

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

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

### Encode for Range<T>

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/trait.Encode_search=std%3A%3Avec

Implements the `Encode` trait for `Range<T>`, where `T` must implement `Encode`. This enables the encoding of ranges, which are typically represented by their start and end points.

```rust
impl<T> Encode for Range<T>
where T: Encode,
{
    fn size_hint(&self) -> usize;
    fn encode(&self) -> Vec<u8>;
}
```

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

### Type Conversion with TryFrom and TryInto (Rust)

Source: https://docs.rs/parity-scale-codec/3.7.5/parity_scale_codec/struct.OptionBool_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides implementations for `TryFrom` and `TryInto` traits, enabling fallible conversions between types. These conversions can fail and return a `Result`.

```rust
/// The type returned in the event of a conversion error.
type Error = Infallible;

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

/// The type returned in the event of a conversion error.
type Error = <U as TryFrom<T>>::Error;

/// Performs the conversion.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>;
```

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

### Implement ToString for Generic Type T in Rust

Source: https://docs.rs/parity-scale-codec/latest/parity_scale_codec/struct.Error_search=u32+-%3E+bool

Enables converting any type `T` that implements `Display` into a `String`. This is a common way to get a string representation of a value.

```rust
impl<T> ToString for T where T: Display + ?Sized

fn to_string(&self) -> String
```
Tokens:
Raw