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 /// 对应`std::vector<bool>`.
347 #[cpp(class = "template<class Allocator> std::vector<bool, Allocator>")]
348 pub class VecBool {
349 /// ```
350 /// use hicc_std::VecBool;
351 /// let vec = VecBool::new();
352 /// assert!(vec.is_empty());
353 /// ```
354 #[cpp(method = "bool empty() const")]
355 pub fn is_empty(&self) -> bool;
356
357 /// ```
358 /// use hicc_std::VecBool;
359 /// let vec = VecBool::new();
360 /// assert_eq!(vec.size(), 0);
361 /// ```
362 #[cpp(method = "size_t size() const")]
363 pub fn size(&self) -> usize;
364
365 /// ```
366 /// use hicc_std::VecBool;
367 /// let vec = VecBool::new();
368 /// println!("vec.max_size = {}", vec.max_size());
369 /// ```
370 #[cpp(method = "size_t max_size() const")]
371 pub fn max_size(&self) -> usize;
372
373 /// ```
374 /// use hicc_std::VecBool;
375 /// let vec = VecBool::new();
376 /// println!("vec.capacity = {}", vec.capacity());
377 /// ```
378 #[cpp(method = "size_t capacity() const")]
379 pub fn capacity(&self) -> usize;
380
381 /// ```
382 /// use hicc_std::VecBool;
383 /// let mut vec = VecBool::new();
384 /// vec.push_back(true);
385 /// vec.clear();
386 /// assert!(vec.is_empty());
387 /// ```
388 #[cpp(method = "void clear()")]
389 pub fn clear(&mut self);
390
391 /// ```
392 /// use hicc_std::VecBool;
393 /// let mut vec = VecBool::new();
394 /// vec.reserve(10_usize);
395 /// assert!(vec.is_empty());
396 /// println!("vec.capacity = {}", vec.capacity());
397 /// ```
398 #[cpp(method = "void reserve(size_t)")]
399 pub fn reserve(&mut self, n: usize);
400
401 /// ```
402 /// use hicc_std::VecBool;
403 /// let mut vec = VecBool::new();
404 /// vec.reserve(10_usize);
405 /// // ...
406 /// vec.shrink_to_fit();
407 /// ```
408 #[cpp(method = "void shrink_to_fit()")]
409 pub fn shrink_to_fit(&mut self);
410
411 /// ```
412 /// use hicc_std::VecBool;
413 /// let mut vec = VecBool::new();
414 /// vec.resize(2, true);
415 /// assert_eq!(vec.size(), 2);
416 /// assert_eq!(vec.back(), Some(true));
417 /// assert_eq!(vec.front(), Some(true));
418 /// ```
419 #[cpp(method = "void resize(size_t, bool)")]
420 pub fn resize(&mut self, n: usize, val: bool);
421
422 /// ```
423 /// use hicc_std::VecBool;
424 /// let mut vec = VecBool::new();
425 /// assert_eq!(vec.get(0), None);
426 /// vec.push_back(true);
427 /// assert_eq!(vec.get(0), Some(true));
428 /// ```
429 pub fn get(&self, pos: usize) -> Option<bool> {
430 if pos < self.size() {
431 return unsafe { Some(self.at(pos)) };
432 }
433 None
434 }
435 #[cpp(method = "bool at(size_t) const")]
436 unsafe fn at(&self, pos: usize) -> bool;
437
438 hicc::cpp! {
439 static void set(Self& self, size_t pos, bool val) {
440 if (pos < self.size()) {
441 self[pos] = val;
442 }
443 }
444 }
445 /// 如果`pos`超出范围，则不做任何修改.
446 /// ```
447 /// use hicc_std::VecBool;
448 /// let mut vec = VecBool::new();
449 /// vec.set(0, false);
450 /// assert_eq!(vec.get(0), None);
451 /// vec.push_back(true);
452 /// assert_eq!(vec.get(0), Some(true));
453 /// vec.set(0, false);
454 /// assert_eq!(vec.get(0), Some(false));
455 /// ```
456 ///
457 #[cpp(func = "void SelfMethods::set(Self&, size_t, bool)")]
458 pub fn set(&mut self, pos: usize, val: bool);
459
460 /// ```
461 /// use hicc_std::VecBool;
462 /// let mut vec = VecBool::new();
463 /// assert_eq!(vec.back(), None);
464 /// vec.push_back(true);
465 /// assert_eq!(vec.back(), Some(true));
466 /// ```
467 pub fn back(&self) -> Option<bool> {
468 if !self.is_empty() {
469 return unsafe { Some(self._back()) };
470 }
471 None
472 }
473 #[cpp(method = "bool back() const")]
474 unsafe fn _back(&self) -> bool;
475
476 /// ```
477 /// use hicc_std::VecBool;
478 /// let mut vec = VecBool::new();
479 /// vec.push_back(true);
480 /// assert_eq!(vec.front(), Some(true));
481 /// ```
482 pub fn front(&self) -> Option<bool> {
483 if !self.is_empty() {
484 return unsafe { Some(self._front()) };
485 }
486 None
487 }
488 #[cpp(method = "bool front() const")]
489 unsafe fn _front(&self) -> bool;
490
491 /// ```
492 /// use hicc_std::VecBool;
493 /// let mut vec = VecBool::new();
494 /// vec.assign(2, true);
495 /// assert_eq!(vec.size(), 2);
496 /// assert_eq!(vec.front(), Some(true));
497 /// assert_eq!(vec.back(), Some(true));
498 /// ```
499 pub fn assign(&mut self, n: usize, val: bool) {
500 self._assign(n, &val);
501 }
502 #[cpp(method = "void assign(size_t, const bool&)")]
503 fn _assign(&mut self, n: usize, val: &bool);
504
505 /// 如果为空不做任何改变.
506 /// ```
507 /// use hicc_std::VecBool;
508 /// let mut vec = VecBool::new();
509 /// vec.pop_back();
510 /// vec.push_back(true);
511 /// vec.pop_back();
512 /// assert!(vec.is_empty());
513 /// ```
514 pub fn pop_back(&mut self) {
515 if !self.is_empty() {
516 unsafe { self._pop_back() };
517 }
518 }
519 #[cpp(method = "void pop_back()")]
520 unsafe fn _pop_back(&mut self);
521
522 /// ```
523 /// use hicc_std::VecBool;
524 /// let mut vec = VecBool::new();
525 /// vec.push_back(true);
526 /// assert_eq!(vec.front(), Some(true));
527 /// ```
528 #[cpp(method = "void push_back(bool)")]
529 pub fn push_back(&mut self, val: bool);
530
531 /// ```
532 /// use hicc_std::VecBool;
533 /// let mut vec = VecBool::new();
534 /// vec.push_back(true);
535 /// vec.swap(&mut VecBool::new());
536 /// assert!(vec.is_empty());
537 /// ```
538 #[cpp(method = "void swap(Self&)")]
539 pub fn swap(&mut self, other: &mut Self);
540
541 hicc::cpp! {
542 static void insert(Self& self, size_t pos, size_t count, bool val) {
543 self.insert(self.begin() + std::min(pos, self.size()), count, val);
544 }
545 }
546 /// 如果pos超出范围则添加到最后.
547 /// ```
548 /// use hicc_std::VecBool;
549 /// let mut vec = VecBool::new();
550 /// vec.insert(0, 2, true);
551 /// vec.insert(vec.size(), 1, false);
552 /// assert_eq!(vec.get(0), Some(true));
553 /// assert_eq!(vec.get(1), Some(true));
554 /// assert_eq!(vec.get(2), Some(false));
555 /// assert_eq!(vec.get(3), None);
556 /// ```
557 #[cpp(func = "void SelfMethods::insert(Self&, size_t, size_t, bool)")]
558 pub fn insert(&mut self, pos: usize, count: usize, val: bool);
559
560 hicc::cpp! {
561 static void erase(Self& self, size_t pos, size_t count) {
562 pos = std::min(pos, self.size());
563 count = std::min(count, self.size() - pos);
564 self.erase(self.begin() + pos, self.begin() + pos + count);
565 }
566 }
567 /// 如果pos超出范围则不做任何改变.
568 /// ```
569 /// use hicc_std::VecBool;
570 /// let mut vec = VecBool::new();
571 /// vec.insert(0, 10, true);
572 /// vec.erase(1, 9);
573 /// assert_eq!(vec.size(), 1);
574 /// assert_eq!(vec.get(0), Some(true));
575 /// ```
576 #[cpp(func = "void SelfMethods::erase(Self&, size_t, size_t)")]
577 pub fn erase(&mut self, pos: usize, count: usize);
578 }
579}
580
581unsafe impl Send for VecBool {}
582unsafe impl Sync for VecBool {}
583
584impl VecBool {
585
586 /// ```
587 /// use hicc_std::VecBool;
588 /// let mut vec = VecBool::new();
589 /// vec.resize(2, false);
590 /// vec.set(0, true);
591 /// let mut it = vec.iter();
592 /// assert_eq!(it.next(), Some(true));
593 /// assert_eq!(it.next(), Some(false));
594 /// assert_eq!(it.next(), None);
595 /// ```
596 pub fn iter(&self) -> impl Iterator<Item = bool> + '_ {
597 VecBoolIter { vec: self, pos: 0 }
598 }
599
600 /// ```
601 /// use hicc_std::VecBool;
602 /// let mut vec = VecBool::new();
603 /// vec.resize(2, false);
604 /// vec.set(0, true);
605 /// let mut it = vec.rev_iter();
606 /// assert_eq!(it.next(), Some(false));
607 /// assert_eq!(it.next(), Some(true));
608 /// assert_eq!(it.next(), None);
609 /// ```
610 pub fn rev_iter(&self) -> impl Iterator<Item = bool> + '_ {
611 VecBoolRevIter {
612 vec: self,
613 pos: self.size(),
614 }
615 }
616}
617
618struct VecBoolIter<'a> {
619 vec: &'a VecBool,
620 pos: usize,
621}
622
623impl Iterator for VecBoolIter<'_> {
624 type Item = bool;
625 fn next(&mut self) -> Option<Self::Item> {
626 if self.pos < self.vec.size() {
627 self.pos += 1;
628 return Some(unsafe { self.vec.at(self.pos - 1) });
629 }
630 None
631 }
632}
633
634struct VecBoolRevIter<'a> {
635 vec: &'a VecBool,
636 pos: usize,
637}
638
639impl Iterator for VecBoolRevIter<'_> {
640 type Item = bool;
641 fn next(&mut self) -> Option<Self::Item> {
642 if self.pos > 0 {
643 self.pos -= 1;
644 return Some(unsafe { self.vec.at(self.pos) });
645 }
646 None
647 }
648}