Module errors 

Error Handling for SWIFT MT Message Library

Purpose

Comprehensive error types and result handling for SWIFT MT message parsing, validation, and processing. Provides detailed error information for debugging and error recovery.

Error Categories

• Parse Errors: Issues during message parsing and field extraction
• Validation Errors: Field format and business rule validation failures
• Type Errors: Message type mismatches and unsupported formats
• IO Errors: File system and network-related errors
• Serialization Errors: JSON and data conversion issues

Error Design

All errors implement:

• std::error::Error trait for standard error handling
• Serialize/Deserialize for API error responses
• Clone for error propagation and logging
• Debug for comprehensive debugging information

Usage Examples

use swift_mt_message::errors::{ParseError, ValidationError, Result};
use swift_mt_message::parser::SwiftParser;
use swift_mt_message::ValidationResult;

// Handle parsing errors
match SwiftParser::parse_auto(&invalid_message) {
    Ok(message) => println!("Parsed successfully: {:?}", message),
    Err(ParseError::InvalidFieldFormat(err)) => {
        eprintln!("Format error in field {}: {}", err.field_tag, err.component_name);
    },
    Err(ParseError::MissingRequiredField { field_tag, field_name, .. }) => {
        eprintln!("Missing required field: {} ({})", field_tag, field_name);
    },
    Err(other) => eprintln!("Other error: {}", other),
}

// Handle validation errors
let validation_result = ValidationResult::with_errors(vec![
    ValidationError::FormatValidation {
        field_tag: "20".to_string(),
        message: "Invalid format".to_string()
    },
]);
if !validation_result.is_valid {
    for error in validation_result.errors {
        match error {
            ValidationError::FormatValidation { field_tag, message } => {
                eprintln!("Field {} format error: {}", field_tag, message);
            },
            ValidationError::BusinessRuleValidation { rule_name, message } => {
                eprintln!("Business rule {} failed: {}", rule_name, message);
            },
            _ => eprintln!("Validation error: {}", error),
        }
    }
}

Error Recovery

Many errors provide sufficient context for automated error recovery:

• Field validation errors include expected formats for correction
• Parse errors include position information for partial recovery
• Business rule errors include rule names for selective validation

Modules

error_codes

SWIFT Error Code Constants

Structs

FieldParseResult

Result of parsing a field with potential error

InvalidFieldFormatError

Details for invalid field format errors

ParseErrorCollection

Collection of parsing errors for comprehensive error reporting

ParserConfig

Parser configuration options

SwiftBusinessError

C-Series: Conditional/Business Rules Error

SwiftContentError

D-Series: Data/Content Validation Error

SwiftFormatError

T-Series: Technical/Format Validation Error

SwiftGeneralError

G-Series: General/Field Validation Error

SwiftRelationError

E-Series: Enhanced/Field Relation Validation Error

Enums

ParseError

Main error type for parsing operations

ParseResult

Result type for parse operations with error collection

SwiftValidationError

Comprehensive SWIFT validation error system based on SWIFT Standard Error Codes

ValidationError

Validation error for field-level validation

Type Aliases

Result

Result type alias for the library

SwiftValidationResult

Enhanced result type for SWIFT validation operations