asar coverage - build #324 - 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		262381	operator T() const
10			{
11		262381	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		89509	autoptr(T ptr_)
26			{
27		89509	ptr = ptr_;
28		89509	}
29
30			autoptr(const autoptr<T>& ptr_)
31			{
32			ptr = ptr_.ptr;
33			}
34
35		90031	~autoptr()
36			{
37	3/3 ✓ Branch 0 taken 40098 times. ✓ Branch 1 taken 40483 times. ✓ Branch 2 taken 60 times.	90031	if (ptr) free((void*)ptr);
38		90031	}
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		1889017	T& get(int id)
60			{
61	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1769968 times.	1889017	if (id < 0) return dummy;
62	4/4 ✓ Branch 0 taken 145 times. ✓ Branch 1 taken 884098 times. ✓ Branch 2 taken 148 times. ✓ Branch 3 taken 885577 times.	1889017	if (id >= bufferlen - 4)
63			{
64		586	resize(id);
65			}
66	3/3 ✓ Branch 0 taken 9661 times. ✓ Branch 1 taken 884390 times. ✓ Branch 2 taken 875917 times.	1889017	if (id >= count)
67			{
68	13/14 ✗ Branch 0 not taken. ✓ Branch 1 taken 3155 times. ✓ Branch 2 taken 6556 times. ✓ Branch 3 taken 3140 times. ✓ Branch 4 taken 9687 times. ✓ Branch 5 taken 6545 times. ✓ Branch 6 taken 1608 times. ✓ Branch 7 taken 5460 times. ✓ Branch 8 taken 1630 times. ✓ Branch 9 taken 7007 times. ✓ Branch 10 taken 8246 times. ✓ Branch 11 taken 37 times. ✓ Branch 12 taken 2789 times. ✓ Branch 13 taken 2789 times.	77984	for (int i = count;i <= id;i++) new(ptr + i) T();
69		38886	count = id + 1;
70			}
71		1889017	return ptr[id];
72			}
73
74		615	void resize(int size)
75			{
76		615	int oldlen = count;
77	4/4 ✓ Branch 0 taken 159 times. ✓ Branch 1 taken 159 times. ✓ Branch 2 taken 163 times. ✓ Branch 3 taken 163 times.	1230	while (bufferlen <= size + 4) bufferlen *= 2;
78		615	T *old = ptr;
79		615	ptr = (T)malloc(sizeof(T)(size_t)bufferlen);
80	2/2 ✓ Branch 0 taken 24760 times. ✓ Branch 1 taken 322 times.	49827	for(int i = 0; i < oldlen; i++){
81	6/11 ✗ Branch 0 not taken. ✓ Branch 1 taken 4064 times. ✓ Branch 2 taken 8308 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 96 times. ✓ Branch 6 taken 8300 times. ✓ Branch 7 taken 8 times. ✗ Branch 8 not taken. ✓ Branch 9 taken 3984 times. ✗ Branch 10 not taken.	49212	new(ptr + i) T();
82	0/2 ✗ Branch 0 not taken. ✗ Branch 1 not taken.	49212	ptr[i] = static_cast<T &&>(old[i]);
83			}
84		615	free(old);
85	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 163 times.	615	memset((void)(ptr + oldlen), 0, (size_t)(bufferlen - oldlen) sizeof(T));
86		615	}
87
88			public:
89
90		22651	void reset(int keep = 0)
91			{
92	3/3 ✓ Branch 0 taken 4451 times. ✓ Branch 1 taken 6306 times. ✓ Branch 2 taken 857 times.	22651	if (keep >= count) return;
93	7/7 ✓ Branch 0 taken 3242 times. ✓ Branch 1 taken 1097 times. ✓ Branch 2 taken 489 times. ✓ Branch 3 taken 3357 times. ✓ Branch 4 taken 341 times. ✓ Branch 5 taken 853 times. ✓ Branch 6 taken 516 times.	18977	for (int i = keep;i < count;i++) ptr[i].~T();
94	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 857 times.	3026	memset((void)(ptr + keep), 0, (size_t)(count - keep) sizeof(T));
95	2/4 ✓ Branch 0 taken 773 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 857 times. ✗ Branch 3 not taken.	3026	if (keep < bufferlen / 2)
96			{
97	8/10 ✓ Branch 0 taken 990 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 217 times. ✓ Branch 3 taken 773 times. ✓ Branch 4 taken 1142 times. ✗ Branch 5 not taken. ✓ Branch 6 taken 285 times. ✓ Branch 7 taken 857 times. ✓ Branch 8 taken 285 times. ✓ Branch 9 taken 857 times.	3961	while (keep < bufferlen / 2 && bufferlen>8) bufferlen /= 2;
98		3026	T *old = ptr;
99		3026	ptr = (T)malloc(sizeof(T)(size_t)bufferlen);
100	2/2 ✓ Branch 0 taken 24 times. ✓ Branch 1 taken 1630 times.	3074	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		3026	free(old);
105
106			}
107		3026	count = keep;
108			}
109
110		1856067	T& operator[](int id)
111			{
112		1856067	return get(id);
113			}
114
115		28	const T& operator[](int id) const
116			{
117		28	return getconst(id);
118			}
119
120		1652	operator T*()
121			{
122		1652	return ptr;
123			}
124
125			operator const T*() const
126			{
127			return ptr;
128			}
129
130		27211	T& append(const T& item)
131			{
132		27211	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		138469	void insert(int pos, const T& item)
150			{
151	3/5 ✓ Branch 0 taken 138469 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 69155 times. ✓ Branch 4 taken 69314 times.	138469	if (pos<0 \|\| pos>count) return;
152	4/4 ✓ Branch 0 taken 14 times. ✓ Branch 1 taken 69141 times. ✓ Branch 2 taken 15 times. ✓ Branch 3 taken 69299 times.	138469	if (count >= bufferlen - 4)
153			{
154		29	resize(count);
155			}
156	2/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 69314 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 69314 times.	138469	memmove(ptr + pos + 1, ptr + pos, sizeof(T)*(size_t)(count - pos));
157	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 69314 times.	138469	memset((void*)(ptr + pos), 0, sizeof(T));
158	2/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 69155 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 69314 times.	138469	new(ptr + pos) T();
159		138469	ptr[pos] = item;
160		138469	count++;
161			}
162
163		139058	void remove(int id)
164			{
165	3/5 ✓ Branch 0 taken 138500 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 69195 times. ✓ Branch 4 taken 69305 times.	139058	if (id < 0 \|\| id >= count) return;
166		139058	count--;
167		139058	ptr[id].~T();
168	3/3 ✓ Branch 0 taken 93371 times. ✓ Branch 1 taken 162587 times. ✓ Branch 2 taken 69305 times.	325821	for(int i = id; i < count; i++){
169		186763	ptr[i] = static_cast<T &&>(ptr[i+1]);
170			}
171			}
172
173		5862	autoarray()
174		3130	{
175		5862	ptr = (T)malloc(sizeof(T) default_size);
176	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1559 times.	5862	memset((void)ptr, 0, default_sizesizeof(T));
177		5862	bufferlen = default_size;
178		5862	count = 0;
179		5862	}
180
181		5817	~autoarray()
182			{
183	7/7 ✓ Branch 0 taken 141 times. ✓ Branch 1 taken 6104 times. ✓ Branch 2 taken 718 times. ✓ Branch 3 taken 185 times. ✓ Branch 4 taken 720 times. ✓ Branch 5 taken 5478 times. ✓ Branch 6 taken 839 times.	28355	for (int i = 0;i < count;i++) ptr[i].~T();
184		5817	free(ptr);
185		5817	}
186			};
187