doe/macros.rs
1///all macros
2#[allow(warnings)]
3#[macro_use]
4pub mod macros {
5 ///
6 // Result<(), Box<dyn std::error::Error>>
7 #[macro_export]
8 macro_rules! dyn_error {
9 () => {Result<(), Box<dyn std::error::Error>>};
10 }
11
12 #[macro_export]
13 macro_rules! include_string {
14 ($path:expr) => {
15 include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/", $path)).to_string()
16 };
17 }
18 ///
19 /// ```ignore
20 /// use doe::run_time;
21 /// run_time!{
22 /// {
23 /// for i in 0..10000{
24 /// println!("{}",i);
25 /// }
26 /// }
27 /// };
28 /// ```
29 ///
30 #[macro_export]
31 macro_rules! run_time {
32 ($v:block) => {{
33 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
34 use std::time::Instant;
35 static ELAPSED_TIME_NS: AtomicUsize = AtomicUsize::new(0);
36 let start = Instant::now();
37 let _ret = $v;
38 ELAPSED_TIME_NS.fetch_add(start.elapsed().as_nanos() as usize, SeqCst);
39 println!("{}ms", ELAPSED_TIME_NS.load(SeqCst) / 1000 / 1000);
40 }};
41 }
42
43 ///socketaddr
44 /// ```
45 /// use doe::socketaddr;
46 /// let addr = socketaddr!("127.0.0.1", "8080");
47 /// let addr = socketaddr!("127.0.0.1:8080");
48 /// ```
49 #[macro_export]
50 macro_rules! socketaddr {
51 ($ip:expr, $port:expr) => {{
52 use std::net::{Ipv4Addr, SocketAddr, ToSocketAddrs};
53 format!("{}:{}", $ip, $port)
54 .to_socket_addrs()
55 .unwrap()
56 .next()
57 .unwrap()
58 }};
59 ($str:expr) => {{
60 use std::net::{Ipv4Addr, SocketAddr, ToSocketAddrs};
61 $str.to_socket_addrs().unwrap().next().unwrap()
62 }};
63 }
64 ///## like pythons os.system() function
65 #[cfg(target_os = "linux")]
66 #[macro_export]
67 macro_rules! system {
68 ( $a:expr) => {{
69 pub fn system(command: impl ToString) -> std::io::Result<()> {
70 use std::process::Command;
71 Command::new("sh")
72 .arg("-c")
73 .arg(&command.to_string())
74 .status()
75 .map(|_| ())
76 }
77 system($a).unwrap()
78 }};
79 }
80 ///## like pythons os.system() function
81 #[cfg(target_os = "macos")]
82 #[macro_export]
83 macro_rules! system {
84 ( $a:expr) => {{
85 pub fn system(command: impl ToString) -> std::io::Result<()> {
86 use std::process::Command;
87 Command::new("sh")
88 .arg("-c")
89 .arg(&command.to_string())
90 .status()
91 .map(|_| ())
92 }
93 system($a).unwrap()
94 }};
95 }
96 ///## like pythons os.system() function
97 #[cfg(target_os = "windows")]
98 #[macro_export]
99 macro_rules! system_cmd {
100 ( $a:expr) => {{
101 pub fn system(command: impl ToString) -> std::io::Result<()> {
102 use std::process::Command;
103 Command::new("cmd")
104 .arg("/c")
105 .arg(&command.to_string())
106 .status()
107 .map(|_| ())
108 }
109 system($a).unwrap()
110 }};
111 }
112 ///## like pythons os.system() function
113 #[cfg(target_os = "windows")]
114 #[macro_export]
115 macro_rules! system {
116 ( $a:expr) => {{
117 pub fn system(command: impl ToString) -> std::io::Result<()> {
118 use std::process::Command;
119 Command::new("powershell")
120 .arg("-Command")
121 .arg(&command.to_string())
122 .status()
123 .map(|_| ())
124 }
125 system($a).unwrap()
126 }};
127 }
128 ///## convert type
129 /// ```rust
130 /// use doe::*;
131 /// let s = as_to!(5., i64);
132 /// assert_eq!(5, s);
133 /// ```
134 #[macro_export]
135 macro_rules! as_to {
136 ( $a:expr,$type:ty ) => {
137 ($a as $type)
138 };
139 }
140 use std::{
141 any::Any,
142 collections::HashMap,
143 fmt::{Debug, Display},
144 };
145 ///## if type is i8 return true
146 /// ```rust
147 /// use doe::*;
148 /// assert_eq!(is_i8(&5_i8),true);
149 /// ```
150 pub fn is_i8(s: &dyn Any) -> bool {
151 if s.is::<i8>() {
152 return true;
153 } else {
154 return false;
155 }
156 }
157 ///## if type is i16 return true
158 /// ```rust
159 /// use doe::*;
160 /// assert_eq!(is_i16(&5_i16),true);
161 /// ```
162 pub fn is_i16(s: &dyn Any) -> bool {
163 if s.is::<i16>() {
164 return true;
165 } else {
166 return false;
167 }
168 }
169 ///## if type is i32 return true
170 /// ```rust
171 /// use doe::*;
172 /// assert_eq!(is_i32(&5_i32),true);
173 /// ```
174 pub fn is_i32(s: &dyn Any) -> bool {
175 if s.is::<i32>() {
176 return true;
177 } else {
178 return false;
179 }
180 }
181 ///## if type is i64 return true
182 /// ```rust
183 /// use doe::*;
184 /// assert_eq!(is_i64(&5_i64),true);
185 /// ```
186 pub fn is_i64(s: &dyn Any) -> bool {
187 if s.is::<i64>() {
188 return true;
189 } else {
190 return false;
191 }
192 }
193 ///## if type is i128 return true
194 /// ```rust
195 /// use doe::*;
196 /// assert_eq!(is_i128(&5_i128),true);
197 /// ```
198 pub fn is_i128(s: &dyn Any) -> bool {
199 if s.is::<i128>() {
200 return true;
201 } else {
202 return false;
203 }
204 }
205 ///## if type is f32 return true
206 /// ```rust
207 /// use doe::*;
208 /// assert_eq!(is_f32(&5.0_f32),true);
209 /// ```
210 pub fn is_f32(s: &dyn Any) -> bool {
211 if s.is::<f32>() {
212 return true;
213 } else {
214 return false;
215 }
216 }
217 ///## if type is f64 return true
218 /// ```rust
219 /// use doe::*;
220 /// assert_eq!(is_f64(&5.0_f64),true);
221 /// ```
222 pub fn is_f64(s: &dyn Any) -> bool {
223 if s.is::<f64>() {
224 return true;
225 } else {
226 return false;
227 }
228 }
229
230 pub fn pow<T>(a: T, b: T) -> T
231 where
232 f64: From<T>,
233 T: 'static
234 + std::ops::MulAssign
235 + std::fmt::Display
236 + std::ops::Mul<Output = T>
237 + Copy
238 + std::convert::From<f64>,
239 {
240 let mut re = a;
241 let aa: f64 = a.into();
242 let bb: f64 = b.into();
243 re = f64::powf(aa, bb).into();
244 re
245 }
246 ///## returns a raised to the b power
247 /// ```rust
248 /// use doe::*;
249 /// let p = powf!(2.,2.);
250 /// assert_eq!(p,4.0);
251 /// ```
252 #[macro_export]
253 macro_rules! powf {
254 ($a:expr,$b:expr) => {
255 f64::powf($a, $b)
256 };
257 }
258 ///## get argument and collect into Vec\<String\>
259 /// ```ignore
260 /// use doe::*;
261 /// //cargo run -- -n 100
262 /// let arg = args!();
263 /// assert_eq!(arg,vec![format!("-n"),format!("100")]);
264 /// ```
265 #[macro_export]
266 macro_rules! args {
267 () => {
268 std::env::args().skip(1).collect::<Vec<String>>()
269 };
270 }
271 ///## get user input from terminal,return String
272 /// ```rust
273 /// use doe::*;
274 /// let s = input!();
275 /// println!("{:?}",s);
276 /// ```
277 #[macro_export]
278 macro_rules! input {
279 () => {{
280 let mut string = String::new();
281 std::io::stdin().read_line(&mut string).unwrap();
282 string = string.to_string().trim().to_owned();
283 string
284 }};
285
286 ($prompt:expr) => {{
287 print!("{}", $prompt);
288 use std::io::Write;
289 // flush stdout buffer to ensure prompt is printed before reading input
290 std::io::stdout().flush().unwrap();
291 let mut string = String::new();
292 std::io::stdin().read_line(&mut string).unwrap();
293 string = string.trim().to_owned();
294 string
295 }};
296 }
297 #[macro_export]
298 macro_rules! input_lines {
299 () => {{
300 use std::io::{self, BufRead};
301 let stdin = io::stdin();
302 let lock = stdin.lock();
303 let mut lines = lock.lines();
304
305 let mut input_lines: Vec<String> = Vec::new();
306
307 loop {
308 if let Some(Ok(line)) = lines.next() {
309 if line.is_empty() {
310 break;
311 }
312 input_lines.push(line);
313 } else {
314 break;
315 }
316 }
317 input_lines
318 }};
319
320 ($prompt:expr) => {{
321 print!("{}", $prompt);
322 use std::io::Write;
323 // flush stdout buffer to ensure prompt is printed before reading input
324 std::io::stdout().flush().unwrap();
325 use std::io::{self, BufRead};
326 let stdin = io::stdin();
327 let lock = stdin.lock();
328 let mut lines = lock.lines();
329
330 let mut input_lines: Vec<String> = Vec::new();
331
332 loop {
333 if let Some(Ok(line)) = lines.next() {
334 if line.is_empty() {
335 break;
336 }
337 input_lines.push(line);
338 } else {
339 break;
340 }
341 }
342 input_lines
343 }};
344 }
345 ///## Spliy &str by spliter and collect into Vec\<String\>
346 /// ```rust
347 /// use doe::*;
348 /// let s = split_to_vec!("aa.bb",".");
349 /// assert_eq!(s,vec![format!("aa"),format!("bb")]);
350 /// ```
351 #[macro_export]
352 macro_rules! split_to_vec {
353 ($a:expr,$b:expr) => {
354 $a.to_string()
355 .split($b)
356 .map(|s| s.to_string().trim().to_owned())
357 .collect::<Vec<String>>()
358 };
359 }
360 ///## read .csv file and Collect into Vec\<Vec\<String\>\>
361 /// ```rust
362 /// use doe::*;
363 ///let s = read_csv!("./data.csv");
364 ///assert_eq!(s,vec![vec![format!("a"), format!("b"), format!("c")],vec![format!("1"), format!("2"), format!("3")],vec![format!("10"), format!("20"), format!("30")]]);
365 /// ```
366 #[macro_export]
367 macro_rules! read_csv {
368 ($path:expr) => {{
369 let data = std::fs::read($path).unwrap();
370 use $crate::Str;
371 let data_vec = String::from_utf8_lossy(&data).split_to_vec("\n");
372 data_vec
373 .iter()
374 .map(|s| s.split_to_vec(","))
375 .collect::<Vec<Vec<String>>>()
376 }};
377 }
378 ///## sorted new Vec
379 /// ```rust
380 /// use doe::*;
381 /// let s1 = sorted!(vec![1.2, 2.6, 0.2]);
382 /// let s2 = sorted!(vec![8, 1_i128, 5_i128]);
383 /// assert_eq!(s1,vec![0.2,1.2,2.6]);
384 /// assert_eq!(s2,vec![1,5,8]);
385 /// ```
386 #[macro_export]
387 macro_rules! sorted {
388 ($vec:expr) => {{
389 let mut vec = $vec.clone();
390 vec.sort_by(|a, b| a.partial_cmp(b).unwrap());
391 vec
392 }};
393 }
394 ///## sorted and deduped Vec
395 /// ```rust
396 /// use doe::*;
397 /// let s1 = deduped_sorted!(vec![1.2, 1.2,2.6, 0.2]);
398 /// let s2 = deduped_sorted!(vec![8, 1_i128,8,5_i128]);
399 /// assert_eq!(s1,vec![0.2,1.2,2.6]);
400 /// assert_eq!(s2,vec![1,5,8]);
401 /// ```
402 #[macro_export]
403 macro_rules! deduped_sorted {
404 ($vec:expr) => {{
405 let mut vec1 = $vec.clone();
406 let mut vec2 = $crate::sorted!(vec1);
407 vec2.dedup();
408 vec2
409 }};
410 }
411 ///## parse Vec element to type, parse Vec\<&str\> Collect to Vec\<type\>
412 /// ```rust
413 /// use doe::*;
414 ///let v1: Vec<f64> = vec_element_parse!(vec!["15.", "2.9"], f64);
415 ///let v2: Vec<i128> = vec_element_parse!(vec!["15", "2"], i128);
416 ///let v3: Vec<f32> = vec_element_parse!(vec![".15", ".2"], f32);
417 ///assert_eq!(vec![15.0, 2.9], v1);
418 ///assert_eq!(vec![15, 2], v2);
419 ///assert_eq!(vec![0.15, 0.2], v3);
420 /// ```
421 #[macro_export]
422 macro_rules! vec_element_parse {
423 ($vec:expr,$type:ty) => {{
424 let mut v2: Vec<$type> = Vec::new();
425 let vec = $vec.clone();
426 if $vec.len() > 0 {
427 match vec.get(0).unwrap().to_owned().parse::<$type>() {
428 Ok(_r) => {
429 let vec1 = $vec.clone();
430 v2 = vec1
431 .iter()
432 .map(|x| x.to_string().parse::<$type>().unwrap())
433 .collect::<Vec<_>>();
434 }
435 Err(_e) => {}
436 }
437 }
438 v2
439 }};
440 }
441 ///## convert vec item to String,return Vec\<String\>
442 /// ```rust
443 /// use doe::*;
444 ///let v1 = vec_element_to_string!(vec!["15.", "2.9"]);
445 ///let v2 = vec_element_to_string!(vec![15, 2]);
446 ///let v3 = vec_element_to_string!(vec![0.15, 0.2]);
447 ///assert_eq!(vec!["15.", "2.9"], v1);
448 ///assert_eq!(vec!["15", "2"], v2);
449 ///assert_eq!(vec!["0.15", "0.2"], v3);
450 /// ```
451 #[macro_export]
452 macro_rules! vec_element_to_string {
453 ($vec:expr) => {{
454 let mut v2: Vec<String> = Vec::new();
455 if $vec.len() > 0 {
456 let vec1 = $vec.clone();
457 v2 = vec1
458 .iter()
459 .map(|x| format!("{}", &x))
460 .collect::<Vec<String>>();
461 }
462 v2
463 }};
464 }
465 ///## return the array elements arranged from outermost elements to the middle element, traveling clockwise (n x n)
466 /// ```rust
467 /// use doe::*;
468 ///let v1 = snail_sort!(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]);
469 ///let v2 = snail_sort!(vec![vec![1.1, 2.1, 3.1],vec![4.1, 5.1, 6.1],vec![7.1, 8.1, 9.1]]);
470 ///assert_eq!(vec![1, 2, 3, 6, 9, 8, 7, 4, 5], v1);
471 ///assert_eq!(vec![1.1, 2.1, 3.1, 6.1, 9.1, 8.1, 7.1, 4.1, 5.1], v2);
472 /// ```
473 #[macro_export]
474 macro_rules! snail_sort {
475 ($vec:expr) => {{
476 fn snail<T: Copy>(matrix: &[Vec<T>]) -> Vec<T> {
477 let mut ret = Vec::new();
478 if matrix.len() == 0 {
479 return ret;
480 }
481 let mut width = matrix[0].len();
482 let mut height = matrix.len();
483 let mut cycle = 0;
484 while width > 0 && height > 0 {
485 for x in cycle..width {
486 ret.push(matrix[cycle][x]);
487 }
488 for y in cycle + 1..height {
489 ret.push(matrix[y][width - 1]);
490 }
491 for x in (cycle..width - 1).rev() {
492 ret.push(matrix[height - 1][x]);
493 }
494 for y in (cycle + 1..height - 1).rev() {
495 ret.push(matrix[y][cycle]);
496 }
497 cycle += 1;
498 width -= 1;
499 height -= 1;
500 }
501 ret
502 }
503 let vec = $vec.clone();
504 snail(&vec)
505 }};
506 }
507
508 ///## mutiply two matrix
509 /// ```rust
510 /// use doe::*;
511 ///let m1 = [[1, 2, -1], [-1, 3, 4], [1, 1, 1]].map(|s| s.to_vec()).to_vec();
512 ///let m2 = [[5, 6], [-5, -6], [6, 0]].map(|s| s.to_vec()).to_vec();
513 ///let mul_result1 = multiply_matrix!(&m1, &m2);
514 ///assert_eq!(mul_result1, [[-11, -6], [4, -24], [6, 0]]);
515 ///let m11 = [[1., 2., -1.], [-1., 3., 4.]].map(|s| s.to_vec()).to_vec();
516 ///let m22 = [[5.5, 6.], [-5., -6.5]].map(|s| s.to_vec()).to_vec();
517 ///let mul_result2 = multiply_matrix!(&m11, &m22);
518 ///assert_eq!(mul_result2, [[-4.5, -7.0], [-20.5, -25.5]]);
519 ///let m111 = [[1., 2., -1.], [-1., 3., 4.]].map(|s| s.to_vec()).to_vec();
520 ///let m222 = [[5.5, 6.]].map(|s| s.to_vec()).to_vec();
521 ///let mul_result3 = multiply_matrix!(&m111, &m222);
522 ///assert_eq!(mul_result3, [[5.5, 6.0]]);
523 /// ```
524 #[macro_export]
525 macro_rules! multiply_matrix {
526 ($vec1:expr,$vec2:expr) => {{
527 use core::ops;
528 pub fn new<T: Clone + Copy>(val: T, m: usize, n: usize) -> Vec<Vec<T>> {
529 //returb 0 created n*m matrix
530 let mut mat: Vec<Vec<T>> = Vec::new();
531 for _ in 0..m {
532 mat.push(vec![val; n].to_vec());
533 }
534 let vec = mat.clone();
535 vec
536 }
537 pub fn multiply_matrix<
538 T: Clone
539 + Copy
540 + std::fmt::Debug
541 + std::fmt::Display
542 + ops::Mul<Output = T>
543 + ops::Add<Output = T>
544 + ops::Div<Output = T>
545 + ops::Sub<Output = T>
546 + std::ops::AddAssign
547 + std::convert::From<i32>,
548 >(
549 matrix1: &Vec<Vec<T>>,
550 matrix2: &Vec<Vec<T>>,
551 ) -> Vec<Vec<T>> {
552 let m = *&matrix2.len();
553 pub fn generic_convert<T>(a: i32) -> T
554 where
555 i32: std::convert::Into<T>,
556 T: std::convert::From<i32>,
557 {
558 Into::into(a)
559 }
560 let val = generic_convert::<T>(0);
561 let mut matrix3: Vec<Vec<T>> = new(val, *&matrix2.len(), *&matrix2[0].len());
562 for i in 0..*&matrix2.len() {
563 for j in 0..*&matrix2[0].len() {
564 for k in 0..m {
565 matrix3[i][j] += matrix1[i][k] * matrix2[k][j];
566 }
567 }
568 }
569 matrix3
570 }
571
572 let vec1 = $vec1.clone();
573 let vec2 = $vec2.clone();
574 multiply_matrix(&vec1, &vec2)
575 }};
576 }
577 ///## find the fist element and remove
578 /// ```rust
579 /// use doe::*;
580 ///let v1 = vec_element_remove!(vec!["15.", "2.9"], "2.9");
581 ///let v2 = vec_element_remove!(vec![15, 2, 3, 2], 2);
582 ///let v3 = vec_element_remove!(vec![0.15, 0.2, 0.2], 0.2);
583 ///assert_eq!(vec!["15."], v1);
584 ///assert_eq!(vec![15, 3, 2], v2);
585 ///assert_eq!(vec![0.15, 0.2], v3);
586 /// ```
587 #[macro_export]
588 macro_rules! vec_element_remove {
589 ($vec:expr,$element:expr) => {{
590 let mut vec = $vec.clone();
591 match &vec.binary_search_by(|probe| probe.partial_cmp(&$element).unwrap()) {
592 Ok(r) => {
593 vec.remove(*r);
594 }
595 Err(r) => {}
596 }
597 vec
598 };};
599 }
600 ///## find the element and remove all
601 /// ```rust
602 /// use doe::*;
603 ///let v1 = vec_element_remove_all!(vec!["15.", "2.9", "0.9", "2.9", "2.9"], "2.9");
604 ///assert_eq!(vec!["15.", "0.9"], v1);
605 ///let v2 = vec_element_remove_all!(vec![15, 2, 3, 2], 2);
606 ///assert_eq!(vec![15, 3], v2);
607 ///let v3 = vec_element_remove_all!(vec![0.15, 0.2, 1.0, 0.2], 0.3);
608 ///assert_eq!(vec![0.15, 0.2, 1.0, 0.2], v3);
609 ///let v4 = vec_element_remove_all!(vec!["0".to_string(),"1".to_string(),"0".to_string()], "0".to_string());
610 ///assert_eq!(vec!["1".to_string()], v4);
611 /// ```
612 #[macro_export]
613 macro_rules! vec_element_remove_all {
614 ($vec:expr,$element:expr) => {{
615 let mut vec = $vec.clone();
616 fn remove<T: Clone + PartialOrd<T>>(vec: Vec<T>, target: &T) -> Vec<T> {
617 let mut v1 = vec.clone();
618 for i in 1..v1.len() - 1 {
619 if v1[i - 1] == *target {
620 v1.remove(i - 1);
621 }
622 }
623 if v1[v1.len() - 1] == *target {
624 v1.remove(v1.len() - 1);
625 }
626 v1
627 }
628 remove(vec, &$element)
629 };};
630 }
631 ///## find element position and collect into Vec<usize>
632 /// ```rust
633 /// use doe::*;
634 ///let v1 = vec_element_position_all!(vec![1, 2, 5, 3, 6, 2, 2], 2);
635 ///assert_eq!(v1, vec![1, 5, 6]);
636 ///let v2 = vec_element_position_all!(vec!["0".to_string(),"4".to_string(),"7".to_string(),"7".to_string(),], "7".to_string());
637 ///assert_eq!(v2, vec![2,3]);
638 /// ```
639 #[macro_export]
640 macro_rules! vec_element_position_all {
641 ($vec:expr,$element:expr) => {{
642 let mut vec = $vec.clone();
643 fn position<T: Clone + PartialOrd<T>>(vec: Vec<T>, target: &T) -> Vec<usize> {
644 let mut v1 = vec.clone();
645 let mut re = vec![];
646 for i in 0..v1.len() {
647 if v1[i] == *target {
648 re.push(i);
649 }
650 }
651 re
652 }
653 position(vec, &$element)
654 };};
655 }
656
657 ///## slice vec by range
658 /// ```rust
659 ///use doe::*;
660 ///let v1 = vec_slice!(vec![1.2, 1.5, 9.0], 0..2);
661 ///let v2 = vec_slice!(vec![1, 1, 9, 90, 87, 0, 2], 4..6);
662 ///let v3 = vec_slice!(vec![1.2, 1.5, 9.0], 0..3);
663 ///let v4 = vec_slice!(vec![1.2, 1.5, 9.0], 1..3);
664 ///let v5 = vec_slice!(vec!["1", "2", "3", "4", "5"], 2..5);
665 ///let v6 = vec_slice!(vec!["1".to_string(),"2".to_string(),"3".to_string()], 1..2);
666 ///assert_eq!(v1, vec![1.2, 1.5]);
667 ///assert_eq!(v2, vec![87, 0]);
668 ///assert_eq!(v3, vec![1.2, 1.5, 9.0]);
669 ///assert_eq!(v4, vec![1.5, 9.0]);
670 ///assert_eq!(v5, vec!["3", "4", "5"]);
671 ///assert_eq!(v6,vec!["2".to_string()]);
672 /// ```
673 #[macro_export]
674 macro_rules! vec_slice {
675 ($vec:expr,$range:expr) => {{
676 fn vec_slice<T: Clone>(vec: Vec<T>, range: std::ops::Range<usize>) -> Vec<T> {
677 vec.get(range).unwrap().to_vec()
678 }
679 vec_slice($vec, $range)
680 }};
681 }
682
683 ///## clone element by index
684 /// ```rust
685 /// use doe::*;
686 ///let v1 = vec_element_clone!(vec!["15.", "2.9"], 1);
687 ///let v2 = vec_element_clone!(vec![15, 2, 3, 2], 2);
688 ///let v3 = vec_element_clone!(vec![0.15, 0.2, 0.2], 0);
689 ///let v4 = vec_element_clone!(vec![format!("1"),format!("2"),format!("3"),format!("4"),format!("5")],4);
690 ///assert_eq!("2.9", v1);
691 ///assert_eq!(3, v2);
692 ///assert_eq!(0.15, v3);
693 ///assert_eq!(format!("5"), v4);
694 /// ```
695 #[macro_export]
696 macro_rules! vec_element_clone {
697 ($vec:expr,$index:expr) => {{
698 let vec = $vec.clone();
699 let s = vec.get($index).unwrap();
700 s.to_owned()
701 };};
702 }
703 ///## remove file or folder
704 /// ```ignore
705 ///remove_file_or_folder!("./demo.txt");
706 ///remove_file_or_folder!("./target");
707 /// ```
708 #[macro_export]
709 macro_rules! remove_file_or_folder {
710 ($path:expr) => {{
711 use std::fs;
712 use std::path::Path;
713 pub fn rm(path: &Path) {
714 if path.is_dir() {
715 fs::remove_dir_all(path).unwrap();
716 } else if path.is_file() {
717 fs::remove_file(path).unwrap();
718 }
719 }
720 let path = Path::new($path);
721 rm(path);
722 };};
723 }
724 ///## get vec type ,return string type value
725 /// ```rust
726 /// use doe::*;
727 ///assert_eq!(vec_type!(vec![0.2_f64]), format!("Vec<f64>"));
728 ///assert_eq!(vec_type!(vec![0.2_f32]), format!("Vec<f32>"));
729 ///assert_eq!(vec_type!(vec![2_i32]), format!("Vec<i32>"));
730 ///assert_eq!(vec_type!(vec![2_i128]), format!("Vec<i128>"));
731 ///assert_eq!(vec_type!(vec![2_isize]), format!("Vec<isize>"));
732 ///assert_eq!(vec_type!(vec![2_usize]), format!("Vec<usize>"));
733 /// ```
734 #[macro_export]
735 macro_rules! vec_type {
736 ($vec:expr) => {{
737 use std::any::Any;
738 pub fn vec_type(s: &dyn Any) -> String {
739 let mut re = String::new();
740 if s.is::<Vec<String>>() {
741 re = format!("Vec<String>");
742 } else if s.is::<Vec<&str>>() {
743 re = format!("Vec<&str>");
744 } else if s.is::<Vec<i128>>() {
745 re = format!("Vec<i128>");
746 } else if s.is::<Vec<i64>>() {
747 re = format!("Vec<i64>");
748 } else if s.is::<Vec<i32>>() {
749 re = format!("Vec<i32>");
750 } else if s.is::<Vec<i16>>() {
751 re = format!("Vec<i16>");
752 } else if s.is::<Vec<i8>>() {
753 re = format!("Vec<i8>");
754 } else if s.is::<Vec<u128>>() {
755 re = format!("Vec<u128>");
756 } else if s.is::<Vec<u64>>() {
757 re = format!("Vec<u64>");
758 } else if s.is::<Vec<u32>>() {
759 re = format!("Vec<u32>");
760 } else if s.is::<Vec<u16>>() {
761 re = format!("Vec<u16>");
762 } else if s.is::<Vec<u8>>() {
763 re = format!("Vec<u8>");
764 } else if s.is::<Vec<f64>>() {
765 re = format!("Vec<f64>");
766 } else if s.is::<Vec<f32>>() {
767 re = format!("Vec<f32>");
768 } else if s.is::<Vec<usize>>() {
769 re = format!("Vec<usize>");
770 } else if s.is::<Vec<isize>>() {
771 re = format!("Vec<isize>");
772 } else {
773 re = format!("");
774 }
775 re
776 }
777 vec_type(&$vec)
778 };};
779 }
780
781 /// ## convert vec elements type
782 /// ```rust
783 /// use doe::*;
784 ///let v1: Vec<f64> = vec_element_convert!(vec![1, 2], f64);
785 ///let v2: Vec<i32> = vec_element_convert!(vec![1.0, 2.0], i32);
786 ///let v3: Vec<i128> = vec_element_convert!(vec![1.0, 2.0], i128);
787 ///let v4: Vec<i32> = vec_element_convert!(vec![1_usize, 2_usize], i32);
788 ///let v5: Vec<i64> = vec_element_convert!(vec![0.15, 2.0], i64);
789 ///assert_eq!(v1, vec![1.0, 2.0]);
790 ///assert_eq!(v2, vec![1, 2]);
791 ///assert_eq!(v3, vec![1, 2]);
792 ///assert_eq!(v4, vec![1, 2]);
793 ///assert_eq!(v5, vec![0, 2]);
794 /// ```
795 #[macro_export]
796 macro_rules! vec_element_convert {
797 ($vec:expr,$type:ty) => {{
798 let vec = $vec.clone();
799 let mut re: Vec<$type> = Vec::new();
800 let re_type = vec_type!(re);
801 if vec_type!(re) != format!("Vec<String>") {
802 for item in &vec {
803 re.push(*item as $type);
804 }
805 }
806 re
807 };};
808 }
809
810 ///## expr return max value
811 /// ```rust
812 /// use doe::*;
813 ///let re_max = max!(1, 20);
814 ///assert_eq!(re_max,20);
815 /// ```
816 #[macro_export]
817 macro_rules! max {
818 ($x:expr) => ($x);
819 ($x:expr, $($y:expr),+) => {
820 std::cmp::max($x, max!($($y),+))
821 }
822 }
823 ///## expr return min value
824 /// ```rust
825 /// use doe::*;
826 ///let re_min = min!(10, 2, 2, 5, 4, 6);
827 ///assert_eq!(re_min,2);
828 /// ```
829 #[macro_export]
830 macro_rules! min {
831 ($x:expr) => ($x);
832 ($x:expr, $($y:expr),+) => {
833 std::cmp::min($x, min!($($y),+))
834 }
835 }
836 ///## convert binary string to decimal
837 /// ```rust
838 /// use doe::*;
839 ///let d1 = binary_to_decimal!("01101",i128);
840 ///assert_eq!(d1,13_i128);
841 ///let d2 = binary_to_decimal!("00000000000010100110001",i64);
842 ///assert_eq!(d2,1329_i64);
843 ///let d3 = binary_to_decimal!("000011",i32);
844 ///assert_eq!(d3,3_i32);
845 ///let d4 = binary_to_decimal!("000101",i16);
846 ///assert_eq!(d4,5_i16);
847 ///let d5 = binary_to_decimal!("001001",i8);
848 ///assert_eq!(d5,9_i8);
849 /// ```
850 #[macro_export]
851 macro_rules! binary_to_decimal {
852 ($binary_string:expr,$decimal_type:ty) => {{
853 fn binary_to_decimal(num: impl ToString) -> $decimal_type {
854 let mut sum = 0 as $decimal_type;
855 let vec = num
856 .to_string()
857 .chars()
858 .map(|x| <$decimal_type>::from(x.to_digit(10).unwrap() as $decimal_type))
859 .collect::<Vec<$decimal_type>>();
860 for (index, item) in vec.iter().rev().enumerate() {
861 sum += <$decimal_type>::pow(2, index as u32) * item;
862 }
863 sum
864 }
865 binary_to_decimal($binary_string)
866 }};
867 }
868 ///## expr return memory address
869 /// ```rust
870 /// use doe::*;
871 ///let d1 = binary_to_decimal!("01101",i128);
872 ///println!("{:?}",memory_address!(d1));//0x7ffcac734f08
873 /// ```
874 #[macro_export]
875 macro_rules! memory_address {
876 ($x:expr) => {{
877 &$x as *const _
878 }};
879 }
880
881 ///## Merge two Vec return merged Vec
882 /// ```rust
883 /// use doe::*;
884 ///let v1 = vec_merge!(vec![0, 1, 2], vec![5, 6, 7]);
885 ///assert_eq!(vec![0, 1, 2, 5, 6, 7],v1);
886 ///let v2 = vec_merge!(vec![0., 1., 2.], vec![5., 6., 7.]);
887 ///assert_eq!(vec![0., 1., 2., 5., 6., 7.],v2);
888 ///```
889 #[macro_export]
890 macro_rules! vec_merge {
891 ($vec1:expr,$vec2:expr) => {{
892 let mut re = vec![];
893 for item in $vec1.iter() {
894 re.push(item.to_owned());
895 }
896 for item in $vec2.iter() {
897 re.push(item.to_owned());
898 }
899 re
900 }};
901 }
902
903 ///## take size of elements and return a new vec
904 /// ```rust
905 /// use doe::*;
906 ///let v1 = vec_element_take!(vec![0, 1, 2],2);
907 ///assert_eq!(vec![0,1],v1);
908 ///```
909 #[macro_export]
910 macro_rules! vec_element_take {
911 ($vec:expr,$size:expr) => {{
912 let mut re = vec![];
913 for i in 0..$size {
914 re.push(vec_element_clone!($vec, i));
915 }
916 re
917 }};
918 }
919
920 ///## zip two vec elements in tuple
921 /// ```rust
922 /// use doe::*;
923 ///let v1 = vec_zip!(vec![0, 1, 2],vec![0, 1, 2]);
924 ///assert_eq!(vec![(0,0),(1,1),(2,2)],v1);
925 ///```
926 #[macro_export]
927 macro_rules! vec_zip {
928 ($vec1:expr,$vec2:expr) => {{
929 let mut re = vec![];
930 if $vec1.len() == $vec2.len() {
931 for i in 0..$vec1.len() {
932 re.push((vec_element_clone!($vec1, i), vec_element_clone!($vec2, i)));
933 }
934 }
935 re
936 }};
937 }
938
939 ///## enumerate all indexs and elements collect tuple of vec
940 /// ```rust
941 /// use doe::*;
942 ///let v1 = vec_enumerate!(vec![12, 11, 20]);
943 ///assert_eq!(vec![(0,12),(1,11),(2,20)],v1);
944 ///```
945 #[macro_export]
946 macro_rules! vec_enumerate {
947 ($vec:expr) => {{
948 let mut re = vec![];
949 for (index, element) in $vec.iter().enumerate() {
950 re.push((index, vec_element_clone!($vec, index)));
951 }
952 re
953 }};
954 }
955 ///## sort vec and return sorted vec
956 /// ```rust
957 /// use doe::*;
958 ///let v1 = vec_sort!(vec![10, 2, 3]);
959 ///assert_eq!(vec![2,3,10],v1);
960 ///let v2 = vec_sort!(vec![1.8, 2.5, 0.3]);
961 ///assert_eq!(vec![0.3,1.8,2.5],v2);
962 ///```
963 #[macro_export]
964 macro_rules! vec_sort {
965 ($vec:expr) => {{
966 let mut re = $vec.clone();
967 re.sort_by(|a, b| a.partial_cmp(b).unwrap());
968 re
969 }};
970 }
971 ///## has stable rust nightly return bool
972 /// ```ignore
973 /// use doe::*;
974 /// let v1 = has_nightly_compiler!();
975 /// assert_eq!(v1, true);
976 ///```
977 #[cfg(not(target_arch = "wasm32"))]
978 #[macro_export]
979 macro_rules! has_nightly_compiler {
980 () => {{
981 fn has_nightly_compiler() -> bool {
982 use std::process;
983 match process::Command::new("cargo")
984 .arg("+nightly")
985 .arg("help")
986 .stdout(process::Stdio::null())
987 .stderr(process::Stdio::null())
988 .status()
989 {
990 Ok(exit_status) => exit_status.success(),
991 Err(_) => false,
992 }
993 }
994 has_nightly_compiler()
995 }};
996 }
997
998 ///## has stable rust compiler return bool
999 /// ```rust
1000 /// use doe::*;
1001 /// let v1 = has_stable_compiler!();
1002 /// assert_eq!(v1, false);
1003 ///```
1004 #[cfg(not(target_arch = "wasm32"))]
1005 #[macro_export]
1006 macro_rules! has_stable_compiler {
1007 () => {{
1008 fn has_stable_compiler() -> bool {
1009 use std::process;
1010 match process::Command::new("cargo")
1011 .arg("+stable")
1012 .arg("help")
1013 .stdout(process::Stdio::null())
1014 .stderr(process::Stdio::null())
1015 .status()
1016 {
1017 Ok(exit_status) => exit_status.success(),
1018 Err(_) => false,
1019 }
1020 }
1021 has_stable_compiler()
1022 }};
1023 }
1024
1025 ///## run command
1026 /// ```ignore
1027 /// use doe::*;
1028 ///command!("ls -la");
1029 ///command!("dust");
1030 ///command!("lsd");
1031 ///```
1032 #[cfg(not(target_arch = "wasm32"))]
1033 #[macro_export]
1034 macro_rules! command {
1035 ($cmd:expr) => {{
1036 let cmds = $cmd;
1037 fn cmd(cmd: &str) {
1038 use std::process::Stdio;
1039 use std::{io::Write, process::Command};
1040 let exe = vec_element_clone!(split_to_vec!(cmd, " "), 0);
1041 let other = split_to_vec!(cmd, " ")
1042 .get(1..)
1043 .unwrap()
1044 .to_vec()
1045 .into_iter()
1046 .map(|s| s.to_string())
1047 .collect::<Vec<_>>();
1048 let mut child = Command::new(exe)
1049 .args(other)
1050 .stdin(Stdio::piped())
1051 .stdout(Stdio::piped())
1052 .stderr(Stdio::piped())
1053 .spawn()
1054 .expect("Failed to spawn child process");
1055 let output = child.wait_with_output().expect("Failed to read stdout");
1056 if output.status.success() {
1057 // println!("{:?}",&output.stdout);
1058 std::io::stdout().write_all(&output.stdout).unwrap();
1059 println!("{} 👈👌✔", cmd);
1060 } else {
1061 // println!("{:?}",&output.stderr);
1062 std::io::stdout().write_all(&output.stderr).unwrap();
1063 println!("{} 👈👎✗", cmd);
1064 }
1065 }
1066 cmd(cmds);
1067 }};
1068 }
1069
1070 ///## run a function once after a particularized delay(millis)
1071 /// ```ignore
1072 /// use doe::*;
1073 ///set_timeout!(||{
1074 /// println!("ok");
1075 ///},3000);
1076 ///```
1077 #[cfg(not(target_arch = "wasm32"))]
1078 #[macro_export]
1079 macro_rules! set_timeout {
1080 ($fn:expr,$time:expr) => {{
1081 fn set_timeout<F>(mut func: F, time: u64)
1082 where
1083 F: Copy + Fn(),
1084 {
1085 use std::time::Duration;
1086 std::thread::sleep(Duration::from_millis(time));
1087 func();
1088 }
1089 set_timeout($fn, $time);
1090 }};
1091 }
1092
1093 ///## run a function repeatedly, beginning after some millis, then repeating continuously at the given interval.
1094 /// ```ignore
1095 /// use doe::*;
1096 ///set_interval!(||{
1097 /// println!("ok");
1098 ///},3000);
1099 ///```
1100 #[cfg(not(target_arch = "wasm32"))]
1101 #[macro_export]
1102 macro_rules! set_interval {
1103 ($fn:expr,$time:expr) => {{
1104 loop {
1105 set_timeout!($fn, $time);
1106 }
1107 }};
1108 }
1109
1110 ///## get current UTC-timestamp
1111 /// ```rust
1112 /// use doe::*;
1113 /// let t = utc_timestamp!();
1114 /// eprintln!("{}", t);
1115 /// ```
1116 #[cfg(not(target_arch = "wasm32"))]
1117 #[macro_export]
1118 macro_rules! utc_timestamp {
1119 () => {{
1120 std::time::SystemTime::now()
1121 .duration_since(std::time::SystemTime::UNIX_EPOCH)
1122 .unwrap_or_default()
1123 .as_secs_f64()
1124 }};
1125 }
1126
1127 ///## macro for HashMap
1128 ///```rust
1129 /// use doe::*;
1130 /// use std::collections::HashMap;
1131 /// let mut map:HashMap<i32,i32> = hashmap!();
1132 /// map.insert(0, 1);
1133 /// let map1 = hashmap!(2=>5,3=>4);
1134 ///```
1135 #[macro_export]
1136 macro_rules! hashmap {
1137 () => {{
1138 std::collections::HashMap::new()
1139 }};
1140 ($(||)+) => {{
1141 std::collections::HashMap::new
1142 }};
1143 ($($k: expr => $v: expr),+ $(,)*) => {{
1144 let mut m = std::collections::HashMap::with_capacity([$(&$k),*].len());
1145 $(m.insert($k, $v);)*
1146 m
1147 }};
1148
1149 }
1150 ///## macro for BTreeMap
1151 ///```rust
1152 /// use doe::*;
1153 /// use std::collections::BTreeMap;
1154 /// let mut map:BTreeMap<i32,i32> = btreemap!();
1155 /// map.insert(0, 1);
1156 /// let map1 = btreemap!(2=>5,3=>4);
1157 ///```
1158 #[macro_export]
1159 macro_rules! btreemap {
1160 () => {{
1161 std::collections::BTreeMap::new()
1162 }};
1163 ($(||)+) => {{
1164 std::collections::BTreeMap::new
1165 }};
1166 ($($k: expr => $v: expr),+ $(,)*) => {{
1167 let mut m = std::collections::BTreeMap::new();
1168 $(m.insert($k, $v);)*
1169 m
1170 }};
1171
1172 }
1173 /// ## implment targets! for return Vec<(Box\<dyn ToString>,Box\<dyn ToString>)>
1174 /// ```rust
1175 ///fn main() {
1176 /// use doe::Print;
1177 /// use doe::Str;
1178 /// "this is a {s},I like Trait Object {p}%"
1179 /// .format(vec![(Box::new("{s}"),Box::new("demo")),(Box::new("{p}"),Box::new(100))]).println();//this is a demo,I like Trait Object 100%
1180 /// use doe::targets;
1181 /// "this is a {d},I like Trait Object {p}}%"
1182 /// .format(targets!{"{d}"=>"demo","{p}"=>100})
1183 /// .println(); //this is a demo,I like Trait Object 100%
1184 ///}
1185 /// ```
1186 #[macro_export]
1187 macro_rules! targets {
1188 ($($key:expr => $value:expr),*) => {
1189 vec![
1190 $((Box::new($key), Box::new($value))),*
1191 ]
1192 };
1193 }
1194 /// implmemt Display for Struct
1195 /// ```rust
1196 ///fn main() {
1197 /// use std::sync::{Arc, Mutex};
1198 /// use doe::*;
1199 /// struct Doe{
1200 /// pub name:String,
1201 /// pub nickname: Box<str>,
1202 /// key:Arc<Mutex<usize>>
1203 /// }
1204 /// impl_display!(Doe,name,nickname,key);
1205 /// impl_debug!(Doe,name,nickname,key);
1206 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1207 /// println!("{:?}",d);
1208 /// println!("{}",d);
1209 ///}
1210 /// ```
1211 ///
1212 #[macro_export]
1213 macro_rules! impl_display {
1214 ($struct_name:ident, $($key:ident),*) => {
1215 impl std::fmt::Display for $struct_name {
1216 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1217 write!(f, "{} {{", stringify!($struct_name))?;
1218 $(
1219 write!(f, " {}: {:?},", stringify!($key), self.$key)?;
1220 )*
1221 write!(f, "}}")
1222 }
1223 }
1224 };
1225 }
1226 /// implmemt Debug for Struct
1227 /// ```rust
1228 ///fn main() {
1229 /// use std::sync::{Arc, Mutex};
1230 /// use doe::*;
1231 /// struct Doe{
1232 /// pub name:String,
1233 /// pub nickname: Box<str>,
1234 /// key:Arc<Mutex<usize>>
1235 /// }
1236 /// impl_display!(Doe,name,nickname,key);
1237 /// impl_debug!(Doe,name,nickname,key);
1238 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1239 /// println!("{:?}",d);
1240 /// println!("{}",d);
1241 ///}
1242 /// ```
1243 ///
1244 #[macro_export]
1245 macro_rules! impl_debug {
1246 ($struct_name:ident, $($key:ident),*) => {
1247 impl std::fmt::Debug for $struct_name {
1248 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1249 f.debug_struct(stringify!($struct_name))
1250 $(.field(stringify!($key), &self.$key))*
1251 .finish()
1252 }
1253 }
1254 };
1255 }
1256 /// implmemt Clone for Struct
1257 /// ```rust
1258 ///fn main() {
1259 /// use std::sync::{Arc, Mutex};
1260 /// use doe::*;
1261 /// struct Doe{
1262 /// pub name:String,
1263 /// pub nickname: Box<str>,
1264 /// key:Arc<Mutex<usize>>
1265 /// }
1266 /// impl_clone!(Doe,name,nickname,key);
1267 /// impl_debug!(Doe,name,nickname,key);
1268 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1269 /// println!("{:?}",d.clone());
1270 ///}
1271 /// ```
1272 ///
1273 #[macro_export]
1274 macro_rules! impl_clone {
1275 ($struct_name:ident, $($key:ident),*) => {
1276 impl Clone for $struct_name {
1277 fn clone(&self) -> Self {
1278 // clone each element
1279 $(
1280 let $key = self.$key.clone();
1281 )*
1282
1283 // create a new instance
1284 $struct_name {
1285 $(
1286 $key,
1287 )*
1288 }
1289 }
1290 }
1291 }
1292 }
1293 /// implmemt Default for Struct
1294 /// ```rust
1295 ///fn main() {
1296 /// use std::sync::{Arc, Mutex};
1297 /// use doe::*;
1298 /// struct Doe{
1299 /// pub name:String,
1300 /// pub nickname: Box<str>,
1301 /// key:Arc<Mutex<usize>>
1302 /// }
1303 /// impl_default!(Doe,name,nickname,key);
1304 /// impl_debug!(Doe,name,nickname,key);
1305 /// let d = Doe::default();
1306 /// println!("{:?}",d);
1307 ///}
1308 /// ```
1309 ///
1310 #[macro_export]
1311 macro_rules! impl_default {
1312 ($struct_name:ident, $($key:ident),*) => {
1313 impl Default for $struct_name {
1314 fn default() -> Self {
1315 $struct_name {
1316 $(
1317 $key: Default::default(),
1318 )*
1319 }
1320 }
1321 }
1322 }
1323 }
1324 /// implmemt Drop for Struct
1325 /// ```rust
1326 ///fn main() {
1327 /// use std::sync::{Arc, Mutex};
1328 /// use doe::*;
1329 /// struct Doe{
1330 /// pub name:String,
1331 /// pub nickname: Box<str>,
1332 /// key:Arc<Mutex<usize>>
1333 /// }
1334 /// impl_default!(Doe,name,nickname,key);
1335 /// impl_debug!(Doe,name,nickname,key);
1336 /// impl_drop!(Doe,name,nickname,key);
1337 /// let d = Doe::default();
1338 /// println!("{:?}",d);
1339 ///}
1340 /// ```
1341 ///
1342 #[macro_export]
1343 macro_rules! impl_drop {
1344 ($struct_name:ident, $($key:ident),*) => {
1345 impl Drop for $struct_name {
1346 fn drop(&mut self) {
1347 $(
1348 let _ = &self.$key;
1349 )*
1350 }
1351 }
1352 }
1353 }
1354 /// implement Default,Debug,Display,Clone,Drop for struct
1355 /// ```rust
1356 ///fn main() {
1357 /// use std::sync::{Arc, Mutex};
1358 /// use doe::*;
1359 /// struct Doe{
1360 /// pub name:String,
1361 /// pub nickname: Box<str>,
1362 /// key:Arc<Mutex<usize>>
1363 /// }
1364 /// impl_all!(Doe,name,nickname,key);
1365 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1366 /// let d1 = Doe::default();
1367 /// let d2 = d1.clone();
1368 /// println!("{:?}",d);
1369 /// println!("{}",d1);
1370 ///}
1371 /// ```
1372 #[macro_export]
1373 macro_rules! impl_all {
1374 ($struct_name:ident, $($key:ident),*) => {
1375 $crate::impl_debug!($struct_name, $($key),*);
1376 $crate::impl_display!($struct_name, $($key),*);
1377 $crate::impl_clone!($struct_name, $($key),*);
1378 $crate::impl_drop!($struct_name, $($key),*);
1379 $crate::impl_default!($struct_name, $($key),*);
1380 }
1381 }
1382
1383 ///## implments Bfn struct and bfn! macro for Box<dyn Fn()> trait object
1384 ///```rust
1385 ///fn main() {
1386 /// use doe::DebugPrint;
1387 /// use doe::bfn;
1388 /// use doe::Bfn;
1389 /// #[derive(Debug)]
1390 /// struct Demo<'a>{
1391 /// name:&'a str
1392 /// }
1393 /// let f0 = bfn!(||{println!("ok");});
1394 /// f0.call();
1395 /// fn func()->Demo<'static>{
1396 /// let d = Demo{name: "andrew"};
1397 /// d
1398 /// }
1399 /// let f1 = bfn!(func);
1400 /// f1.call().dprintln();
1401 ///
1402 /// fn sum()->usize{
1403 /// 9+89
1404 /// }
1405 /// let f2 = Bfn::new(Box::new(sum));//or bfn!(sum);
1406 /// f2.call().dprintln();
1407 ///}
1408 ///```
1409 #[macro_export]
1410 macro_rules! bfn {
1411 ($v:expr) => {
1412 $crate::structs::structs::Bfn::new(Box::new($v))
1413 };
1414 }
1415
1416 ///## implments Bts struct and bts! macro for Box<\dyn ToString> trait object
1417 /// ```rust
1418 ///fn main() {
1419 /// use doe::DebugPrint;
1420 /// use doe::Bts;
1421 /// use doe::bts;
1422 /// let mut s:Bts = bts!("Trait Object, it's ");
1423 /// s.push(bts!(100));
1424 /// s.push_str("% safe");
1425 /// s.dprintln();//"Trait Object, it's 100% safe"
1426 /// s.as_bytes().dprintln();//[84, 114, 97, 105, 116, 32, 79, 98, 106, 101, 99, 116, 44, 32, 105, 116, 39, 115, 32, 49, 48, 48, 37, 32, 115, 97, 102, 101]
1427 /// s.chars().dprintln();//['T', 'r', 'a', 'i', 't', ' ', 'O', 'b', 'j', 'e', 'c', 't', ',', ' ', 'i', 't', '\'', 's', ' ', '1', '0', '0', '%', ' ', 's', 'a', 'f', 'e']
1428 /// let b = Into::<Bts>::into("b".to_string());
1429 /// let b = Bts::from("demo");
1430 ///}
1431 ///```
1432 #[macro_export]
1433 macro_rules! bts {
1434 ($v:expr) => {{
1435 $crate::structs::structs::Bts::new(Box::new($v))
1436 }};
1437 }
1438 #[macro_export]
1439 macro_rules! has_powershell {
1440 () => {{
1441 fn has_powershell() -> bool {
1442 use std::process::Command;
1443 let output = Command::new("powershell")
1444 .args(&["-Command", "$PSVersionTable.PSVersion.Major"])
1445 .output()
1446 .expect("Failed to execute PowerShell command");
1447
1448 if output.status.success() {
1449 let _ = String::from_utf8_lossy(&output.stdout);
1450 return true;
1451 } else {
1452 return false;
1453 }
1454 }
1455 has_powershell()
1456 }};
1457 }
1458}