Trait Container 

pub trait Container<T>: Deref<Target = T> + Value {
    // Required method
    fn into_inner(self) -> T;
}

The trait defining the required functionality of container types

The Freedom API is generic over “containers”. Each implementer of the Api trait must also define a container. This is useful since certain clients will return Arc’d values, i.e. the caching client, while others return the values wrapped in a simple Inner type which is just a stack value.

However, for most cases this complexity can be ignored, since containers are required to implement Deref of T. So for read-only operations the container can be used as if it were T. For mutable access see Self::into_inner.

Example

let request = client
    .get_request_by_id(42)
    .await?;

println!("Created on {}", request.created); // Direct access to created field
                                            // through the Container

Required Methods

fn into_inner(self) -> T

All containers are capable of returning the value they wrap

However, the runtime performance of this varies by client type. For crate::Client, this operation is essentially free, however for the caching client, this often results in a clone of the value.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: Deref<Target = T> + Value> Container<T> for Box<T>

fn into_inner(self) -> T

Implementors

impl<T> Container<T> for Inner<T>

where T: Value,