Trait TryPatch 

pub trait TryPatch: Patchable {
    type Error: Error + Send + Sync + 'static;

    // Required method
    fn try_patch(&mut self, patch: Self::Patch) -> Result<(), Self::Error>;
}

A fallible variant of Patch.

This trait lets you apply a patch with validation and return a custom error if it cannot be applied.

Usage

use patchable::{TryPatch, Patchable};
use std::fmt;

#[derive(Debug)]
struct Config {
    concurrency: u32,
}

#[derive(Clone, PartialEq)]
struct ConfigPatch {
    concurrency: u32,
}

#[derive(Debug)]
struct PatchError(String);

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

impl std::error::Error for PatchError {}

impl Patchable for Config {
    type Patch = ConfigPatch;
}

impl From<Config> for ConfigPatch {
    fn from(c: Config) -> Self {
        Self { concurrency: c.concurrency }
    }
}

impl TryPatch for Config {
    type Error = PatchError;

    fn try_patch(&mut self, patch: Self::Patch) -> Result<(), Self::Error> {
        if patch.concurrency == 0 {
            return Err(PatchError("Concurrency must be > 0".into()));
        }
        self.concurrency = patch.concurrency;
        Ok(())
    }
}

let mut config = Config { concurrency: 1 };
let valid_patch = ConfigPatch { concurrency: 4 };
config.try_patch(valid_patch).unwrap();
assert_eq!(config.concurrency, 4);

let invalid_patch = ConfigPatch { concurrency: 0 };
assert!(config.try_patch(invalid_patch).is_err());

Required Associated Types

type Error: Error + Send + Sync + 'static

The error type returned when applying a patch fails.

Required Methods

fn try_patch(&mut self, patch: Self::Patch) -> Result<(), Self::Error>

Applies the provided patch to self.

Errors

Returns an error if the patch is invalid or cannot be applied.

Implementors

impl<T: Patch> TryPatch for T

Blanket implementation for all Patch types, where patching is infallible.

type Error = Infallible