1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// //! A simple but working vector.

// use std::alloc::{alloc, dealloc, realloc, Layout};

// const DEFAULT_CAPACITY: usize = 4;

// pub struct Vector<T> {
//     ptr: *mut T,
//     len: usize,
//     capacity: usize,
// }

// impl<T> Vector<T> {
//     pub fn new() -> Self {
//         let ptr = unsafe {
//             let layout = Self::layout(DEFAULT_CAPACITY);
//             alloc(layout) as *mut T
//         };
//         Self {
//             ptr,
//             len: 0,
//             capacity: DEFAULT_CAPACITY,
//         }
//     }
//     pub fn push(&mut self, v: T) {
//         unsafe {
//             *self.ptr.add(self.len) = v;
//             self.len += 1;
//             if self.len == self.capacity {
//                 self.ptr = realloc(
//                     self.ptr as *mut u8,
//                     Self::layout(self.capacity),
//                     self.capacity * 2,
//                 ) as *mut T;
//                 self.capacity *= 2;
//             }
//         }
//     }
//     pub fn get(&self, idx: usize) -> Option<&T> {
//         if idx < self.len {
//             unsafe { Some(&*(self.ptr.add(idx))) }
//         } else {
//             None
//         }
//     }
//     pub fn get_mut(&self, idx: usize) -> Option<&mut T> {
//         if idx < self.len {
//             unsafe { Some(&mut *(self.ptr.add(idx))) }
//         } else {
//             None
//         }
//     }
//     pub fn pop(&mut self) -> Option<T> {
//         if self.is_empty() {
//             None
//         } else {
//             self.len -= 1;
//             unsafe { Some(std::ptr::read(self.ptr.add(self.len))) }
//         }
//     }
//     pub fn len(&self) -> usize {
//         self.len
//     }
//     pub fn is_empty(&self) -> bool {
//         self.len() == 0
//     }
//     pub fn capacity(&self) -> usize {
//         self.capacity
//     }
//     unsafe fn layout(size: usize) -> Layout {
//         Layout::from_size_align_unchecked(size, std::mem::size_of::<T>())
//     }
// }

// impl<T> Drop for Vector<T> {
//     fn drop(&mut self) {
//         unsafe { dealloc(self.ptr as *mut u8, Self::layout(self.capacity)) };
//     }
// }

// impl<T> std::ops::Index<usize> for Vector<T> {
//     type Output = T;
//     fn index(&self, index: usize) -> &Self::Output {
//         self.get(index).unwrap()
//     }
// }
// impl<T> std::ops::IndexMut<usize> for Vector<T> {
//     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
//         self.get_mut(index).unwrap()
//     }
// }

// // #[cfg(test)]
// // mod tests {
// //     use super::*;
// //     #[test]
// //     fn test_vector() {
// //         let mut v = Vector::<char>::new();
// //         assert_eq!(v.len(), 0);
// //         assert_eq!(v.capacity(), DEFAULT_CAPACITY);
// //         v.push('1');
// //         assert_eq!(v.len(), 1);
// //         assert_eq!(v.capacity(), DEFAULT_CAPACITY);
// //         assert_eq!(v[0], '1');
// //         v.push('2');
// //         v.push('3');
// //         v.push('4');
// //         v.push('5');
// //         v[4] = 'A';
// //         assert_eq!(v.len(), 5);
// //         assert_eq!(v.capacity(), DEFAULT_CAPACITY * 2);
// //         assert_eq!(v[4], 'A');
// //         let x = v.pop();
// //         assert_eq!(x, Some('A'));
// //         assert_eq!(v.len(), 4);
// //     }
// // }