Enum KeyParseError

Source

#[non_exhaustive]pub enum KeyParseError {
    Empty,
    InvalidCharacter {
        character: char,
        position: usize,
        expected: Option<&'static str>,
    },
    TooLong {
        max_length: usize,
        actual_length: usize,
    },
    InvalidStructure {
        reason: &'static str,
    },
    DomainValidation {
        domain: &'static str,
        message: String,
    },
    Custom {
        code: u32,
        message: String,
    },
}

Expand description

Comprehensive error type for key parsing and validation failures

This enum covers all possible validation failures that can occur during key creation, providing detailed information for debugging and user feedback.

§Error Categories

Length Errors: Empty keys or keys exceeding maximum length
Character Errors: Invalid characters at specific positions
Structure Errors: Invalid patterns like consecutive special characters
Domain Errors: Domain-specific validation failures
Custom Errors: Application-specific validation failures

§Examples

use domain_key::{KeyParseError, ErrorCategory};

// Handle different error types
match KeyParseError::Empty {
    err => {
        println!("Error: {}", err);
        println!("Code: {}", err.code());
        println!("Category: {:?}", err.category());
    }
}

Variants (Non-exhaustive)§

This enum is marked as non-exhaustive

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

§

Empty

Key cannot be empty or contain only whitespace

This error occurs when attempting to create a key from an empty string or a string containing only whitespace characters.

§

InvalidCharacter

Key contains a character that is not allowed at the specified position

Each domain defines which characters are allowed. This error provides the specific character, its position, and optionally what was expected.

Fields

§character: char

The invalid character that was found

§position: usize

Position where the invalid character was found (0-based)

§expected: Option<&'static str>

Optional description of what characters are expected

§

TooLong

Key exceeds the maximum allowed length for the domain

Each domain can specify a maximum length. This error provides both the limit and the actual length that was attempted.

Fields

§max_length: usize

The maximum allowed length for this domain

§actual_length: usize

The actual length of the key that was attempted

§

InvalidStructure

Key has invalid structure (consecutive special chars, invalid start/end)

This covers structural issues like:

Starting or ending with special characters
Consecutive special characters
Invalid character sequences

Fields

§reason: &'static str

Description of the structural issue

§

DomainValidation

Domain-specific validation error

This error is returned when domain-specific validation rules fail. It includes the domain name and a descriptive message.

Fields

§domain: &'static str

The domain name where validation failed

§message: String

The error message describing what validation failed

§

Custom

Custom error for specific use cases

Applications can define custom validation errors with numeric codes for structured error handling.

Fields

§code: u32

Custom error code for programmatic handling

§message: String

The custom error message

Implementations§

Source §

impl KeyParseError

Source

pub fn domain_error(domain: &'static str, message: impl Into<String>) -> Self

Create a domain validation error with domain name

This is the preferred way to create domain validation errors.

§Examples

use domain_key::KeyParseError;

let error = KeyParseError::domain_error("my_domain", "Custom validation failed");
// Verify it's the correct error type
match error {
    KeyParseError::DomainValidation { domain, message } => {
        assert_eq!(domain, "my_domain");
        assert!(message.contains("Custom validation failed"));
    },
    _ => panic!("Expected domain validation error"),
}

Source

pub fn domain_error_generic(message: impl Into<String>) -> Self

Create a domain validation error without specifying domain (for internal use)

Source

pub fn domain_error_with_source( domain: &'static str, message: impl Into<String>, source: &(dyn Error + Send + Sync), ) -> Self

Create a domain validation error with source error information

Source

pub fn custom(code: u32, message: impl Into<String>) -> Self

Create a custom validation error

Custom errors allow applications to define their own error codes for structured error handling.

§Examples

use domain_key::KeyParseError;

let error = KeyParseError::custom(1001, "Business rule violation");
assert_eq!(error.code(), 1001);

Source

pub fn custom_with_source( code: u32, message: impl Into<String>, source: &(dyn Error + Send + Sync), ) -> Self

Create a custom validation error with source error information

Source

pub const fn code(&self) -> u32

Get the error code for machine processing

Returns a numeric code that can be used for programmatic error handling. This is useful for APIs that need to return structured error responses.

§Error Codes

1001: Empty key
1002: Invalid character
1003: Key too long
1004: Invalid structure
2000: Domain validation (base code)
Custom codes: As specified in Custom errors

§Examples

use domain_key::KeyParseError;

assert_eq!(KeyParseError::Empty.code(), 1001);
assert_eq!(KeyParseError::custom(42, "test").code(), 42);

Source

pub const fn category(&self) -> ErrorCategory

Get the error category for classification

Returns the general category of this error for higher-level error handling. This allows applications to handle broad categories of errors uniformly.

§Examples

use domain_key::{KeyParseError, ErrorCategory};

match KeyParseError::Empty.category() {
    ErrorCategory::Length => println!("Length-related error"),
    ErrorCategory::Character => println!("Character-related error"),
    _ => println!("Other error type"),
}

Source