avx-error 0.2.0

AVL Platform error handling - replacement for anyhow/thiserror
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

# avx-error


**Unified error handling system for the avx ecosystem.**

[![Crates.io](https://img.shields.io/crates/v/avx-error.svg)](https://crates.io/crates/avx-error)
[![Documentation](https://docs.rs/avx-error/badge.svg)](https://docs.rs/avx-error)
[![License](https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue.svg)](https://github.com/avilaops/arxis/blob/main/LICENSE-MIT)

## Features


## Features


- **Zero Dependencies** - Pure Rust (except derive macros)
- **Rich Error Context** - Chain context information
- **Error Categories** - 15+ predefined error kinds
- **Derive Macros** - Automatic trait implementations
- **no_std Compatible** - Works in embedded environments
- **Backtrace Support** - Optional std backtrace integration
- **Type-Safe** - Compile-time error handling

## Error Kinds


- `InvalidInput` - Bad input data
- `NotFound` - Resource missing
- `PermissionDenied` - Access denied
- `ConnectionFailed` - Network error
- `Timeout` - Operation timeout
- `DataCorruption` - Corrupted data
- `ConfigError` - Configuration issue
- `AuthenticationFailed` - Auth failure
- `AuthorizationFailed` - Permission failure
- `AlreadyExists` - Duplicate resource
- `ResourceExhausted` - Out of resources
- `Cancelled` - Operation cancelled
- `Internal` - Internal error
- `NotImplemented` - Feature not implemented
- `Unavailable` - Service unavailable
- `Unknown` - Unknown error

## Examples


### Basic Usage


```rust
use avx_error::{Error, ErrorKind, Result};

fn load_config(path: &str) -> Result<Config> {
    if path.is_empty() {
        return Err(Error::new(
            ErrorKind::InvalidInput,
            "Path cannot be empty"
        ));
    }

    // ...
    Ok(Config::default())
}
```

### Error Context


```rust
use avx_error::{Result, ResultExt};

fn parse_file(path: &str) -> Result<Data> {
    read_file(path)
        .context("Failed to read file")?;

    parse_json(contents)
        .with_context(|| format!("Failed to parse {}", path))?;

    Ok(data)
}
```

### Custom Errors with Derive


```rust
use avx_error::Error as avxError;

#[derive(Debug, avxError)]

enum MyError {
    IoError(std::io::Error),
    ParseError(String),
    Custom { code: i32, message: String },
}
```

### Error Matching


```rust
use avx_error::{Error, ErrorKind};

match error.kind() {
    ErrorKind::NotFound => {
        // Handle missing resource
    },
    ErrorKind::PermissionDenied => {
        // Handle access denied
    },
    _ => {
        // Handle other errors
    }
}
```

## Installation


Add to your `Cargo.toml`:

```toml
[dependencies]
avx-error = "0.3.0"
```

With derive macros:

```toml
[dependencies]
avx-error = { version = "0.3.0", features = ["derive"] }
```

For `no_std` environments:

```toml
[dependencies]
avx-error = { version = "0.3.0", default-features = false }
```

## Integration


All avx crates use `avx-error` as the foundation:

```rust
// In avx-db
pub type Result<T> = avx_error::Result<T>;

// In avx-http
impl From<HttpError> for avx_error::Error {
    fn from(err: HttpError) -> Self {
        // Convert to avx_error::Error
    }
}
```

## License


Licensed under either of:

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT license ([LICENSE-MIT](LICENSE-MIT))

at your option.