csd-rs 0.1.4

Canonical Signed Digit Conversion in Rust
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

//! Logging utilities for csd-rs applications.
//!
//! This module provides optional logging capabilities that are only available
//! when the `std` feature is enabled. This maintains `#![no_std]` compatibility
//! while allowing applications to use logging for debugging and diagnostics.
//!
//! # Usage
//!
//! ```rust,ignore
//! use csd::logging::init_logger;
//!
//! init_logger();
//! log::info!("Application started");
//!
//! // Use csd functions
//! let csd = csd::to_csd(28.5, 2);
//! log::debug!("CSD representation: {}", csd);
//! ```
//!
//! Set the `RUST_LOG` environment variable to control logging levels:
//!
//! ```bash
//! RUST_LOG=debug cargo run --features std
//! RUST_LOG=warn cargo run --features std
//! ```

use log::LevelFilter;

/// Initialize the logger with the default filter.
///
/// Reads the log level from the `RUST_LOG` environment variable.
/// If not set, defaults to `info` level.
///
/// # Panics
///
/// Panics if the logger has already been initialized.
#[cfg(feature = "std")]
pub fn init_logger() {
    env_logger::Builder::from_default_env()
        .filter_level(LevelFilter::Info)
        .init();
}

/// Initialize the logger with a custom filter string.
///
/// The filter string follows the `env_logger` format:
/// - `error`, `warn`, `info`, `debug`, `trace` for specific levels
/// - `crate_name=level` for module-specific filtering
///
/// # Panics
///
/// Panics if the logger has already been initialized.
///
/// # Example
///
/// ```rust,ignore
/// use csd::logging::init_logger_with_filter;
///
/// init_logger_with_filter("debug");
/// log::debug!("Debug message"); // This will be logged
/// ```
#[cfg(feature = "std")]
pub fn init_logger_with_filter(filter: &str) {
    env_logger::Builder::from_default_env()
        .filter_level(filter.parse().unwrap_or(LevelFilter::Info))
        .init();
}

/// Try to initialize the logger (non-panicking version).
///
/// Returns `Ok(())` if initialization succeeded, or `Err` if the logger
/// has already been initialized.
///
/// # Example
///
/// ```rust,ignore
/// use csd::logging::try_init_logger;
///
/// if try_init_logger().is_ok() {
///     log::info!("Logger initialized");
/// }
/// ```
#[cfg(feature = "std")]
pub fn try_init_logger() -> Result<(), log::SetLoggerError> {
    env_logger::Builder::from_default_env()
        .filter_level(LevelFilter::Info)
        .try_init()
}

/// Try to initialize the logger with a custom filter (non-panicking version).
///
/// Returns `Ok(())` if initialization succeeded, or `Err` if the logger
/// has already been initialized.
///
/// # Example
///
/// ```rust,ignore
/// use csd::logging::try_init_logger_with_filter;
///
/// if try_init_logger_with_filter("csd=debug").is_ok() {
///     log::debug!("Debug messages enabled");
/// }
/// ```
#[cfg(feature = "std")]
pub fn try_init_logger_with_filter(filter: &str) -> Result<(), log::SetLoggerError> {
    env_logger::Builder::from_default_env()
        .filter_level(filter.parse().unwrap_or(LevelFilter::Info))
        .try_init()
}

/// Check if the logger has been initialized.
///
/// Returns `true` if logging is active, `false` otherwise.
///
/// # Example
///
/// ```rust,ignore
/// use csd::logging::{try_init_logger, is_logger_initialized};
///
/// try_init_logger();
/// if is_logger_initialized() {
///     log::info!("Logging is active");
/// }
/// ```
#[cfg(feature = "std")]
pub fn is_logger_initialized() -> bool {
    log::max_level() != LevelFilter::Off
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_try_init_logger() {
        // Try to initialize - may fail if already initialized in test runner
        let _ = try_init_logger();
    }

    #[test]
    fn test_try_init_logger_with_filter() {
        // Try to initialize with a custom filter
        let _ = try_init_logger_with_filter("info");
    }

    #[test]
    fn test_is_logger_initialized() {
        // Just verify the function can be called
        let _ = is_logger_initialized();
    }
}