system-analysis 0.2.1

A comprehensive Rust library for analyzing system capabilities, workload requirements, and optimal resource allocation
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

//! Error types for the system analysis crate.

use thiserror::Error;

/// The main error type for the system analysis crate.
#[derive(Error, Debug)]
pub enum SystemAnalysisError {
    /// Error occurred while analyzing system hardware
    #[error("System analysis failed: {message}")]
    AnalysisError { message: String },

    /// Error occurred while accessing system information
    #[error("System information access failed: {source}")]
    SystemInfoError { 
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>
    },

    /// Error occurred while calculating compatibility
    #[error("Compatibility calculation failed: {message}")]
    CompatibilityError { message: String },

    /// Invalid workload requirements
    #[error("Invalid workload requirements: {message}")]
    InvalidWorkload { message: String },

    /// Resource requirement not found
    #[error("Resource requirement not found: {resource_type}")]
    ResourceNotFound { resource_type: String },

    /// Configuration error
    #[error("Configuration error: {message}")]
    ConfigError { message: String },

    /// I/O error
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

    /// Serialization error
    #[error("Serialization error: {0}")]
    SerializationError(#[from] serde_json::Error),

    /// GPU detection error (when feature is enabled)
    #[cfg(feature = "gpu-detection")]
    #[error("GPU detection error: {message}")]
    GpuError { message: String },
}

impl SystemAnalysisError {
    /// Create a new analysis error
    pub fn analysis(message: impl Into<String>) -> Self {
        Self::AnalysisError {
            message: message.into(),
        }
    }

    /// Create a new system info error
    pub fn system_info(message: impl Into<String>) -> Self {
        Self::SystemInfoError {
            source: Box::new(std::io::Error::other(
                message.into()
            )),
        }
    }

    /// Create a new compatibility error
    pub fn compatibility(message: impl Into<String>) -> Self {
        Self::CompatibilityError {
            message: message.into(),
        }
    }

    /// Create a new invalid workload error
    pub fn invalid_workload(message: impl Into<String>) -> Self {
        Self::InvalidWorkload {
            message: message.into(),
        }
    }

    /// Create a new resource not found error
    pub fn resource_not_found(resource_type: impl Into<String>) -> Self {
        Self::ResourceNotFound {
            resource_type: resource_type.into(),
        }
    }

    /// Create a new config error
    pub fn config(message: impl Into<String>) -> Self {
        Self::ConfigError {
            message: message.into(),
        }
    }

    #[cfg(feature = "gpu-detection")]
    /// Create a new GPU error
    pub fn gpu(message: impl Into<String>) -> Self {
        Self::GpuError {
            message: message.into(),
        }
    }
}

/// Convenience type alias for Results with SystemAnalysisError
pub type Result<T> = std::result::Result<T, SystemAnalysisError>;