asar coverage - build #321 - src/asar/autoarray.h

Line	Branch	Exec	Source
1			#pragma once
2
3			#include "std-includes.h"
4
5			//Note: T must be a pointer type, or stuff will screw up. To make a pointer last longer than this object, assign nullptr to it and it won't free the old one.
6			template<typename T> class autoptr {
7			T ptr;
8			public:
9		261079	operator T() const
10			{
11		261079	return ptr;
12			}
13
14		402	autoptr& operator=(T ptr_)
15			{
16		402	ptr = ptr_;
17		402	return *this;
18			}
19
20		522	autoptr()
21			{
22		522	ptr = nullptr;
23		522	}
24
25		89179	autoptr(T ptr_)
26			{
27		89179	ptr = ptr_;
28		89179	}
29
30			autoptr(const autoptr<T>& ptr_)
31			{
32			ptr = ptr_.ptr;
33			}
34
35		89701	~autoptr()
36			{
37	3/3 ✓ Branch 0 taken 39933 times. ✓ Branch 1 taken 40318 times. ✓ Branch 2 taken 60 times.	89701	if (ptr) free((void*)ptr);
38		89701	}
39			};
40
41			template<typename T> class autoarray {
42			public:
43			int count;
44
45			private:
46			T* ptr;
47			int bufferlen;
48
49			T dummy;
50			static const int default_size = 128;
51
52		28	const T& getconst(int id) const
53			{
54	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 14 times.	28	if (id < 0) return dummy;
55	1/3 ✗ Branch 0 not taken. ✗ Branch 1 not taken. ✓ Branch 2 taken 14 times.	28	if (id >= count) return dummy;
56		28	return ptr[id];
57			}
58
59		1886223	T& get(int id)
60			{
61	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1768260 times.	1886223	if (id < 0) return dummy;
62	4/4 ✓ Branch 0 taken 144 times. ✓ Branch 1 taken 883245 times. ✓ Branch 2 taken 147 times. ✓ Branch 3 taken 884724 times.	1886223	if (id >= bufferlen - 4)
63			{
64		582	resize(id);
65			}
66	3/3 ✓ Branch 0 taken 9629 times. ✓ Branch 1 taken 883536 times. ✓ Branch 2 taken 875095 times.	1886223	if (id >= count)
67			{
68	13/14 ✗ Branch 0 not taken. ✓ Branch 1 taken 3142 times. ✓ Branch 2 taken 6537 times. ✓ Branch 3 taken 3127 times. ✓ Branch 4 taken 9655 times. ✓ Branch 5 taken 6526 times. ✓ Branch 6 taken 1594 times. ✓ Branch 7 taken 5453 times. ✓ Branch 8 taken 1616 times. ✓ Branch 9 taken 6986 times. ✓ Branch 10 taken 8228 times. ✓ Branch 11 taken 37 times. ✓ Branch 12 taken 2778 times. ✓ Branch 13 taken 2778 times.	77728	for (int i = count;i <= id;i++) new(ptr + i) T();
69		38758	count = id + 1;
70			}
71		1886223	return ptr[id];
72			}
73
74		609	void resize(int size)
75			{
76		609	int oldlen = count;
77	4/4 ✓ Branch 0 taken 157 times. ✓ Branch 1 taken 157 times. ✓ Branch 2 taken 161 times. ✓ Branch 3 taken 161 times.	1218	while (bufferlen <= size + 4) bufferlen *= 2;
78		609	T *old = ptr;
79		609	ptr = (T)malloc(sizeof(T)(size_t)bufferlen);
80	2/2 ✓ Branch 0 taken 24744 times. ✓ Branch 1 taken 318 times.	49797	for(int i = 0; i < oldlen; i++){
81	6/11 ✗ Branch 0 not taken. ✓ Branch 1 taken 4060 times. ✓ Branch 2 taken 8304 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 96 times. ✓ Branch 6 taken 8296 times. ✓ Branch 7 taken 8 times. ✗ Branch 8 not taken. ✓ Branch 9 taken 3980 times. ✗ Branch 10 not taken.	49188	new(ptr + i) T();
82	0/2 ✗ Branch 0 not taken. ✗ Branch 1 not taken.	49188	ptr[i] = static_cast<T &&>(old[i]);
83			}
84		609	free(old);
85	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 161 times.	609	memset((void)(ptr + oldlen), 0, (size_t)(bufferlen - oldlen) sizeof(T));
86		609	}
87
88			public:
89
90		22315	void reset(int keep = 0)
91			{
92	3/3 ✓ Branch 0 taken 4380 times. ✓ Branch 1 taken 6220 times. ✓ Branch 2 taken 842 times.	22315	if (keep >= count) return;
93	7/7 ✓ Branch 0 taken 3229 times. ✓ Branch 1 taken 1076 times. ✓ Branch 2 taken 476 times. ✓ Branch 3 taken 3344 times. ✓ Branch 4 taken 339 times. ✓ Branch 5 taken 834 times. ✓ Branch 6 taken 503 times.	18795	for (int i = keep;i < count;i++) ptr[i].~T();
94	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 842 times.	2968	memset((void)(ptr + keep), 0, (size_t)(count - keep) sizeof(T));
95	2/4 ✓ Branch 0 taken 758 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 842 times. ✗ Branch 3 not taken.	2968	if (keep < bufferlen / 2)
96			{
97	8/10 ✓ Branch 0 taken 973 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 215 times. ✓ Branch 3 taken 758 times. ✓ Branch 4 taken 1125 times. ✗ Branch 5 not taken. ✓ Branch 6 taken 283 times. ✓ Branch 7 taken 842 times. ✓ Branch 8 taken 283 times. ✓ Branch 9 taken 842 times.	3897	while (keep < bufferlen / 2 && bufferlen>8) bufferlen /= 2;
98		2968	T *old = ptr;
99		2968	ptr = (T)malloc(sizeof(T)(size_t)bufferlen);
100	2/2 ✓ Branch 0 taken 24 times. ✓ Branch 1 taken 1600 times.	3016	for(int i = 0; i < keep; i++){
101	2/11 ✗ Branch 0 not taken. ✗ Branch 1 not taken. ✓ Branch 2 taken 12 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 12 times. ✗ Branch 6 not taken. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✗ Branch 9 not taken. ✗ Branch 10 not taken.	48	new(ptr + i) T();
102		48	ptr[i] = static_cast<T &&>(old[i]);
103			}
104		2968	free(old);
105
106			}
107		2968	count = keep;
108			}
109
110		1853321	T& operator[](int id)
111			{
112		1853321	return get(id);
113			}
114
115		28	const T& operator[](int id) const
116			{
117		28	return getconst(id);
118			}
119
120		1628	operator T*()
121			{
122		1628	return ptr;
123			}
124
125			operator const T*() const
126			{
127			return ptr;
128			}
129
130		27187	T& append(const T& item)
131			{
132		27187	return (get(count) = item);
133			}
134
135			//insert is not safe for non pod types!!!
136			void insert(int pos)
137			{
138			if (pos<0 \|\| pos>count) return;
139			if (count >= bufferlen - 4)
140			{
141			resize(count);
142			}
143			memmove(ptr + pos + 1, ptr + pos, sizeof(T)*(count - pos));
144			memset((void*)(ptr + pos), 0, sizeof(T));
145			new(ptr + pos) T();
146			count++;
147			}
148
149		138417	void insert(int pos, const T& item)
150			{
151	3/5 ✓ Branch 0 taken 138417 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 69129 times. ✓ Branch 4 taken 69288 times.	138417	if (pos<0 \|\| pos>count) return;
152	4/4 ✓ Branch 0 taken 13 times. ✓ Branch 1 taken 69116 times. ✓ Branch 2 taken 14 times. ✓ Branch 3 taken 69274 times.	138417	if (count >= bufferlen - 4)
153			{
154		27	resize(count);
155			}
156	2/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 69288 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 69288 times.	138417	memmove(ptr + pos + 1, ptr + pos, sizeof(T)*(size_t)(count - pos));
157	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 69288 times.	138417	memset((void*)(ptr + pos), 0, sizeof(T));
158	2/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 69129 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 69288 times.	138417	new(ptr + pos) T();
159		138417	ptr[pos] = item;
160		138417	count++;
161			}
162
163		139010	void remove(int id)
164			{
165	3/5 ✓ Branch 0 taken 138452 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 69171 times. ✓ Branch 4 taken 69281 times.	139010	if (id < 0 \|\| id >= count) return;
166		139010	count--;
167		139010	ptr[id].~T();
168	3/3 ✓ Branch 0 taken 93340 times. ✓ Branch 1 taken 162532 times. ✓ Branch 2 taken 69281 times.	325711	for(int i = id; i < count; i++){
169		186701	ptr[i] = static_cast<T &&>(ptr[i+1]);
170			}
171			}
172
173		5838	autoarray()
174		3114	{
175		5838	ptr = (T)malloc(sizeof(T) default_size);
176	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1553 times.	5838	memset((void)ptr, 0, default_sizesizeof(T));
177		5838	bufferlen = default_size;
178		5838	count = 0;
179		5838	}
180
181		5793	~autoarray()
182			{
183	7/7 ✓ Branch 0 taken 139 times. ✓ Branch 1 taken 6102 times. ✓ Branch 2 taken 714 times. ✓ Branch 3 taken 183 times. ✓ Branch 4 taken 718 times. ✓ Branch 5 taken 5478 times. ✓ Branch 6 taken 835 times.	28323	for (int i = 0;i < count;i++) ptr[i].~T();
184		5793	free(ptr);
185		5793	}
186			};
187