revorbis/
utils.rs

1use std::{
2    fmt::{self, Debug, Display, Formatter},
3};
4
5use crate::*;
6
7/// * Format array in a specific patterns
8#[macro_export]
9macro_rules! format_array {
10    () => {
11        "".to_string()
12    };
13    ($data:expr) => {
14        format_array!($data, ", ", "{}")
15    };
16    ($data:expr, hex2) => {
17        format_array!($data, " ", "{:02x}")
18    };
19    ($data:expr, hex4) => {
20        format_array!($data, " ", "{:04x}")
21    };
22    ($data:expr, hex8) => {
23        format_array!($data, " ", "{:08x}")
24    };
25    ($data:expr, hex2arr) => {
26        format_array!($data, ", ", "0x{:02x}")
27    };
28    ($data:expr, hex4arr) => {
29        format_array!($data, ", ", "0x{:04x}")
30    };
31    ($data:expr, hex8arr) => {
32        format_array!($data, ", ", "0x{:08x}")
33    };
34    ($data:expr, debug) => {
35        format_array!($data, ", ", "{:?}")
36    };
37    ($data:expr, $delims:expr, $($arg:tt)*) => {
38        $data.iter().map(|&v|format!($($arg)*, v)).collect::<Vec<_>>().join($delims)
39    };
40}
41
42pub struct NestVecFormatter<'a, T>
43where
44    T: Display + Copy {
45    vec: &'a Vec<T>,
46}
47
48impl<'a, T> NestVecFormatter<'a, T>
49where
50    T: Display + Copy {
51    pub fn new(vec: &'a Vec<T>) -> Self {
52        Self {
53            vec,
54        }
55    }
56
57    pub fn new_level1(vec: &'a Vec<Vec<T>>) -> Vec<Self> {
58        let mut ret = Vec::with_capacity(vec.len());
59        for v in vec.iter() {
60            ret.push(Self::new(&v))
61        }
62        ret
63    }
64
65    pub fn new_level2(vec: &'a Vec<Vec<Vec<T>>>) -> Vec<Vec<Self>> {
66        let mut ret = Vec::with_capacity(vec.len());
67        for v in vec.iter() {
68            let mut new_v = Vec::with_capacity(v.len());
69            for v in v.iter() {
70                new_v.push(Self::new(&v))
71            }
72            ret.push(new_v)
73        }
74        ret
75    }
76}
77
78impl<T> Debug for NestVecFormatter<'_, T>
79where
80    T: Display + Copy {
81    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
82        f.debug_list()
83        .entries(&[format_args!("[{}]", format_array!(&self.vec))])
84        .finish()
85    }
86}
87
88#[macro_export]
89macro_rules! debugln {
90    () => {
91        if SHOW_DEBUG {
92            println!("");
93        }
94    };
95    ($($arg:tt)*) => {
96        if SHOW_DEBUG {
97            println!($($arg)*);
98        }
99    };
100}
101
102#[macro_export]
103macro_rules! return_Err {
104    ($error:expr) => {
105        if PANIC_ON_ERROR {
106            panic!("{:?}", $error)
107        } else {
108            return Err($error)
109        }
110    }
111}
112
113#[macro_export]
114macro_rules! derive_index {
115    ($object:ident, $target:ident, $member:tt) => {
116        use std::ops::{Index, IndexMut, Range, RangeFrom, RangeTo, RangeFull};
117
118        impl Index<usize> for $object {
119            type Output = $target;
120
121            #[track_caller]
122            fn index(&self, index: usize) -> &$target {
123                &self.$member[index]
124            }
125        }
126
127        impl IndexMut<usize> for $object {
128            #[track_caller]
129            fn index_mut(&mut self, index: usize) -> &mut $target {
130                &mut self.$member[index]
131            }
132        }
133
134        impl Index<Range<usize>> for $object {
135            type Output = [$target];
136
137            #[track_caller]
138            fn index(&self, range: Range<usize>) -> &[$target] {
139                &self.$member[range]
140            }
141        }
142
143        impl IndexMut<Range<usize>> for $object {
144            #[track_caller]
145            fn index_mut(&mut self, range: Range<usize>) -> &mut [$target] {
146                &mut self.$member[range]
147            }
148        }
149
150        impl Index<RangeFrom<usize>> for $object {
151            type Output = [$target];
152
153            #[track_caller]
154            fn index(&self, range: RangeFrom<usize>) -> &[$target] {
155                &self.$member[range]
156            }
157        }
158
159        impl IndexMut<RangeFrom<usize>> for $object {
160            #[track_caller]
161            fn index_mut(&mut self, range: RangeFrom<usize>) -> &mut [$target] {
162                &mut self.$member[range]
163            }
164        }
165
166        impl Index<RangeTo<usize>> for $object {
167            type Output = [$target];
168
169            #[track_caller]
170            fn index(&self, range: RangeTo<usize>) -> &[$target] {
171                &self.$member[range]
172            }
173        }
174
175        impl IndexMut<RangeTo<usize>> for $object {
176            #[track_caller]
177            fn index_mut(&mut self, range: RangeTo<usize>) -> &mut [$target] {
178                &mut self.$member[range]
179            }
180        }
181
182        impl Index<RangeFull> for $object {
183            type Output = [$target];
184
185            #[track_caller]
186            fn index(&self, _range: RangeFull) -> &[$target] {
187                &self.$member[..]
188            }
189        }
190
191        impl IndexMut<RangeFull> for $object {
192            #[track_caller]
193            fn index_mut(&mut self, _range: RangeFull) -> &mut [$target] {
194                &mut self.$member[..]
195            }
196        }
197    }
198}
199
200#[macro_export]
201macro_rules! rint {
202    ($x:expr) => {
203        ($x.floor() + 0.5) as i32
204    };
205}
206
207#[macro_export]
208macro_rules! vecvec {
209    [[$val:expr; $len1:expr]; $len2:expr] => {
210        (0..$len2).map(|_|vec![$val; $len1]).collect::<Vec<_>>()
211    }
212}
213
214#[macro_export]
215macro_rules! field {
216    ($prev:ident, $self:ident, $field:tt) => {
217        $prev.field(stringify!($field), &$self.$field)
218    }
219}
220
221#[macro_export]
222macro_rules! field_array {
223    ($prev:ident, $self:ident, $field:tt) => {
224        $prev.field(stringify!($field), &format_args!("[{}]", format_array!($self.$field)))
225    }
226}
revorbis/utils.rs

revorbis/
utils.rs
