Struct Forwardable 

pub struct Forwardable<T> {
    pub inner: T,
    /* private fields */
}

A wrapper that holds domain data along with forward compatibility context.

This type preserves information from unknown versions so that when saved, the data can be written back with minimal information loss.

Usage

// Load with forward compatibility
let mut task: Forwardable<TaskEntity> = migrator.load_forward("task", json)?;

// Access inner data (Deref makes this transparent)
task.title = "updated".to_string();

// Check if it was a lossy load
if task.was_lossy() {
    warn!("Loaded from unknown version: {}", task.original_version());
}

// Save preserving unknown fields and original version
let json = migrator.save_forward(&task)?;

Fields

inner: T

The inner domain data.

Implementations

impl<T> Forwardable<T>

pub fn original_version(&self) -> &str

Returns the original version of the data.

pub fn was_lossy(&self) -> bool

Returns true if the load was lossy (unknown version).

pub fn unknown_fields(&self) -> &Map<String, Value>

Returns the unknown fields that were preserved.

pub fn context(&self) -> &ForwardContext

Returns a reference to the forward context.

pub fn into_inner(self) -> T

Consumes the wrapper and returns the inner value.

Trait Implementations

impl<T: Clone> Clone for Forwardable<T>

fn clone(&self) -> Forwardable<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Forwardable<T>

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

Formats the value using the given formatter.

impl<T> Deref for Forwardable<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Forwardable<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Forwardable<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Serialize> Serialize for Forwardable<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.