stackvec 0.2.1

A crate to use stack-allocated Vectors (performance and/or no-std)
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

//! The crate's [errors][`::std::error::Error`].

use super::*;

use ::std::error::Error;

/// Error returned by [`StackVec::try_push`][`::stackvec::StackVec::try_push]
/// method.
#[derive(Clone, Copy, Debug)]
pub struct OutOfCapacityError<T>(pub T);

impl<T> fmt::Display for OutOfCapacityError<T> {
    fn fmt (
        self: &Self,
        stream: &mut fmt::Formatter,
    ) -> fmt::Result
    {
        fmt::Display::fmt(
            "Attempted to add an element to a full StackVec",
            stream
        )
    }
}

impl<T: fmt::Debug> ::std::error::Error for OutOfCapacityError<T> {
    fn description (
        self: &Self,
    ) -> &str
    {
        "Attempted to add an element to a full StackVec"
    }
}


/// Error returned by
/// [`StackVec::try_into`][`::stackvec::traits::TryInto::try_into]
/// method.
#[derive(Clone, Copy, Debug)]
pub struct IncompleteArrayError;

impl fmt::Display for IncompleteArrayError {
    fn fmt (
        self: &Self,
        stream: &mut fmt::Formatter,
    ) -> fmt::Result
    {
        fmt::Display::fmt(self.description(), stream)
    }
}

impl ::std::error::Error for IncompleteArrayError {
    fn description (
        self: &Self,
    ) -> &str
    {
        concat!(
            "Cannot build an incomplete array.",
        )
    }
}

/// Error used generic-wise to extend fake fallible operations from unfallible
/// ones.
#[derive(Debug)]
pub enum UnreachableError {}

impl UnreachableError {
    /// This error is unconstructible and can thus safely be seen as anything.
    pub fn unreachable (&self) -> ! { match *self {} }
}

impl fmt::Display for UnreachableError {
    fn fmt (&self, _: &mut fmt::Formatter) -> fmt::Result {
        self.unreachable()
    }
}

impl ::std::error::Error for UnreachableError {
    fn description (&self) -> &str {
        self.unreachable()
    }
}