Enum DxError 

pub enum DxError {
    UnexpectedEof(usize),
    ParseError {
        location: SourceLocation,
        message: String,
        snippet: String,
    },
    InvalidSyntax {
        pos: usize,
        msg: String,
    },
    SchemaError(String),
    TypeMismatch {
        expected: String,
        actual: String,
    },
    UnknownAlias(String),
    UnknownAnchor(String),
    InvalidTypeHint(String),
    InvalidNumber(String),
    Utf8Error {
        offset: usize,
    },
    Base62Error {
        char: char,
        position: usize,
        message: String,
    },
    IntegerOverflow,
    InvalidMagic(u8, u8),
    UnsupportedVersion {
        found: u8,
        expected: u8,
    },
    BufferTooSmall {
        required: usize,
        available: usize,
    },
    CompressionError(String),
    DecompressionError(String),
    Io(String),
    UnsupportedPlatform(String),
    ConversionError(String),
    DittoNoPrevious(usize),
    PrefixError(String),
    InputTooLarge {
        size: usize,
        max: usize,
    },
    RecursionLimitExceeded {
        depth: usize,
        max: usize,
    },
    TableTooLarge {
        rows: usize,
        max: usize,
    },
}

Comprehensive error type for all DX serializer operations

Variants

UnexpectedEof(usize)

Unexpected end of input during parsing

ParseError

Parse error with location information and snippet

Fields

location: SourceLocation

Source location where parsing failed.

message: String

Human-readable parse failure message.

snippet: String

Snippet of the problematic input (up to 50 chars)

InvalidSyntax

Invalid syntax at a specific position

Fields

pos: usize

Byte position where the syntax error was detected.

msg: String

Human-readable syntax failure message.

SchemaError(String)

Schema validation error

TypeMismatch

Type mismatch during parsing or conversion

Fields

expected: String

Expected type or schema name.

actual: String

Actual type or value kind that was found.

UnknownAlias(String)

Unknown alias reference

UnknownAnchor(String)

Unknown anchor reference

InvalidTypeHint(String)

Invalid type hint in schema

InvalidNumber(String)

Invalid number format

Utf8Error

Invalid UTF-8 sequence

Fields

offset: usize

Byte offset where invalid UTF-8 begins.

Base62Error

Invalid Base62 character

Fields

char: char

Invalid Base62 character.

position: usize

Character position where the error was found.

message: String

Human-readable Base62 failure message.

IntegerOverflow

Integer overflow during encoding/decoding

InvalidMagic(u8, u8)

Invalid magic bytes in binary header

UnsupportedVersion

Unsupported binary format version

Fields

found: u8

Version found in the input.

expected: u8

Version supported by this crate.

BufferTooSmall

Buffer too small for operation

Fields

required: usize

Required number of bytes.

available: usize

Available number of bytes.

CompressionError(String)

Compression operation failed

DecompressionError(String)

Decompression operation failed

Io(String)

General I/O error (wraps std::io::Error message)

UnsupportedPlatform(String)

Platform not supported for operation

ConversionError(String)

Format conversion error

DittoNoPrevious(usize)

Ditto operator without previous value

PrefixError(String)

Prefix inheritance failed

InputTooLarge

Input size exceeds maximum allowed

Fields

size: usize

Input size in bytes.

max: usize

Maximum allowed input size in bytes.

RecursionLimitExceeded

Recursion depth exceeds maximum allowed

Fields

depth: usize

Observed recursion depth.

max: usize

Maximum allowed recursion depth.

TableTooLarge

Table row count exceeds maximum allowed

Fields

rows: usize

Observed table row count.

max: usize

Maximum allowed table row count.

Implementations

impl DxError

pub fn parse_error( input: &[u8], offset: usize, message: impl Into<String>, ) -> Self

Create a parse error with location information and snippet

pub fn parse_error_with_location( location: SourceLocation, message: impl Into<String>, snippet: impl Into<String>, ) -> Self

Create a parse error with explicit location and snippet

pub fn type_mismatch( expected: impl Into<String>, actual: impl Into<String>, ) -> Self

Create a type mismatch error

pub fn utf8_error(offset: usize) -> Self

Create a UTF-8 error at a specific offset

pub fn base62_error( char: char, position: usize, message: impl Into<String>, ) -> Self

Create a Base62 error with position

pub fn invalid_magic(byte0: u8, byte1: u8) -> Self

Create an invalid magic error

pub fn unsupported_version(found: u8) -> Self

Create an unsupported version error

pub fn buffer_too_small(required: usize, available: usize) -> Self

Create a buffer too small error

pub fn input_too_large(size: usize) -> Self

Create an input too large error

pub fn recursion_limit_exceeded(depth: usize) -> Self

Create a recursion limit exceeded error

pub fn table_too_large(rows: usize) -> Self

Create a table too large error

pub fn offset(&self) -> Option<usize>

Get the byte offset if available

pub fn location(&self) -> Option<&SourceLocation>

Get the source location if available

pub fn snippet(&self) -> Option<&str>

Get the snippet if available

pub fn line(&self) -> Option<usize>

Get line number if available (1-indexed)

pub fn column(&self) -> Option<usize>

Get column number if available (1-indexed)

pub fn is_recoverable(&self) -> bool

Check if this is a recoverable error

Trait Implementations

impl Clone for DxError

fn clone(&self) -> DxError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DxError

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

Formats the value using the given formatter.

impl Display for DxError

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

Formats the value using the given formatter.

impl Error for DxError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ConvertError> for DxError

fn from(err: ConvertError) -> Self

Convert a ConvertError into a DxError.

This conversion handles all ConvertError variants:

• LlmParse: Converts the underlying ParseError to DxError
• HumanParse: Converts to ConversionError with the error message
• MachineFormat: Converts to ConversionError with the error message

impl From<Error> for DxError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for DxError

fn from(err: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ParseError> for DxError

fn from(err: ParseError) -> Self

Convert a ParseError from the LLM parser into a DxError.

This conversion preserves position information where available, mapping each ParseError variant to the most appropriate DxError variant.

impl From<Utf8Error> for DxError

fn from(err: Utf8Error) -> Self

Converts to this type from the input type.

impl PartialEq for DxError

fn eq(&self, other: &DxError) -> 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 StructuralPartialEq for DxError