qubit-config 0.11.1

Powerful type-safe configuration management with multi-value properties, variable substitution, and rich data type support
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

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/
//! # Base Implementation of Configurable Objects
//!
//! Provides a base structure that implements the `Configurable` trait.
//!

use super::{Config, Configurable};

/// Base implementation of configurable objects
///
/// This is a base structure that implements the `Configurable` trait and can be
/// used as a base for other structures that need configuration.
///
/// # Features
///
/// - Automatically implements the `Configurable` trait
/// - Provides configuration change callback mechanism
/// - Can be inherited and extended
///
/// # Examples
///
/// ```rust
/// use qubit_config::{Config, Configurable, Configured};
///
/// let mut configured = Configured::new();
/// configured.config_mut().set("port", 8080).unwrap();
/// let port: i32 = configured.config().get("port").unwrap();
/// assert_eq!(port, 8080);
/// ```
///
/// ```rust
/// // Or compose it into other structures
/// use qubit_config::{Config, Configurable, Configured};
/// struct Server {
///     configured: Configured,
///     // Other fields...
/// }
///
/// impl Server {
///     fn new() -> Self {
///         Self {
///             configured: Configured::new(),
///         }
///     }
///
///     fn config(&self) -> &Config {
///         self.configured.config()
///     }
///
///     fn config_mut(&mut self) -> &mut Config {
///         self.configured.config_mut()
///     }
/// }
/// ```
///
///
#[derive(Debug, Clone, PartialEq)]
pub struct Configured {
    /// Configuration object
    config: Config,
}

impl Configured {
    /// Creates a new configurable object
    ///
    /// # Returns
    ///
    /// Returns a new configurable object instance
    ///
    /// # Examples
    ///
    /// ```rust
    /// use qubit_config::{Configurable, Configured};
    ///
    /// let configured = Configured::new();
    /// assert!(configured.config().is_empty());
    /// ```
    #[inline]
    pub fn new() -> Self {
        Self {
            config: Config::new(),
        }
    }

    /// Creates a configurable object with the specified configuration
    ///
    /// # Parameters
    ///
    /// * `config` - Configuration object
    ///
    /// # Returns
    ///
    /// Returns a new configurable object instance
    ///
    /// # Examples
    ///
    /// ```rust
    /// use qubit_config::{Config, Configurable, Configured};
    ///
    /// let mut configured = Configured::with_config(Config::new());
    /// assert!(configured.config().is_empty());
    /// ```
    #[inline]
    pub fn with_config(config: Config) -> Self {
        Self { config }
    }
}

impl Configurable for Configured {
    #[inline]
    fn config(&self) -> &Config {
        &self.config
    }

    #[inline]
    fn config_mut(&mut self) -> &mut Config {
        &mut self.config
    }

    fn set_config(&mut self, config: Config) {
        self.config = config;
        self.on_config_changed();
    }

    #[inline]
    fn on_config_changed(&mut self) {
        // Default implementation is empty, subclasses can override
    }
}

impl Default for Configured {
    #[inline]
    fn default() -> Self {
        Self::new()
    }
}