doe 1.1.82

doe is a powerful Rust crate designed to enhance development workflow by providing an extensive collection of useful macros and utility functions. It not only simplifies common tasks but also offers convenient features for clipboard management,robust cryptographic functions,keyboard input, and mouse interaction.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/// Asynchronous utilities for working with Tokio runtime and async operations
/// 
/// Provides functionality for:
/// - Blocking on async operations
/// - Running system commands asynchronously
/// 
/// # Examples
/// 
/// ```ignore
/// #[allow(warnings)]
/// fn main() {
/// // Block on an async operation
/// asyncrs::block_on(async {
///     let output = asyncrs::command("echo hello").await;
///     println!("{}", String::from_utf8_lossy(&output.stdout));
/// });
///     let rt = doe::asyncrs::runtime::Builder::new_multi_thread()
///         .enable_all()
///         .build()
///         .unwrap();
///     rt.block_on(run());
///     rt.block_on(async {
///         run().await;
///     });
/// }
/// 
/// async fn run() {}
/// 
/// ```
#[allow(warnings)]
#[cfg(feature = "asyncrs")]
pub mod asyncrs {
    pub use tokio::runtime::Runtime;
    pub use tokio::*;

    use crate::Vector;

    /// Trait for blocking on async operations
    /// 
    /// Provides a method to block the current thread until a future completes
    pub trait BlockOn {
        /// Blocks the current thread until the provided future completes
        /// 
        /// # Arguments
        /// 
        /// * `future` - A future that will be blocked on
        /// 
        /// # Panics
        /// 
        /// Panics if unable to create a new Tokio runtime
        /// 
        /// # Example
        /// 
        /// ```
        /// use doe::asyncrs::BlockOn;
        /// 
        /// ().block_on(async {
        ///     println!("Running async operation");
        /// });
        /// ```
        fn block_on<F>(&self, future: F)
        where
            F: std::future::Future<Output = ()> + Send + 'static;
    }

    impl BlockOn for () {
        fn block_on<F>(&self, future: F)
        where
            F: std::future::Future<Output = ()> + Send + 'static,
        {
            let rt = tokio::runtime::Runtime::new().unwrap();
            rt.block_on(future);
        }
    }

    /// Blocks the current thread on the given future, executing it to completion
    /// 
    /// Creates a new Tokio runtime and uses it to run the provided future
    /// 
    /// # Arguments
    /// 
    /// * `future` - A future that will be blocked on
    /// 
    /// # Panics
    /// 
    /// Panics if unable to create a new Tokio runtime
    pub fn block_on<F>(future: F)
    where
        F: std::future::Future<Output = ()> + Send + 'static,
    {
        let rt = tokio::runtime::Runtime::new().unwrap();
        rt.block_on(future);
    }

    /// Executes a system command asynchronously
    /// 
    /// # Arguments
    /// 
    /// * `command` - The command to execute, can be a string or byte slice
    /// 
    /// # Returns
    /// 
    /// Returns a `std::process::Output` containing the command's output
    /// 
    /// # Panics
    /// 
    /// Panics if unable to spawn the child process
    /// 
    /// # Example
    /// 
    /// ```
    /// use doe::asyncrs;
    /// 
    /// asyncrs::block_on(async {
    ///     let output = asyncrs::command("echo hello").await;
    ///     println!("{}", String::from_utf8_lossy(&output.stdout));
    /// });
    /// ```
    pub async fn command(command: impl AsRef<[u8]>) -> std::process::Output {
        use std::process::Stdio;
        use tokio::process::Command;
        let command = command.as_ref().to_string_lossy().to_string();
        let exe = command.split(" ").into_iter().nth(0).unwrap();
        let other = command.split(" ").into_iter().skip(1).collect::<Vec<_>>();
        let child = Command::new(exe)
            .args(other)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .expect("Failed to spawn child process");
        let output = child
            .wait_with_output()
            .await
            .expect("Failed to wait on child");
        output
    }
}
#[cfg(feature = "asyncrs")]
pub use asyncrs::*;