config-ro 0.1.0

A thread-safe configuration manager for Rust applications that loads and caches JSON configuration files.
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

# Config Manager

[![Crates.io](https://img.shields.io/crates/v/config-ro)](https://crates.io/crates/config-ro)
[![Documentation](https://docs.rs/config-ro/badge.svg)](https://docs.rs/config-ro)
[![License](https://img.shields.io/crates/l/config-ro)](LICENSE-MIT)


A thread-safe configuration manager for Rust applications that loads and caches JSON configuration files.

## Features

- **Thread-safe caching**: Configurations are loaded once and cached for subsequent accesses
- **Concurrent access**: Safe for use across multiple threads with `RwLock` synchronization
- **Type-safe retrieval**: Supports deserializing configuration values into Rust types
- **JSON-based**: Configuration files are stored in JSON format

## Usage

### Basic Usage

1. Create a JSON configuration file in the `configs/` directory (e.g., `configs/app.json`):

```json
{
  "db_host": "localhost",
  "db_port": 5432,
  "debug_mode": true
}
```

2. Use the configuration in your Rust code:

```rust
use config_ro::Config;

let config = Config::new("app");
let db_host: String = config.get("db_host").unwrap();
let db_port: u16 = config.get("db_port").unwrap();
let debug_mode: bool = config.get("debug_mode").unwrap();
```

### Advanced Usage

```rust
// Create multiple configuration instances
let app_config = Config::new("app");
let db_config = Config::new("database");

// Get nested values (if your JSON has nested objects)
let nested_value = app_config.get::<String>("nested.key").unwrap();

// Handle missing values
match app_config.get::<String>("optional_key") {
    Some(value) => println!("Got value: {}", value),
    None => println!("Using default value"),
}
```

## API Reference

### `Config::new(name: &str) -> Config`

Creates a new configuration instance for the given name. The configuration is loaded from `configs/{name}.json` if not already cached.

### `config.get<T: DeserializeOwned>(key: &str) -> Option<T>`

Retrieves a configuration value by key, attempting to deserialize it into type `T`.

## Thread Safety

The configuration manager is designed for concurrent access:

- Configuration loading is synchronized
- Multiple threads can read configurations simultaneously
- Configuration updates are exclusive (blocking other accesses during write)


## Example Configuration File

```json
{
  "app_name": "My Application",
  "version": "1.0.0",
  "database": {
    "host": "db.example.com",
    "port": 5432,
    "credentials": {
      "username": "admin",
      "password": "secret"
    }
  },
  "features": {
    "experimental": true,
    "logging": "verbose"
  }
}
```

## Contributing

Contributions are welcome! Please open an issue or submit a PR for:
- New features
- Performance improvements
- Bug fixes


## License

Dual-licensed under [MIT](LICENSE-MIT) or [Apache 2.0](LICENSE-APACHE) at your option.