Enum Idempotent 

pub enum Idempotent<T> {
    Executed(T),
    AlreadyApplied,
}

Signals if a mutation is applied or was skipped.

Distinguishes between operations that were executed versus those that were ignored due to idempotency checks. The idempotency_guard macro provides an easy way to do such checks.

Examples

use es_entity::{idempotency_guard, Idempotent};
pub enum UserEvent{
    Initialized {id: u64, name: String},
    NameUpdated {name: String}
}

pub struct User{
    events: Vec<UserEvent>
}

impl User{
    // This returns `Idempotent<T>` where T is the return value we get after the event is processed
    pub fn update_name(&mut self, new_name: impl Into<String>) -> Idempotent<()>{
        let name = new_name.into();
        idempotency_guard!(
            self.events.iter().rev(),
            UserEvent::NameUpdated { name: existing_name } if existing_name == &name
        );
        self.events.push(UserEvent::NameUpdated{name});
        Idempotent::Executed(())
    }
}
   
fn example(){
    let mut user = User{ events: vec![] };
    assert!(user.update_name("Alice").did_execute());
    // updating "Alice" executes as no such event has been processed before.
    // Signalled by returning `Idempotent::Executed(T)`, validated with `did_execute` helper method

    assert!(user.update_name("Alice").was_already_applied());
    // updating "Alice" again ignored because same event has been processed before.
    // Signalled by returning `Idempotent::AlreadyApplied` early, validated with `was_already_applied` helper method
}

Variants

Executed(T)

AlreadyApplied

Implementations

impl<T> Idempotent<T>

pub fn was_already_applied(&self) -> bool

Returns true if the operation was ignored due to idempotency checks.

pub fn did_execute(&self) -> bool

Returns true if the operation was executed.

pub fn unwrap(self) -> T

Unwraps the value if executed, panics if ignored.

pub fn expect(self, msg: &str) -> T

Unwraps the value if executed, panics with custom message if ignored.

Trait Implementations

impl<T> FromAlreadyApplied for Idempotent<T>

fn from_already_applied() -> Self

to handle Idempotent<T> return type