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 /// println!("has stable compiler: {v1}");
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 a function once after a particularized delay(millis)
1026 /// ```ignore
1027 /// use doe::*;
1028 ///set_timeout!(||{
1029 /// println!("ok");
1030 ///},3000);
1031 ///```
1032 #[cfg(not(target_arch = "wasm32"))]
1033 #[macro_export]
1034 macro_rules! set_timeout {
1035 ($fn:expr,$time:expr) => {{
1036 fn set_timeout<F>(mut func: F, time: u64)
1037 where
1038 F: Copy + Fn(),
1039 {
1040 use std::time::Duration;
1041 std::thread::sleep(Duration::from_millis(time));
1042 func();
1043 }
1044 set_timeout($fn, $time);
1045 }};
1046 }
1047
1048 ///## run a function repeatedly, beginning after some millis, then repeating continuously at the given interval.
1049 /// ```ignore
1050 /// use doe::*;
1051 ///set_interval!(||{
1052 /// println!("ok");
1053 ///},3000);
1054 ///```
1055 #[cfg(not(target_arch = "wasm32"))]
1056 #[macro_export]
1057 macro_rules! set_interval {
1058 ($fn:expr,$time:expr) => {{
1059 loop {
1060 set_timeout!($fn, $time);
1061 }
1062 }};
1063 }
1064
1065 ///## get current UTC-timestamp
1066 /// ```rust
1067 /// use doe::*;
1068 /// let t = utc_timestamp!();
1069 /// eprintln!("{}", t);
1070 /// ```
1071 #[cfg(not(target_arch = "wasm32"))]
1072 #[macro_export]
1073 macro_rules! utc_timestamp {
1074 () => {{
1075 std::time::SystemTime::now()
1076 .duration_since(std::time::SystemTime::UNIX_EPOCH)
1077 .unwrap_or_default()
1078 .as_secs_f64()
1079 }};
1080 }
1081
1082 ///## macro for HashMap
1083 ///```rust
1084 /// use doe::*;
1085 /// use std::collections::HashMap;
1086 /// let mut map:HashMap<i32,i32> = hashmap!();
1087 /// map.insert(0, 1);
1088 /// let map1 = hashmap!(2=>5,3=>4);
1089 ///```
1090 #[macro_export]
1091 macro_rules! hashmap {
1092 () => {{
1093 std::collections::HashMap::new()
1094 }};
1095 ($(||)+) => {{
1096 std::collections::HashMap::new
1097 }};
1098 ($($k: expr => $v: expr),+ $(,)*) => {{
1099 let mut m = std::collections::HashMap::with_capacity([$(&$k),*].len());
1100 $(m.insert($k, $v);)*
1101 m
1102 }};
1103
1104 }
1105 ///## macro for BTreeMap
1106 ///```rust
1107 /// use doe::*;
1108 /// use std::collections::BTreeMap;
1109 /// let mut map:BTreeMap<i32,i32> = btreemap!();
1110 /// map.insert(0, 1);
1111 /// let map1 = btreemap!(2=>5,3=>4);
1112 ///```
1113 #[macro_export]
1114 macro_rules! btreemap {
1115 () => {{
1116 std::collections::BTreeMap::new()
1117 }};
1118 ($(||)+) => {{
1119 std::collections::BTreeMap::new
1120 }};
1121 ($($k: expr => $v: expr),+ $(,)*) => {{
1122 let mut m = std::collections::BTreeMap::new();
1123 $(m.insert($k, $v);)*
1124 m
1125 }};
1126
1127 }
1128 /// ## implment targets! for return Vec<(Box\<dyn ToString>,Box\<dyn ToString>)>
1129 /// ```rust
1130 ///fn main() {
1131 /// use doe::Print;
1132 /// use doe::Str;
1133 /// "this is a {s},I like Trait Object {p}%"
1134 /// .format(vec![(Box::new("{s}"),Box::new("demo")),(Box::new("{p}"),Box::new(100))]).println();//this is a demo,I like Trait Object 100%
1135 /// use doe::targets;
1136 /// "this is a {d},I like Trait Object {p}}%"
1137 /// .format(targets!{"{d}"=>"demo","{p}"=>100})
1138 /// .println(); //this is a demo,I like Trait Object 100%
1139 ///}
1140 /// ```
1141 #[macro_export]
1142 macro_rules! targets {
1143 ($($key:expr => $value:expr),*) => {
1144 vec![
1145 $((Box::new($key), Box::new($value))),*
1146 ]
1147 };
1148 }
1149 /// implmemt Display for Struct
1150 /// ```rust
1151 ///fn main() {
1152 /// use std::sync::{Arc, Mutex};
1153 /// use doe::*;
1154 /// struct Doe{
1155 /// pub name:String,
1156 /// pub nickname: Box<str>,
1157 /// key:Arc<Mutex<usize>>
1158 /// }
1159 /// impl_display!(Doe,name,nickname,key);
1160 /// impl_debug!(Doe,name,nickname,key);
1161 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1162 /// println!("{:?}",d);
1163 /// println!("{}",d);
1164 ///}
1165 /// ```
1166 ///
1167 #[macro_export]
1168 macro_rules! impl_display {
1169 ($struct_name:ident, $($key:ident),*) => {
1170 impl std::fmt::Display for $struct_name {
1171 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1172 write!(f, "{} {{", stringify!($struct_name))?;
1173 $(
1174 write!(f, " {}: {:?},", stringify!($key), self.$key)?;
1175 )*
1176 write!(f, "}}")
1177 }
1178 }
1179 };
1180 }
1181 /// implmemt Debug for Struct
1182 /// ```rust
1183 ///fn main() {
1184 /// use std::sync::{Arc, Mutex};
1185 /// use doe::*;
1186 /// struct Doe{
1187 /// pub name:String,
1188 /// pub nickname: Box<str>,
1189 /// key:Arc<Mutex<usize>>
1190 /// }
1191 /// impl_display!(Doe,name,nickname,key);
1192 /// impl_debug!(Doe,name,nickname,key);
1193 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1194 /// println!("{:?}",d);
1195 /// println!("{}",d);
1196 ///}
1197 /// ```
1198 ///
1199 #[macro_export]
1200 macro_rules! impl_debug {
1201 ($struct_name:ident, $($key:ident),*) => {
1202 impl std::fmt::Debug for $struct_name {
1203 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1204 f.debug_struct(stringify!($struct_name))
1205 $(.field(stringify!($key), &self.$key))*
1206 .finish()
1207 }
1208 }
1209 };
1210 }
1211 /// implmemt Clone for Struct
1212 /// ```rust
1213 ///fn main() {
1214 /// use std::sync::{Arc, Mutex};
1215 /// use doe::*;
1216 /// struct Doe{
1217 /// pub name:String,
1218 /// pub nickname: Box<str>,
1219 /// key:Arc<Mutex<usize>>
1220 /// }
1221 /// impl_clone!(Doe,name,nickname,key);
1222 /// impl_debug!(Doe,name,nickname,key);
1223 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1224 /// println!("{:?}",d.clone());
1225 ///}
1226 /// ```
1227 ///
1228 #[macro_export]
1229 macro_rules! impl_clone {
1230 ($struct_name:ident, $($key:ident),*) => {
1231 impl Clone for $struct_name {
1232 fn clone(&self) -> Self {
1233 // clone each element
1234 $(
1235 let $key = self.$key.clone();
1236 )*
1237
1238 // create a new instance
1239 $struct_name {
1240 $(
1241 $key,
1242 )*
1243 }
1244 }
1245 }
1246 }
1247 }
1248 /// implmemt Default for Struct
1249 /// ```rust
1250 ///fn main() {
1251 /// use std::sync::{Arc, Mutex};
1252 /// use doe::*;
1253 /// struct Doe{
1254 /// pub name:String,
1255 /// pub nickname: Box<str>,
1256 /// key:Arc<Mutex<usize>>
1257 /// }
1258 /// impl_default!(Doe,name,nickname,key);
1259 /// impl_debug!(Doe,name,nickname,key);
1260 /// let d = Doe::default();
1261 /// println!("{:?}",d);
1262 ///}
1263 /// ```
1264 ///
1265 #[macro_export]
1266 macro_rules! impl_default {
1267 ($struct_name:ident, $($key:ident),*) => {
1268 impl Default for $struct_name {
1269 fn default() -> Self {
1270 $struct_name {
1271 $(
1272 $key: Default::default(),
1273 )*
1274 }
1275 }
1276 }
1277 }
1278 }
1279 /// implmemt Drop for Struct
1280 /// ```rust
1281 ///fn main() {
1282 /// use std::sync::{Arc, Mutex};
1283 /// use doe::*;
1284 /// struct Doe{
1285 /// pub name:String,
1286 /// pub nickname: Box<str>,
1287 /// key:Arc<Mutex<usize>>
1288 /// }
1289 /// impl_default!(Doe,name,nickname,key);
1290 /// impl_debug!(Doe,name,nickname,key);
1291 /// impl_drop!(Doe,name,nickname,key);
1292 /// let d = Doe::default();
1293 /// println!("{:?}",d);
1294 ///}
1295 /// ```
1296 ///
1297 #[macro_export]
1298 macro_rules! impl_drop {
1299 ($struct_name:ident, $($key:ident),*) => {
1300 impl Drop for $struct_name {
1301 fn drop(&mut self) {
1302 $(
1303 let _ = &self.$key;
1304 )*
1305 }
1306 }
1307 }
1308 }
1309 /// implement Default,Debug,Display,Clone,Drop for struct
1310 /// ```rust
1311 ///fn main() {
1312 /// use std::sync::{Arc, Mutex};
1313 /// use doe::*;
1314 /// struct Doe{
1315 /// pub name:String,
1316 /// pub nickname: Box<str>,
1317 /// key:Arc<Mutex<usize>>
1318 /// }
1319 /// impl_all!(Doe,name,nickname,key);
1320 /// let d = Doe{name:"andrew".to_string(), nickname: Box::from("func"),key:Arc::new(Mutex::new(15))};
1321 /// let d1 = Doe::default();
1322 /// let d2 = d1.clone();
1323 /// println!("{:?}",d);
1324 /// println!("{}",d1);
1325 ///}
1326 /// ```
1327 #[macro_export]
1328 macro_rules! impl_all {
1329 ($struct_name:ident, $($key:ident),*) => {
1330 $crate::impl_debug!($struct_name, $($key),*);
1331 $crate::impl_display!($struct_name, $($key),*);
1332 $crate::impl_clone!($struct_name, $($key),*);
1333 $crate::impl_drop!($struct_name, $($key),*);
1334 $crate::impl_default!($struct_name, $($key),*);
1335 }
1336 }
1337
1338 ///## implments Bfn struct and bfn! macro for Box<dyn Fn()> trait object
1339 ///```rust
1340 ///fn main() {
1341 /// use doe::DebugPrint;
1342 /// use doe::bfn;
1343 /// use doe::Bfn;
1344 /// #[derive(Debug)]
1345 /// struct Demo<'a>{
1346 /// name:&'a str
1347 /// }
1348 /// let f0 = bfn!(||{println!("ok");});
1349 /// f0.call();
1350 /// fn func()->Demo<'static>{
1351 /// let d = Demo{name: "andrew"};
1352 /// d
1353 /// }
1354 /// let f1 = bfn!(func);
1355 /// f1.call().dprintln();
1356 ///
1357 /// fn sum()->usize{
1358 /// 9+89
1359 /// }
1360 /// let f2 = Bfn::new(Box::new(sum));//or bfn!(sum);
1361 /// f2.call().dprintln();
1362 ///}
1363 ///```
1364 #[macro_export]
1365 macro_rules! bfn {
1366 ($v:expr) => {
1367 $crate::structs::structs::Bfn::new(Box::new($v))
1368 };
1369 }
1370
1371 ///## implments Bts struct and bts! macro for Box<\dyn ToString> trait object
1372 /// ```rust
1373 ///fn main() {
1374 /// use doe::DebugPrint;
1375 /// use doe::Bts;
1376 /// use doe::bts;
1377 /// let mut s:Bts = bts!("Trait Object, it's ");
1378 /// s.push(bts!(100));
1379 /// s.push_str("% safe");
1380 /// s.dprintln();//"Trait Object, it's 100% safe"
1381 /// 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]
1382 /// s.chars().dprintln();//['T', 'r', 'a', 'i', 't', ' ', 'O', 'b', 'j', 'e', 'c', 't', ',', ' ', 'i', 't', '\'', 's', ' ', '1', '0', '0', '%', ' ', 's', 'a', 'f', 'e']
1383 /// let b = Into::<Bts>::into("b".to_string());
1384 /// let b = Bts::from("demo");
1385 ///}
1386 ///```
1387 #[macro_export]
1388 macro_rules! bts {
1389 ($v:expr) => {{
1390 $crate::structs::structs::Bts::new(Box::new($v))
1391 }};
1392 }
1393 #[macro_export]
1394 macro_rules! has_powershell {
1395 () => {{
1396 fn has_powershell() -> bool {
1397 use std::process::Command;
1398 let output = Command::new("powershell")
1399 .args(&["-Command", "$PSVersionTable.PSVersion.Major"])
1400 .output()
1401 .expect("Failed to execute PowerShell command");
1402
1403 if output.status.success() {
1404 let _ = String::from_utf8_lossy(&output.stdout);
1405 return true;
1406 } else {
1407 return false;
1408 }
1409 }
1410 has_powershell()
1411 }};
1412 }
1413}