daachorse 2.1.1

Daachorse: Double-Array Aho-Corasick
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

//! Definition of errors.

use core::result;

use alloc::fmt;
use alloc::string::String;

/// Errors in daachorse.
#[derive(Debug)]
pub enum DaachorseError {
    /// Contains [`InvalidArgumentError`].
    InvalidArgument(InvalidArgumentError),

    /// Contains [`DuplicatePatternError`].
    DuplicatePattern(DuplicatePatternError),

    /// Contains [`AutomatonScaleError`].
    AutomatonScale(AutomatonScaleError),

    /// Contains [`InvalidConversionError`].
    InvalidConversion(InvalidConversionError),

    /// Contains [`InvalidAutomatonError`].
    InvalidAutomaton(InvalidAutomatonError),
}

impl fmt::Display for DaachorseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::InvalidArgument(e) => e.fmt(f),
            Self::DuplicatePattern(e) => e.fmt(f),
            Self::AutomatonScale(e) => e.fmt(f),
            Self::InvalidConversion(e) => e.fmt(f),
            Self::InvalidAutomaton(e) => e.fmt(f),
        }
    }
}

impl DaachorseError {
    pub(crate) const fn invalid_argument(arg: &'static str, op: &'static str, value: u32) -> Self {
        Self::InvalidArgument(InvalidArgumentError { arg, op, value })
    }

    pub(crate) const fn duplicate_pattern(pattern: String) -> Self {
        Self::DuplicatePattern(DuplicatePatternError { pattern })
    }

    pub(crate) const fn automaton_scale(arg: &'static str, max_value: u32) -> Self {
        Self::AutomatonScale(AutomatonScaleError { arg, max_value })
    }

    pub(crate) const fn invalid_conversion(arg: &'static str, target: &'static str) -> Self {
        Self::InvalidConversion(InvalidConversionError { arg, target })
    }

    pub(crate) const fn invalid_automaton() -> Self {
        Self::InvalidAutomaton(InvalidAutomatonError)
    }
}

/// Error used when the argument is invalid.
#[derive(Debug)]
pub struct InvalidArgumentError {
    /// Name of the argument.
    arg: &'static str,

    /// Condition operator.
    op: &'static str,

    /// Condition value.
    value: u32,
}

impl fmt::Display for InvalidArgumentError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "InvalidArgumentError: {} must be {} {}",
            self.arg, self.op, self.value
        )
    }
}

/// Error used when some patterns are duplicated.
#[derive(Debug)]
pub struct DuplicatePatternError {
    /// A duplicate pattern.
    pattern: String,
}

impl fmt::Display for DuplicatePatternError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DuplicatePatternError: {}", self.pattern)
    }
}

/// Error used when the scale of the automaton exceeds the expected one.
#[derive(Debug)]
pub struct AutomatonScaleError {
    /// Name of the argument.
    arg: &'static str,

    /// The maximum value (inclusive).
    max_value: u32,
}

impl fmt::Display for AutomatonScaleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "AutomatonScaleError: {} must be <= {}",
            self.arg, self.max_value
        )
    }
}

/// Error used when the conversion fails.
#[derive(Debug)]
pub struct InvalidConversionError {
    /// Name of the argument.
    arg: &'static str,

    /// Target type.
    target: &'static str,
}

impl fmt::Display for InvalidConversionError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "InvalidConversionError: {} cannot be converted to {}",
            self.arg, self.target
        )
    }
}

/// Error used when the deserialization failed.
#[derive(Debug)]
pub struct InvalidAutomatonError;

impl fmt::Display for InvalidAutomatonError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "InvalidAutomatonError: invalid serialized automaton")
    }
}

/// A specialized Result type for Daachorse.
pub type Result<T, E = DaachorseError> = result::Result<T, E>;