hicc_std/std_vector.rs
1use hicc::{AbiClass, AbiType, ClassArray, ClassMutArray};
2use std::slice;
3
4hicc::cpp! {
5 #include <vector>
6 #include <algorithm>
7}
8
9hicc::import_class! {
10 #[cpp(class = "template<class T, class Allocator> std::vector<T, Allocator>")]
11 pub class vector<T> {
12 #[cpp(method = "const T* data() const")]
13 fn data(&self) -> *const T;
14 /// ```
15 /// use hicc_std::VecInt;
16 /// let vec = VecInt::new();
17 /// assert!(vec.is_empty());
18 /// ```
19 #[cpp(method = "bool empty() const")]
20 pub fn is_empty(&self) -> bool;
21
22 /// ```
23 /// use hicc_std::VecInt;
24 /// let vec = VecInt::new();
25 /// assert_eq!(vec.size(), 0);
26 /// ```
27 #[cpp(method = "size_t size() const")]
28 pub fn size(&self) -> usize;
29
30 /// ```
31 /// use hicc_std::VecInt;
32 /// let vec = VecInt::new();
33 /// println!("vec.max_size = {}", vec.max_size());
34 /// ```
35 #[cpp(method = "size_t max_size() const")]
36 pub fn max_size(&self) -> usize;
37
38 /// ```
39 /// use hicc_std::VecInt;
40 /// let vec = VecInt::new();
41 /// println!("vec.capacity = {}", vec.capacity());
42 /// ```
43 #[cpp(method = "size_t capacity() const")]
44 pub fn capacity(&self) -> usize;
45
46 /// ```
47 /// use hicc_std::VecInt;
48 /// let mut vec = VecInt::new();
49 /// vec.push_back(&1);
50 /// vec.clear();
51 /// assert!(vec.is_empty());
52 /// ```
53 #[cpp(method = "void clear()")]
54 pub fn clear(&mut self);
55
56 /// ```
57 /// use hicc_std::VecInt;
58 /// let mut vec = VecInt::new();
59 /// vec.reserve(10_usize);
60 /// assert!(vec.is_empty());
61 /// println!("vec.capacity = {}", vec.capacity());
62 /// ```
63 #[cpp(method = "void reserve(size_t)")]
64 pub fn reserve(&mut self, n: usize);
65
66 /// ```
67 /// use hicc_std::VecInt;
68 /// let mut vec = VecInt::new();
69 /// vec.reserve(10_usize);
70 /// vec.shrink_to_fit();
71 /// println!("vec.capacity = {}", vec.capacity());
72 /// ```
73 #[cpp(method = "void shrink_to_fit()")]
74 pub fn shrink_to_fit(&mut self);
75
76 /// ```
77 /// use hicc_std::VecInt;
78 /// let mut vec = VecInt::new();
79 /// vec.resize(10, &1);
80 /// assert_eq!(vec.size(), 10);
81 /// assert_eq!(vec.back(), Some(&1));
82 /// vec.as_slice().iter().for_each(|v| println!("{v}"));
83 /// ```
84 #[cpp(method = "void resize(size_t, const T&)")]
85 pub fn resize(&mut self, n: usize, val: &T);
86
87 /// ```
88 /// use hicc_std::VecInt;
89 /// let mut vec = VecInt::new();
90 /// assert_eq!(vec.get(0), None);
91 /// vec.push_back(&1);
92 /// assert_eq!(vec.get(0), Some(&1));
93 /// ```
94 pub fn get(&self, pos: usize) -> Option<T::OutputRef<'_>> {
95 if pos < self.size() {
96 return unsafe { Some(self.at(pos)) };
97 }
98 None
99 }
100 #[cpp(method = "const T& at(size_t) const")]
101 unsafe fn at(&self, pos: usize) -> &T;
102
103 /// ```
104 /// use hicc_std::VecInt;
105 /// let mut vec = VecInt::new();
106 /// assert_eq!(vec.get(0), None);
107 /// vec.push_back(&1);
108 /// *vec.get_mut(0).unwrap() += 1;
109 /// assert_eq!(vec.get(0), Some(&2));
110 /// ```
111 pub fn get_mut(&mut self, pos: usize) -> Option<T::OutputRefMut<'_>> {
112 if pos < self.size() {
113 return unsafe { Some(self.at_mut(pos)) };
114 }
115 None
116 }
117 #[cpp(method = "T& at(size_t)")]
118 unsafe fn at_mut(&mut self, pos: usize) -> &mut T;
119
120 /// ```
121 /// use hicc_std::VecInt;
122 /// let mut vec = VecInt::new();
123 /// assert_eq!(vec.back(), None);
124 /// vec.push_back(&1);
125 /// assert_eq!(vec.back(), Some(&1));
126 /// ```
127 pub fn back(&self) -> Option<T::OutputRef<'_>> {
128 if !self.is_empty() {
129 return unsafe { Some(self._back()) };
130 }
131 None
132 }
133 #[cpp(method = "const T& back() const")]
134 unsafe fn _back(&self) -> &T;
135
136 /// 1. 如果是`hicc::Pod<T>`，可通过`*back_mut() = <new value>`改为.
137 /// 1. 如果是`c++ class`, 则必须通过`hicc::AbiClass::write`改写.
138 /// ```
139 /// use hicc_std::VecInt;
140 /// let mut vec = VecInt::new();
141 /// assert_eq!(vec.back_mut(), None);
142 /// vec.push_back(&1);
143 /// *vec.back_mut().unwrap() += 1;
144 /// assert_eq!(vec.back(), Some(&2));
145 ///
146 /// use hicc_std::{string, VecString};
147 /// use hicc::AbiClass;
148 /// let mut vec = VecString::new();
149 /// vec.push_back(&string::from(c"hello"));
150 /// assert_eq!(vec.back(), Some(string::from(c"hello").into_ref()));
151 /// vec.back_mut().unwrap().write(string::from(c"world"));
152 /// assert_eq!(vec.back(), Some(string::from(c"world").into_ref()));
153 /// ```
154 pub fn back_mut(&mut self) -> Option<T::OutputRefMut<'_>> {
155 if !self.is_empty() {
156 return unsafe { Some(self._back_mut()) };
157 }
158 None
159 }
160 #[cpp(method = "T& back()")]
161 unsafe fn _back_mut(&mut self) -> &mut T;
162
163 /// ```
164 /// use hicc_std::VecInt;
165 /// let mut vec = VecInt::new();
166 /// assert_eq!(vec.front(), None);
167 /// vec.push_back(&1);
168 /// assert_eq!(vec.front(), Some(&1));
169 /// ```
170 pub fn front(&self) -> Option<T::OutputRef<'_>> {
171 if !self.is_empty() {
172 return unsafe { Some(self._front()) };
173 }
174 None
175 }
176 #[cpp(method = "const T& front() const")]
177 unsafe fn _front(&self) -> &T;
178
179 /// 1. 如果是`hicc::Pod<T>`，可通过`*back_mut() = <new value>`改为.
180 /// 1. 如果是`c++ class`, 则必须通过`hicc::AbiClass::write`改写.
181 /// ```
182 /// use hicc_std::VecInt;
183 /// let mut vec = VecInt::new();
184 /// assert_eq!(vec.front_mut(), None);
185 /// vec.push_back(&1);
186 /// *vec.front_mut().unwrap() += 1;
187 /// assert_eq!(vec.front(), Some(&2));
188 ///
189 /// use hicc_std::{string, VecString};
190 /// use hicc::AbiClass;
191 /// let mut vec = VecString::new();
192 /// vec.push_back(&string::from(c"hello"));
193 /// assert_eq!(vec.front(), Some(string::from(c"hello").into_ref()));
194 /// vec.front_mut().unwrap().write(string::from(c"world"));
195 /// assert_eq!(vec.front(), Some(string::from(c"world").into_ref()));
196 /// ```
197 pub fn front_mut(&mut self) -> Option<T::OutputRefMut<'_>> {
198 if !self.is_empty() {
199 return unsafe { Some(self._front_mut()) };
200 }
201 None
202 }
203
204 #[cpp(method = "T& front()")]
205 unsafe fn _front_mut(&mut self) -> &mut T;
206
207 /// ```
208 /// use hicc_std::VecInt;
209 /// let mut vec = VecInt::new();
210 /// vec.assign(10, &1);
211 /// assert_eq!(vec.size(), 10);
212 /// ```
213 #[cpp(method = "void assign(size_t, const T&)")]
214 pub fn assign(&mut self, n: usize, val: &T);
215
216 /// 如果为空不做任何改变.
217 /// ```
218 /// use hicc_std::VecInt;
219 /// let mut vec = VecInt::new();
220 /// vec.pop_back();
221 /// vec.push_back(&1);
222 /// assert!(!vec.is_empty());
223 /// vec.pop_back();
224 /// assert!(vec.is_empty());
225 /// ```
226 pub fn pop_back(&mut self) {
227 if !self.is_empty() {
228 unsafe { self._pop_back() };
229 }
230 }
231 #[cpp(method = "void pop_back()")]
232 unsafe fn _pop_back(&mut self);
233
234 /// ```
235 /// use hicc_std::VecInt;
236 /// let mut vec = VecInt::new();
237 /// vec.push_back(&1);
238 /// assert_eq!(vec.front(), Some(&1));
239 /// ```
240 #[cpp(method = "void push_back(const T&)")]
241 pub fn push_back(&mut self, val: &T);
242
243 /// ```
244 /// use hicc_std::VecInt;
245 /// let mut vec = VecInt::new();
246 /// vec.push_back(&1);
247 /// vec.swap(&mut VecInt::new());
248 /// assert!(vec.is_empty());
249 /// ```
250 #[cpp(method = "void swap(Self&)")]
251 pub fn swap(&mut self, other: &mut Self);
252
253 hicc::cpp! {
254 static void insert(Self& self, size_t pos, size_t count, const T& val) {
255 self.insert(self.begin() + std::min(pos, self.size()), count, val);
256 }
257 }
258 /// 如果pos超出范围则追加到最后.
259 /// ```
260 /// use hicc_std::VecInt;
261 /// let mut vec = VecInt::new();
262 /// vec.insert(0, 2, &1);
263 /// vec.insert(vec.size(), 1, &2);
264 /// assert_eq!(vec.as_slice(), &[1, 1, 2]);
265 /// ```
266 #[cpp(func = "void SelfMethods::insert(Self&, size_t, size_t, const T&)")]
267 pub fn insert(&mut self, pos: usize, count: usize, val: &T);
268
269 hicc::cpp! {
270 static void erase(Self& self, size_t pos, size_t count) {
271 pos = std::min(pos, self.size());
272 count = std::min(count, self.size() - pos);
273 self.erase(self.begin() + pos, self.begin() + pos + count);
274 }
275 }
276 /// 如果pos超出范围则不做任何改变.
277 /// ```
278 /// use hicc_std::VecInt;
279 /// let mut vec = VecInt::new();
280 /// vec.insert(0, 10, &2);
281 /// vec.erase(1, 9);
282 /// assert_eq!(vec.size(), 1);
283 /// ```
284 #[cpp(func = "void SelfMethods::erase(Self&, size_t, size_t)")]
285 pub fn erase(&mut self, pos: usize, count: usize);
286 }
287}
288
289unsafe impl<T: AbiType + Sync> Send for vector<T> {}
290unsafe impl<T: AbiType + Sync> Sync for vector<T> {}
291
292impl<T: Sized + 'static> vector<hicc::Pod<T>> {
293 /// ```
294 /// use hicc_std::VecInt;
295 /// let mut vec = VecInt::new();
296 /// vec.insert(0, 2, &2);
297 /// assert_eq!(vec.as_slice(), &[2, 2]);
298 /// ```
299 pub fn as_slice(&self) -> &[T] {
300 let data = self.data();
301 let size = self.size();
302 unsafe { slice::from_raw_parts(data, size) }
303 }
304
305 /// ```
306 /// use hicc_std::VecInt;
307 /// let mut vec = VecInt::new();
308 /// vec.insert(0, 2, &2);
309 /// vec.as_slice_mut().iter_mut().for_each(|v| {*v += 1;});
310 /// assert_eq!(vec.as_slice(), &[3, 3]);
311 /// ```
312 pub fn as_slice_mut(&mut self) -> &mut [T] {
313 let data = self.data();
314 let size = self.size();
315 unsafe { slice::from_raw_parts_mut(data.cast_mut(), size) }
316 }
317}
318
319impl<T: AbiClass + 'static> vector<T> {
320 /// ```
321 /// use hicc_std::{VecString, string};
322 /// let mut vec = VecString::new();
323 /// let msg = string::with_cstr(c"hello");
324 /// vec.insert(0, 10, &msg);
325 /// vec.as_array().iter().for_each(|msg| { println!("msg.size() = {}", msg.size()); });
326 /// ```
327 pub fn as_array(&self) -> ClassArray<'_, T> {
328 unsafe { self.data().into_array(self.size()) }
329 }
330}
331
332impl<T: AbiClass + 'static> vector<T> {
333 /// ```
334 /// use hicc_std::{VecString, string};
335 /// let mut vec = VecString::new();
336 /// let msg = string::with_cstr(c"hello");
337 /// vec.insert(0, 10, &msg);
338 /// vec.as_mut_array().iter_mut().for_each(|mut msg| { msg.append(1, b'c' as i8); });
339 /// ```
340 pub fn as_mut_array(&mut self) -> ClassMutArray<'_, T> {
341 unsafe { self.data().into_mut_ptr().into_mut_array(self.size()) }
342 }
343}
344
345hicc::import_class! {
346 #[cpp(class = "template<class Allocator> std::vector<bool, Allocator>")]
347 pub class VecBool {
348 /// ```
349 /// use hicc_std::VecBool;
350 /// let vec = VecBool::new();
351 /// assert!(vec.is_empty());
352 /// ```
353 #[cpp(method = "bool empty() const")]
354 pub fn is_empty(&self) -> bool;
355
356 /// ```
357 /// use hicc_std::VecBool;
358 /// let vec = VecBool::new();
359 /// assert_eq!(vec.size(), 0);
360 /// ```
361 #[cpp(method = "size_t size() const")]
362 pub fn size(&self) -> usize;
363
364 /// ```
365 /// use hicc_std::VecBool;
366 /// let vec = VecBool::new();
367 /// println!("vec.max_size = {}", vec.max_size());
368 /// ```
369 #[cpp(method = "size_t max_size() const")]
370 pub fn max_size(&self) -> usize;
371
372 /// ```
373 /// use hicc_std::VecBool;
374 /// let vec = VecBool::new();
375 /// println!("vec.capacity = {}", vec.capacity());
376 /// ```
377 #[cpp(method = "size_t capacity() const")]
378 pub fn capacity(&self) -> usize;
379
380 /// ```
381 /// use hicc_std::VecBool;
382 /// let mut vec = VecBool::new();
383 /// vec.push_back(true);
384 /// vec.clear();
385 /// assert!(vec.is_empty());
386 /// ```
387 #[cpp(method = "void clear()")]
388 pub fn clear(&mut self);
389
390 /// ```
391 /// use hicc_std::VecBool;
392 /// let mut vec = VecBool::new();
393 /// vec.reserve(10_usize);
394 /// assert!(vec.is_empty());
395 /// println!("vec.capacity = {}", vec.capacity());
396 /// ```
397 #[cpp(method = "void reserve(size_t)")]
398 pub fn reserve(&mut self, n: usize);
399
400 /// ```
401 /// use hicc_std::VecBool;
402 /// let mut vec = VecBool::new();
403 /// vec.reserve(10_usize);
404 /// // ...
405 /// vec.shrink_to_fit();
406 /// ```
407 #[cpp(method = "void shrink_to_fit()")]
408 pub fn shrink_to_fit(&mut self);
409
410 /// ```
411 /// use hicc_std::VecBool;
412 /// let mut vec = VecBool::new();
413 /// vec.resize(2, true);
414 /// assert_eq!(vec.size(), 2);
415 /// assert_eq!(vec.back(), Some(true));
416 /// assert_eq!(vec.front(), Some(true));
417 /// ```
418 #[cpp(method = "void resize(size_t, bool)")]
419 pub fn resize(&mut self, n: usize, val: bool);
420
421 /// ```
422 /// use hicc_std::VecBool;
423 /// let mut vec = VecBool::new();
424 /// assert_eq!(vec.get(0), None);
425 /// vec.push_back(true);
426 /// assert_eq!(vec.get(0), Some(true));
427 /// ```
428 pub fn get(&self, pos: usize) -> Option<bool> {
429 if pos < self.size() {
430 return unsafe { Some(self.at(pos)) };
431 }
432 None
433 }
434 #[cpp(method = "bool at(size_t) const")]
435 unsafe fn at(&self, pos: usize) -> bool;
436
437 hicc::cpp! {
438 static void set(Self& self, size_t pos, bool val) {
439 if (pos < self.size()) {
440 self[pos] = val;
441 }
442 }
443 }
444 /// 如果`pos`超出范围，则不做任何修改.
445 /// ```
446 /// use hicc_std::VecBool;
447 /// let mut vec = VecBool::new();
448 /// vec.set(0, false);
449 /// assert_eq!(vec.get(0), None);
450 /// vec.push_back(true);
451 /// assert_eq!(vec.get(0), Some(true));
452 /// vec.set(0, false);
453 /// assert_eq!(vec.get(0), Some(false));
454 /// ```
455 ///
456 #[cpp(func = "void SelfMethods::set(Self&, size_t, bool)")]
457 pub fn set(&mut self, pos: usize, val: bool);
458
459 /// ```
460 /// use hicc_std::VecBool;
461 /// let mut vec = VecBool::new();
462 /// assert_eq!(vec.back(), None);
463 /// vec.push_back(true);
464 /// assert_eq!(vec.back(), Some(true));
465 /// ```
466 pub fn back(&self) -> Option<bool> {
467 if !self.is_empty() {
468 return unsafe { Some(self._back()) };
469 }
470 None
471 }
472 #[cpp(method = "bool back() const")]
473 unsafe fn _back(&self) -> bool;
474
475 /// ```
476 /// use hicc_std::VecBool;
477 /// let mut vec = VecBool::new();
478 /// vec.push_back(true);
479 /// assert_eq!(vec.front(), Some(true));
480 /// ```
481 pub fn front(&self) -> Option<bool> {
482 if !self.is_empty() {
483 return unsafe { Some(self._front()) };
484 }
485 None
486 }
487 #[cpp(method = "bool front() const")]
488 unsafe fn _front(&self) -> bool;
489
490 /// ```
491 /// use hicc_std::VecBool;
492 /// let mut vec = VecBool::new();
493 /// vec.assign(2, true);
494 /// assert_eq!(vec.size(), 2);
495 /// assert_eq!(vec.front(), Some(true));
496 /// assert_eq!(vec.back(), Some(true));
497 /// ```
498 pub fn assign(&mut self, n: usize, val: bool) {
499 self._assign(n, &val);
500 }
501 #[cpp(method = "void assign(size_t, const bool&)")]
502 fn _assign(&mut self, n: usize, val: &bool);
503
504 /// 如果为空不做任何改变.
505 /// ```
506 /// use hicc_std::VecBool;
507 /// let mut vec = VecBool::new();
508 /// vec.pop_back();
509 /// vec.push_back(true);
510 /// vec.pop_back();
511 /// assert!(vec.is_empty());
512 /// ```
513 pub fn pop_back(&mut self) {
514 if !self.is_empty() {
515 unsafe { self._pop_back() };
516 }
517 }
518 #[cpp(method = "void pop_back()")]
519 unsafe fn _pop_back(&mut self);
520
521 hicc::cpp! {
522 static void push_back(Self& self, bool val) {
523 self.push_back(val);
524 }
525 }
526 /// ```
527 /// use hicc_std::VecBool;
528 /// let mut vec = VecBool::new();
529 /// vec.push_back(true);
530 /// assert_eq!(vec.front(), Some(true));
531 /// ```
532 #[cpp(func = "void SelfMethods::push_back(Self&, bool)")]
533 pub fn push_back(&mut self, val: bool);
534
535 /// ```
536 /// use hicc_std::VecBool;
537 /// let mut vec = VecBool::new();
538 /// vec.push_back(true);
539 /// vec.swap(&mut VecBool::new());
540 /// assert!(vec.is_empty());
541 /// ```
542 #[cpp(method = "void swap(Self&)")]
543 pub fn swap(&mut self, other: &mut Self);
544
545 hicc::cpp! {
546 static void insert(Self& self, size_t pos, size_t count, bool val) {
547 self.insert(self.begin() + std::min(pos, self.size()), count, val);
548 }
549 }
550 /// 如果pos超出范围则添加到最后.
551 /// ```
552 /// use hicc_std::VecBool;
553 /// let mut vec = VecBool::new();
554 /// vec.insert(0, 2, true);
555 /// vec.insert(vec.size(), 1, false);
556 /// assert_eq!(vec.get(0), Some(true));
557 /// assert_eq!(vec.get(1), Some(true));
558 /// assert_eq!(vec.get(2), Some(false));
559 /// assert_eq!(vec.get(3), None);
560 /// ```
561 #[cpp(func = "void SelfMethods::insert(Self&, size_t, size_t, bool)")]
562 pub fn insert(&mut self, pos: usize, count: usize, val: bool);
563
564 hicc::cpp! {
565 static void erase(Self& self, size_t pos, size_t count) {
566 pos = std::min(pos, self.size());
567 count = std::min(count, self.size() - pos);
568 self.erase(self.begin() + pos, self.begin() + pos + count);
569 }
570 }
571 /// 如果pos超出范围则不做任何改变.
572 /// ```
573 /// use hicc_std::VecBool;
574 /// let mut vec = VecBool::new();
575 /// vec.insert(0, 10, true);
576 /// vec.erase(1, 9);
577 /// assert_eq!(vec.size(), 1);
578 /// assert_eq!(vec.get(0), Some(true));
579 /// ```
580 #[cpp(func = "void SelfMethods::erase(Self&, size_t, size_t)")]
581 pub fn erase(&mut self, pos: usize, count: usize);
582 }
583}
584
585unsafe impl Send for VecBool {}
586unsafe impl Sync for VecBool {}
587
588impl VecBool {
589
590 /// ```
591 /// use hicc_std::VecBool;
592 /// let mut vec = VecBool::new();
593 /// vec.resize(2, false);
594 /// vec.set(0, true);
595 /// let mut it = vec.iter();
596 /// assert_eq!(it.next(), Some(true));
597 /// assert_eq!(it.next(), Some(false));
598 /// assert_eq!(it.next(), None);
599 /// ```
600 pub fn iter(&self) -> impl Iterator<Item = bool> + '_ {
601 VecBoolIter { vec: self, pos: 0 }
602 }
603
604 /// ```
605 /// use hicc_std::VecBool;
606 /// let mut vec = VecBool::new();
607 /// vec.resize(2, false);
608 /// vec.set(0, true);
609 /// let mut it = vec.rev_iter();
610 /// assert_eq!(it.next(), Some(false));
611 /// assert_eq!(it.next(), Some(true));
612 /// assert_eq!(it.next(), None);
613 /// ```
614 pub fn rev_iter(&self) -> impl Iterator<Item = bool> + '_ {
615 VecBoolRevIter {
616 vec: self,
617 pos: self.size(),
618 }
619 }
620}
621
622struct VecBoolIter<'a> {
623 vec: &'a VecBool,
624 pos: usize,
625}
626
627impl Iterator for VecBoolIter<'_> {
628 type Item = bool;
629 fn next(&mut self) -> Option<Self::Item> {
630 if self.pos < self.vec.size() {
631 self.pos += 1;
632 return Some(unsafe { self.vec.at(self.pos - 1) });
633 }
634 None
635 }
636}
637
638struct VecBoolRevIter<'a> {
639 vec: &'a VecBool,
640 pos: usize,
641}
642
643impl Iterator for VecBoolRevIter<'_> {
644 type Item = bool;
645 fn next(&mut self) -> Option<Self::Item> {
646 if self.pos > 0 {
647 self.pos -= 1;
648 return Some(unsafe { self.vec.at(self.pos) });
649 }
650 None
651 }
652}