colvec 0.0.3

Struct-of-arrays column vec like Zig's MultiArrayList
Documentation 
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
118
119
120
121
122
123
124

#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(feature = "nightly", feature(allocator_api))]

fn main(){}

// Idea: multi-slice like Vec<T> Derefs to &[T]
// RawColVec Derefs to &RawColSlice
// &RawColSlice has .field1_slice
// RawColVec DerefMuts to &mut RawColSlice
// &mut RawColSlice has .field1_slice_mut
//
// RawColSlice is a ZST but is !Sized to get the fat pointer

#[cfg(test)]
mod tests {
	use ::colvec::*;

	#[cfg(not(feature = "std"))]
	mod global {
		extern crate alloc as core_alloc;
		use core_alloc::alloc::{alloc, dealloc, Layout};
		use core::ptr::NonNull;

		use ::colvec::alloc::{Allocator,AllocError};

		#[derive(Copy, Clone)]
		pub struct Global;

		unsafe impl Allocator for Global {
			#[inline]
			fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
				let non_null=NonNull::new(unsafe{alloc(layout)}).ok_or(AllocError)?;
				Ok(NonNull::slice_from_raw_parts(non_null, layout.size()))
			}
			#[inline]
			unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
				unsafe {dealloc(ptr.as_ptr(), layout) }
			}
		}
		impl Default for Global {
			#[inline]
			fn default() -> Self {
				Global
			}
		}
	}

	#[test]
	fn smoke_test_macro() {
		#[derive(ColVec)]
		struct Test{
			field0:u8,
			field1:i32,
		}

		#[cfg(feature = "std")]
		let mut test=TestColVec::new();
		#[cfg(not(feature = "std"))]
		let mut test=TestColVec::new_in(global::Global);

		test.push(Test{
			field0:255,
			field1:-1,
		});
		test.push(Test{
			field0:1,
			field1:-2,
		});

		test.field0_slice_mut().sort();
		test.field1_slice_mut().sort();

		assert_eq!(&[1,255], test.field0_slice());
		assert_eq!(&[-2,-1], test.field1_slice());
	}

	#[test]
	fn test_zst(){
		#[derive(ColVec)]
		struct ZST{}

		#[cfg(feature = "std")]
		let mut test=ZSTColVec::new();
		#[cfg(not(feature = "std"))]
		let mut test=ZSTColVec::new_in(global::Global);

		test.push(ZST{});
		test.push(ZST{});

		assert_eq!(2, test.len());
	}

	#[test]
	fn test_append() {
		#[derive(ColVec)]
		struct Bug{
			is_red:bool,
			coolness:u64,
		}

		#[cfg(feature = "std")]
		let mut bugs=BugColVec::with_capacity(2);
		#[cfg(not(feature = "std"))]
		let mut bugs=BugColVec::with_capacity_in(2,global::Global);
		bugs.push(Bug{
			is_red:false,
			coolness:1,
		});

		#[cfg(feature = "std")]
		let mut cool_bugs=BugColVec::with_capacity(1);
		#[cfg(not(feature = "std"))]
		let mut cool_bugs=BugColVec::with_capacity_in(1,global::Global);
		cool_bugs.push(Bug{
			is_red:true,
			coolness:1337,
		});

		bugs.append(&mut cool_bugs);

		assert_eq!(&[false,true], bugs.is_red_slice());
		assert_eq!(&[1,1337], bugs.coolness_slice());
	}
}