Struct Code 

pub struct Code<C: ComponentId, P: PrimaryId> { /* private fields */ }

Waddling diagnostic code: SEVERITY.COMPONENT.PRIMARY.SEQUENCE

Format: E.CRYPTO.SALT.001

This type is generic over component and primary types that implement the ComponentId and PrimaryId traits. This allows full type safety while maintaining extensibility.

Examples

Define your own component and primary enums:

use waddling_errors::{Code, ComponentId, PrimaryId};

#[derive(Debug, Clone, Copy)]
enum Component { Crypto }
impl ComponentId for Component {
    fn as_str(&self) -> &'static str { "CRYPTO" }
}

#[derive(Debug, Clone, Copy)]
enum Primary { Salt }
impl PrimaryId for Primary {
    fn as_str(&self) -> &'static str { "SALT" }
}

const ERR: Code<Component, Primary> = Code::error(Component::Crypto, Primary::Salt, 1);
assert_eq!(ERR.code(), "E.CRYPTO.SALT.001");

Implementations

impl<C: ComponentId, P: PrimaryId> Code<C, P>

pub const fn new( severity: Severity, component: C, primary: P, sequence: u16, ) -> Self

Create a new code with explicit severity

Panics

Panics if sequence > 999

pub const fn error(component: C, primary: P, sequence: u16) -> Self

Create an error code (E)

pub const fn warning(component: C, primary: P, sequence: u16) -> Self

Create a warning code (W)

pub const fn critical(component: C, primary: P, sequence: u16) -> Self

Create a critical code (C)

pub const fn blocked(component: C, primary: P, sequence: u16) -> Self

Create a blocked code (B)

pub const fn help(component: C, primary: P, sequence: u16) -> Self

Create a help code (H)

pub const fn success(component: C, primary: P, sequence: u16) -> Self

Create a success code (S)

pub const fn completed(component: C, primary: P, sequence: u16) -> Self

Create a completed code (K)

pub const fn info(component: C, primary: P, sequence: u16) -> Self

Create an info code (I)

pub const fn trace(component: C, primary: P, sequence: u16) -> Self

Create a trace code (T)

pub fn code(&self) -> String

Get the full error code (e.g., “E.CRYPTO.SALT.001”)

pub fn write_code(&self, f: &mut impl Write) -> Result

Write error code to formatter without allocating

Use in performance-critical paths to avoid String allocation.

pub const fn severity(&self) -> Severity

Get severity

pub const fn component(&self) -> C

Get component

pub fn component_str(&self) -> &'static str

Get component as string

pub const fn primary(&self) -> P

Get primary category

pub fn primary_str(&self) -> &'static str

Get primary as string

pub const fn sequence(&self) -> u16

Get sequence number

Trait Implementations

impl<C: Clone + ComponentId, P: Clone + PrimaryId> Clone for Code<C, P>

fn clone(&self) -> Code<C, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + ComponentId, P: Debug + PrimaryId> Debug for Code<C, P>

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

Formats the value using the given formatter.

impl<C: ComponentId, P: PrimaryId> Display for Code<C, P>

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

Formats the value using the given formatter.

impl<C: Hash + ComponentId, P: Hash + PrimaryId> Hash for Code<C, P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C: PartialEq + ComponentId, P: PartialEq + PrimaryId> PartialEq for Code<C, P>

fn eq(&self, other: &Code<C, P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C: Copy + ComponentId, P: Copy + PrimaryId> Copy for Code<C, P>

impl<C: Eq + ComponentId, P: Eq + PrimaryId> Eq for Code<C, P>

impl<C: ComponentId, P: PrimaryId> StructuralPartialEq for Code<C, P>