stuck 0.4.1

Multi-threading scheduled task facility building on cooperative stackful coroutine
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

use std::any::{Any, TypeId};
use std::{fmt, panic};

use static_assertions::assert_impl_all;

pub(crate) enum PanicError {
    Static(&'static str),
    Unwind(Box<dyn Any + Send + 'static>),
}

impl PanicError {
    pub fn resume(self) -> ! {
        match self {
            PanicError::Static(s) => panic::panic_any(s),
            PanicError::Unwind(err) => panic::resume_unwind(err),
        }
    }

    fn into_boxed(self) -> Box<dyn Any + Send + 'static> {
        match self {
            PanicError::Unwind(boxed) => boxed,
            PanicError::Static(str) => Box::new(str),
        }
    }

    fn as_str(&self) -> Result<&str, TypeId> {
        match self {
            PanicError::Static(s) => Ok(s),
            PanicError::Unwind(boxed) => {
                let panicked = boxed.as_ref();
                if let Some(s) = panicked.downcast_ref::<&str>() {
                    Ok(s)
                } else if let Some(s) = panicked.downcast_ref::<String>() {
                    Ok(s.as_str())
                } else {
                    Err(panicked.type_id())
                }
            },
        }
    }
}

/// Wraps panic as [std::error::Error].
pub struct JoinError {
    err: PanicError,
}

assert_impl_all!(JoinError: Send);

impl JoinError {
    pub(crate) fn new(err: PanicError) -> Self {
        JoinError { err }
    }

    /// Converts this error to panicked object.
    pub fn into_panic(self) -> Box<dyn Any + Send + 'static> {
        self.err.into_boxed()
    }
}

impl From<PanicError> for JoinError {
    fn from(err: PanicError) -> Self {
        JoinError { err }
    }
}

impl fmt::Debug for JoinError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.err.as_str() {
            Ok(s) => write!(f, "JoinError::Panic({})", s),
            Err(type_id) => write!(f, "JoinError::Panic({:?})", type_id),
        }
    }
}

impl fmt::Display for JoinError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "panic({})", self.err.as_str().unwrap_or(".."))
    }
}

impl std::error::Error for JoinError {}