breadx 3.1.0

Pure-Rust X11 connection implementation with a focus on adaptability
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

//               Copyright John Nunley, 2022.
// Distributed under the Boost Software License, Version 1.0.
//       (See accompanying file LICENSE or copy at
//         https://www.boost.org/LICENSE_1_0.txt)

cfg_async! {
    mod unblock;
    pub(crate) use unblock::Unblock;
}

cfg_test! {
    mod test;
    #[allow(unused_imports)]
    pub(crate) use test::setup_tracing;
}

use crate::{display::AsyncStatus, Result};
use ahash::RandomState;
use hashbrown::HashMap as HbHashMap;

/// A hash map that uses the `ahash` algorithm.
///
/// It is marginally more vulnerable to denial of service attacks than
/// default hashmaps, but it is also much faster.
pub(crate) type HashMap<K, V> = HbHashMap<K, V, RandomState>;

pub(crate) trait ResultExt<T>: Sized {
    fn trace(self, f: impl FnOnce(&T)) -> Self;

    fn acopied<'a, R: 'a + Copy>(self) -> Result<AsyncStatus<R>>
    where
        T: Into<AsyncStatus<&'a R>>;
}

impl<T> ResultExt<T> for Result<T> {
    fn trace(self, f: impl FnOnce(&T)) -> Self {
        if let Ok(ref t) = self {
            f(t);
        }

        self
    }

    fn acopied<'a, R: 'a + Copy>(self) -> Result<AsyncStatus<R>>
    where
        T: Into<AsyncStatus<&'a R>>,
    {
        match self {
            Ok(t) => Ok(t.into().copied()),
            Err(e) => Err(e),
        }
    }
}