evdevil 0.4.1

Bindings to Linux' input device APIs: evdev and uinput
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

/// ffi_enum! {}
macro_rules! ffi_enum {
    (
        $( #[$attrs:meta] )*
        $v:vis enum $name:ident: $native:ty {
            $(
                $( #[$variant_attrs:meta] )*
                $variant:ident = $value:expr
            ),+
            $(,)?
        }
    ) => {
        $( #[$attrs] )*
        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        #[repr(transparent)]
        $v struct $name(pub(crate) $native);

        impl $name {
            $(
                $( #[$variant_attrs] )*
                $v const $variant: Self = Self($value);
            )+

            #[allow(dead_code, unreachable_patterns)]
            pub(crate) fn variant_name(&self) -> Option<&'static str> {
                match self {
                    $(
                        &Self::$variant => Some(stringify!($variant)),
                    )*
                    _ => None,
                }
            }

            #[allow(dead_code)]
            pub(crate) fn from_variant_name(name: &str) -> Option<Self> {
                match name {
                    $(
                        stringify!($variant) => Some(Self::$variant),
                    )*
                    _ => None,
                }
            }

            /// Creates a new value from its raw representation.
            #[inline]
            $v const fn from_raw(raw: $native) -> Self {
                Self(raw)
            }

            /// Returns the raw value wrapped by `self`.
            #[inline]
            $v const fn raw(self) -> $native {
                self.0
            }
        }
    };
}

macro_rules! bitvalue {
    ($type:ty) => {
        impl $crate::bits::BitValueImpl for $type {
            type __PrivateArray = [$crate::bits::Word;
                (Self::MAX.0 as usize + 1).div_ceil($crate::bits::Word::BITS as usize)];
            const __PRIVATE_ZERO: Self::__PrivateArray =
                [0; (Self::MAX.0 as usize + 1).div_ceil($crate::bits::Word::BITS as usize)];

            #[inline]
            fn from_index(index: usize) -> Self {
                Self(index as _)
            }
            #[inline]
            fn into_index(self) -> usize {
                self.0 as _
            }
        }
        impl $crate::bits::BitValue for $type {
            const MAX: Self = <Self>::MAX;
        }
    };
}