algos 0.6.8

A collection of algorithms 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

use std::{collections::TryReserveError, fmt::Display};
use thiserror::Error;

/// Errors that can occur during algorithm operations
#[derive(Debug, Error)]
pub enum Error {
    /// The pattern is empty
    #[error("Pattern cannot be empty")]
    EmptyPattern,

    /// The pattern is longer than the text
    #[error("Pattern length {pattern_len} is longer than text length {text_len}")]
    PatternTooLong { pattern_len: usize, text_len: usize },

    /// The recursion depth exceeded the maximum
    #[error("Recursion depth {depth} exceeded maximum allowed depth of {max_depth}")]
    RecursionLimitExceeded { depth: usize, max_depth: usize },

    /// Failed to allocate memory
    #[error("Failed to allocate memory: {reason}")]
    AllocationFailed {
        reason: String,
        #[source]
        source: Option<TryReserveError>,
    },

    /// A parallel execution task failed
    #[error("Parallel execution failed: {reason}")]
    ParallelExecutionFailed { reason: String },

    /// The input was too large
    #[error("Input length {length} exceeds maximum supported length of {max_length}")]
    InputTooLarge { length: usize, max_length: usize },

    /// Index out of bounds
    #[error("Index out of bounds: {0}")]
    IndexOutOfBounds(String),

    /// Operation not supported
    #[error("Operation not supported: {0}")]
    Unsupported(String),

    /// Invalid input
    #[error("Invalid input: {0}")]
    InvalidInput(String),

    /// Vertex not found
    #[error("vertex not found")]
    VertexNotFound,

    /// A negative cycle was detected in the graph
    #[error("negative cycle detected in graph")]
    NegativeCycle,

    /// Invalid vertex
    #[error("invalid vertex")]
    InvalidVertex,

    /// No Eulerian path exists in the graph
    #[error("no Eulerian path exists")]
    NoEulerianPath,
}

/// Result type for algorithm operations
pub type Result<T> = std::result::Result<T, Error>;

/// Common error types for algorithm operations.
/// Note: Many modules define their own specific error types (e.g., HeapSortError)
/// for more precise error handling. These common errors are provided for
/// standardization across modules where appropriate.
impl Error {
    pub(crate) fn empty_pattern() -> Self {
        Self::EmptyPattern
    }

    pub(crate) fn pattern_too_long(pattern_len: usize, text_len: usize) -> Self {
        Self::PatternTooLong {
            pattern_len,
            text_len,
        }
    }

    pub(crate) fn recursion_limit_exceeded(depth: usize, max_depth: usize) -> Self {
        Self::RecursionLimitExceeded { depth, max_depth }
    }

    pub(crate) fn input_too_large(length: usize, max_length: usize) -> Self {
        Self::InputTooLarge { length, max_length }
    }

    pub(crate) fn invalid_input(msg: impl Display) -> Self {
        Self::InvalidInput(msg.to_string())
    }
}

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

    #[test]
    fn test_error_messages() {
        let err = Error::empty_pattern();
        assert_eq!(err.to_string(), "Pattern cannot be empty");

        let err = Error::pattern_too_long(10, 5);
        assert_eq!(
            err.to_string(),
            "Pattern length 10 is longer than text length 5"
        );

        let err = Error::recursion_limit_exceeded(100, 50);
        assert_eq!(
            err.to_string(),
            "Recursion depth 100 exceeded maximum allowed depth of 50"
        );

        let err = Error::input_too_large(1_000_000, 100_000);
        assert_eq!(
            err.to_string(),
            "Input length 1000000 exceeds maximum supported length of 100000"
        );

        let err = Error::invalid_input("invalid UTF-8");
        assert_eq!(err.to_string(), "Invalid input: invalid UTF-8");
    }

    #[test]
    fn test_error_variants() {
        // Test that error variants exist but are handled by specific modules
        let err = Error::AllocationFailed {
            reason: "test".to_string(),
            source: None,
        };
        assert!(err.to_string().contains("Failed to allocate memory"));

        let err = Error::ParallelExecutionFailed {
            reason: "test".to_string(),
        };
        assert!(err.to_string().contains("Parallel execution failed"));

        let err = Error::IndexOutOfBounds("test".to_string());
        assert!(err.to_string().contains("Index out of bounds"));

        let err = Error::Unsupported("test".to_string());
        assert!(err.to_string().contains("Operation not supported"));
    }
}