Trait IdGenerator 

pub trait IdGenerator<Id>: Send + Sync
where
    Id: EntityId,
{
    // Required method
    fn generate(&self) -> Id;
}

Generates new EntityIds, e.g. for a new aggregate.

crate::adapter::id::UuidV4Generator and crate::adapter::id::UuidV7Generator generate real, unique ids; crate::mock::id::FixedIdGenerator is a test double that always returns the same configured id.

Examples

use ddd_toolkit_core::domain::{EntityId, ValueObject};
use ddd_toolkit_core::port::id::IdGenerator;
use std::fmt::Display;
use std::sync::atomic::{AtomicU32, Ordering};

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct OrderId(u32);

impl ValueObject for OrderId {}

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

impl EntityId for OrderId {}

struct SequentialGenerator(AtomicU32);

impl IdGenerator<OrderId> for SequentialGenerator {
    fn generate(&self) -> OrderId {
        OrderId(self.0.fetch_add(1, Ordering::Relaxed))
    }
}

let generator = SequentialGenerator(AtomicU32::new(1));

assert_eq!(generator.generate(), OrderId(1));
assert_eq!(generator.generate(), OrderId(2));

Required Methods

fn generate(&self) -> Id

Generates a new id.

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl<Id> IdGenerator<Id> for FixedIdGenerator<Id>

where Id: EntityId,

impl<Id> IdGenerator<Id> for UuidV4Generator<Id>

where Id: EntityId + TryFrom<Uuid, Error = Infallible>,

impl<Id> IdGenerator<Id> for UuidV7Generator<Id>

where Id: EntityId + TryFrom<Uuid, Error = Infallible>,