cds 0.10.0

Collection of Optimized Data Structures
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

//! `ArrayString` error types.

use core::{
    clone::Clone,
    cmp::{Eq, Ord, PartialEq, PartialOrd},
    fmt::{Debug, Display, Formatter},
    hash::Hash,
    marker::Copy,
};

// ---------------------------------------------------------------------------

/// An error returned when there is no enough spare capacity.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct InsufficientCapacityError;

impl Display for InsufficientCapacityError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(f, "arraystring insufficient capacity")
    }
}

#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for InsufficientCapacityError {}

// ---------------------------------------------------------------------------

/// An error returned from [`try_insert`] and [`try_insert_str`] methods.
///
/// [`try_insert`]: super::ArrayString::try_insert
/// [`try_insert_str`]: super::ArrayString::try_insert_str
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum InsertError {
    /// Index is out of bounds, or doesn't lie on a character boundary.
    InvalidIndex,

    /// There is no spare capacity to accommodate a new element.
    InsufficientCapacity,
}

impl Display for InsertError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        let s = match *self {
            InsertError::InvalidIndex => "invalid index",
            InsertError::InsufficientCapacity => "insufficient capacity",
        };
        write!(f, "arraystring insert error: {}", s)
    }
}

#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for InsertError {}

// ---------------------------------------------------------------------------

/// Index is invalid.
///
/// This error is returned when an index is out of bounds, or doesn't lie on a character boundary.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct IndexError;

impl core::fmt::Display for IndexError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(
            f,
            "arraystring index error: index is out of bounds or doesn't lie on character boundary"
        )
    }
}

#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for IndexError {}

#[cfg(all(test, feature = "std"))]
mod testing {
    use super::*;

    #[test]
    fn insufficient_capacity_error_display() {
        let e = InsufficientCapacityError {};
        let s = format!("{}", e);
        assert_eq!(s, "arraystring insufficient capacity");
    }

    #[test]
    fn insert_error_display() {
        let e = InsertError::InvalidIndex;
        let s = format!("{}", e);
        assert_eq!(s, "arraystring insert error: invalid index");

        let e = InsertError::InsufficientCapacity;
        let s = format!("{}", e);
        assert_eq!(s, "arraystring insert error: insufficient capacity");
    }

    #[test]
    fn index_error() {
        let e = IndexError {};
        let s = format!("{}", e);
        assert_eq!(
            s,
            "arraystring index error: index is out of bounds or doesn't lie on character boundary"
        );
    }
}