radixmap 0.2.4

Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
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

//! Common defines
pub(crate) use std::hash::Hash;
pub(crate) use std::hash::Hasher;
pub(crate) use std::fmt::Debug;
pub(crate) use std::ops::Index;
pub(crate) use std::ops::IndexMut;
pub(crate) use std::fmt::Formatter;
pub(crate) use std::iter::Peekable;
pub(crate) use std::str::Utf8Error;
pub(crate) use std::collections::VecDeque;

pub(crate) use bytes::Bytes;
pub(crate) use regex::Regex;
pub(crate) use vec_map::VecMap;
pub(crate) use thiserror::Error;
pub(crate) use indexmap::IndexMap;

/// Error Codes
#[allow(missing_docs)]
#[derive(Debug, Error)]
pub enum RadixError {
    #[error("path is empty")]
    PathEmpty,

    #[error("path not found")]
    PathNotFound,

    #[error("{0}")]
    PathInvalid(#[from] Utf8Error),

    #[error("{0}")]
    PathMalformed(&'static str),

    #[error("rule can't be split")]
    RuleIndivisible,

    #[error("{0}")]
    GlobInvalid(#[from] glob::PatternError),

    #[error("{0}")]
    RegexInvalid(#[from] regex::Error),
}

/// Custom Result
pub type RadixResult<T> = Result<T, RadixError>;

/// Macros to create RadixMap or RadixSet
///
/// # Examples
///
/// ```
/// #[macro_use] extern crate radixmap;
///
/// let map = radix!{
///     "/" => "/",
///     "/api" => "api",
///     "/api/v1" => "v1",
///     "/api/v1/user" => "user1",
///     "/api/v2" => "v2",
///     "/api/v2/user" => "user2",
/// };
///
/// assert_eq!(map.get(b"/"), Some(&"/"));
/// assert_eq!(map.get(b"/api"), Some(&"api"));
/// assert_eq!(map.get(b"/api/v1"), Some(&"v1"));
/// assert_eq!(map.get(b"/api/v1/user"), Some(&"user1"));
/// assert_eq!(map.get(b"/api/v2"), Some(&"v2"));
/// assert_eq!(map.get(b"/api/v2/user"), Some(&"user2"));
/// assert_eq!(map.get(b"/api/v3"), None);
/// assert_eq!(map.get(b"/api/v3/user"), None);
///
/// let set = radix!{
///     "/",
///     "/api",
///     "/api/v1",
///     "/api/v1/user",
///     "/api/v2",
///     "/api/v2/user",
/// };
///
/// assert_eq!(set.contains(b"/"), true);
/// assert_eq!(set.contains(b"/api"), true);
/// assert_eq!(set.contains(b"/api/v1"), true);
/// assert_eq!(set.contains(b"/api/v1/user"), true);
/// assert_eq!(set.contains(b"/api/v2"), true);
/// assert_eq!(set.contains(b"/api/v2/user"), true);
/// assert_eq!(set.contains(b"/api/v3"), false);
/// assert_eq!(set.contains(b"/api/v3/user"), false);
/// ```
#[macro_export]
macro_rules! radix {
    ($($path:expr => $data:expr),+ $(,)?) => {{
        let mut map = $crate::RadixMap::default();
        $(map.insert($path, $data);)+
        map
    }};

    ($($path:expr),+ $(,)?) => {{
        let mut set = $crate::RadixSet::default();
        $(set.insert($path);)+
        set
    }};
}