hyprland 0.3.13

A unoffical rust wrapper for hyprland's IPC
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
109
110
111
112
113
114
115
116
117
118
119
120
121

macro_rules! impl_on {
    ($name:ident) => {
        #[async_trait]
        impl HyprData for $name {
            fn get() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd(DataCommands::$name);
                let deserialized: $name = serde_json::from_str(&data)?;
                Ok(deserialized)
            }
            async fn get_async() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd_async(DataCommands::$name).await;
                let deserialized: $name = serde_json::from_str(&data)?;
                Ok(deserialized)
            }
        }
    };
}

macro_rules! create_data_struct {
    (vec $name:ident,$kind:path,$held:ty,$c:literal) => {
        #[doc = $c]
        #[derive(Debug, Clone)]
        pub struct $name {
            pos: usize,
            held: Vec<$held>,
        }

        impl $name {
            /// Get the iterator from the `held` Vec without having to move/clone data
            pub fn iter(&self) -> impl Iterator<Item = &$held> {
                self.held.iter()
            }
        }

        #[async_trait]
        impl HyprData for $name {
            fn get() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd($kind);
                let deserialized: Vec<$held> = serde_json::from_str(&data)?;
                Ok(Self {
                    held: deserialized,
                    pos: 0,
                })
            }
            async fn get_async() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd_async($kind).await;
                let deserialized: Vec<$held> = serde_json::from_str(&data)?;
                Ok(Self {
                    held: deserialized,
                    pos: 0,
                })
            }
        }

        impl Iterator for $name {
            type Item = $held;

            fn next(&mut self) -> Option<Self::Item> {
                let out = self.held.get(self.pos);
                self.pos += 1;
                match out {
                    Some(v) => Some(v.clone()),
                    None => None,
                }
            }
        }

        impl HyprDataVec<$held> for $name {
            fn to_vec(self) -> Vec<$held> {
                self.held
            }
        }
    };

    (sing $name:ident,$kind:path,$held:ty,$c:literal $(, iter_item = $it_it:ty)*) => {
        #[doc = $c]
        #[derive(Debug)]
        pub struct $name($held);

        impl $name {
            $(
                /// Get the iterator from the `held` Vec without having to move/clone data
                pub fn iter(&self) -> impl Iterator<Item = $it_it> {
                    self.0.iter()
                }
            )*
        }

        #[async_trait]
        impl HyprData for $name {
            fn get() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd($kind);
                let deserialized: $held = serde_json::from_str(&data)?;
                Ok(Self(deserialized))
            }
            async fn get_async() -> $crate::Result<Self> {
                let data = call_hyprctl_data_cmd_async($kind).await;
                let deserialized: $held = serde_json::from_str(&data)?;
                Ok(Self(deserialized))
            }
        }
    };

    (p $name:ident,$kind:path,$caller:expr,$held:ty,$c:literal) => {
        #[doc = $c]
        #[derive(Debug)]
        pub struct $name($held);

        #[async_trait]
        impl HyprData for $name {
            fn get() -> HResult<Self> {
                let data = call_hyprctl_data_cmd($kind);
                Ok(Self($caller(data)?))
            }
            async fn get_async() -> HResult<Self> {
                let data = call_hyprctl_data_cmd_async($kind).await;
                Ok(Self($caller(data)?))
            }
        }
    };
}