Struct EntityTypeRegistry 

pub struct EntityTypeRegistry { /* private fields */ }

Registry for (EntityKind, entity_type) pair validation and alias normalisation.

Implementations

impl EntityTypeRegistry

pub fn new(defs: impl IntoIterator<Item = EntityTypeDef>) -> Self

Build a fresh registry from the supplied definitions.

Every lookup key (kind-qualified and bare, canonical and alias) is routed through to_snake_case before insertion — the same normalisation resolve applies to incoming wire values (ADR-001:106). Two differently-cased/separated spellings that normalise to the same key therefore land on the same registry slot instead of silently shadowing one another under distinct raw keys.

pub fn builtin() -> Self

Return the built-in registry with all static subtype definitions.

pub fn with_extra(extra: impl IntoIterator<Item = EntityTypeDef>) -> Self

Derive a registry that includes all built-in subtypes plus the caller-supplied extras (used by packs that extend the vocabulary).

pub fn check_extra_collisions<'a>( extras: impl IntoIterator<Item = (&'a str, &'a EntityTypeDef)>, ) -> Result<(), String>

Boot-time collision check across the composed registry with_extra builds: built-in defs plus every caller-supplied (owner, def) extra.

new/register populate a single kind-qualified lookup keyspace ("{kind}:{canonical_name}" and "{kind}:{alias}") with a hard insert — the later write silently wins. Two independently loaded owners can therefore disagree on what a given key resolves to, and the winner depends on registration order. ADR-001’s registry-ownership contract instead requires this to fail at boot: “same (base_kind, canonical_name) from two different packs = boot error” and “an alias collision = boot error.” This walks the same keyspace new/register populate and returns the first collision found, naming both contributing owners, instead of silently picking a winner.

extras is (owner_label, def) for pack-declared entries only — the built-in table is checked automatically, attributed to the label "builtin".

Every canonical and alias key is routed through the same to_snake_case normalisation new/register apply before insertion (ADR-001:104-107): two spellings that only differ in case or separator style (e.g. "Architecture Decision Record" vs. "architecture-decision-record") collide here exactly as they would collide in the composed registry’s lookup keyspace.

pub fn register(&mut self, def: EntityTypeDef)

Register additional subtypes into an existing registry clone.

Mirrors Self::new’s normalisation: every key is routed through to_snake_case before insertion.

pub fn resolve( &self, kind: EntityKind, entity_type: Option<&str>, ) -> Result<ResolvedEntityType, EntityTypeError>

Validate and normalise a (kind, entity_type) wire pair.

pub fn valid_types_for(&self, kind: EntityKind) -> String

Comma-separated list of canonical type names valid for kind.

impl EntityTypeRegistry

pub fn global() -> &'static EntityTypeRegistry

Return a reference to the module-level built-in registry.

Trait Implementations

impl Clone for EntityTypeRegistry

fn clone(&self) -> EntityTypeRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.