asar coverage - build #249

src/asar/
File: src/asar/autoarray.h
Date: 2025-02-21 17:41:52
Lines:
84/84
100.0%
Functions:
138/145
95.2%
Branches:
79/113
69.9%
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 371532 operator T() const
10 {
11
12/13
✗ Branch 0 not taken.
✓ Branch 1 taken 61434 times.
✓ Branch 2 taken 25350 times.
✓ Branch 3 taken 81 times.
✓ Branch 4 taken 54 times.
✓ Branch 5 taken 51 times.
✓ Branch 6 taken 48 times.
✓ Branch 7 taken 99 times.
✓ Branch 8 taken 57 times.
✓ Branch 9 taken 54 times.
✓ Branch 10 taken 6 times.
✓ Branch 11 taken 126 times.
✓ Branch 12 taken 33 times.
 544818 return ptr;
12 }
13
14 1047 autoptr& operator=(T ptr_)
15 {
16
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 603 times.
 1704 ptr = ptr_;
17 1047 return *this;
18 }
19
20 2064 autoptr()
21 {
22
2/2
✓ Branch 0 taken 603 times.
✓ Branch 1 taken 180 times.
 2064 ptr = nullptr;
23 1227 }
24
25 402420 autoptr(T ptr_)
26 {
27
11/19
✗ Branch 0 not taken.
✓ Branch 1 taken 8892 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 84678 times.
✓ Branch 4 taken 8541 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 7176 times.
✓ Branch 7 taken 5166 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 99 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 63 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 18 times.
✓ Branch 14 taken 36 times.
✓ Branch 15 taken 174 times.
✗ Branch 16 not taken.
✓ Branch 17 taken 63 times.
✗ Branch 18 not taken.
 393879 ptr = ptr_;
28 203448 }
29
30 autoptr(const autoptr<T>& ptr_)
31 {
32 ptr = ptr_.ptr;
33 }
34
35 1004409 ~autoptr()
36 {
37
2/2
✓ Branch 0 taken 389340 times.
✓ Branch 1 taken 990 times.
 604515 if (ptr) free((void*)ptr);
38 1004409 }
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 27750 const T& getconst(int id) const
53 {
54
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13875 times.
 27750 if (id < 0) return dummy;
55
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13875 times.
 27750 if (id >= count) return dummy;
56 27750 return ptr[id];
57 }
58
59 8354391 T& get(int id)
60 {
61
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6661504 times.
 8354391 if (id < 0) return dummy;
62
2/2
✓ Branch 0 taken 889 times.
✓ Branch 1 taken 6660615 times.
 8354391 if (id >= bufferlen - 4)
63 {
64 1778 resize(id);
65 }
66
2/2
✓ Branch 0 taken 751593 times.
✓ Branch 1 taken 5909911 times.
 8354391 if (id >= count)
67 {
68
5/7
✓ Branch 0 taken 387104 times.
✓ Branch 1 taken 751745 times.
✓ Branch 2 taken 364660 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 9 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 3006724 for (int i = count;i <= id;i++) new(ptr + i) T();
69 1503030 count = id + 1;
70 }
71 8354391 return ptr[id];
72 }
73
74 1833 void resize(int size)
75 {
76 1833 int oldlen = count;
77
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 944 times.
 3666 while (bufferlen <= size + 4) bufferlen *= 2;
78 1833 T *old = ptr;
79 1833 ptr = (T*)malloc(sizeof(T)*(size_t)bufferlen);
80
2/2
✓ Branch 0 taken 206272 times.
✓ Branch 1 taken 944 times.
 413773 for(int i = 0; i < oldlen; i++){
81
0/4
✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 411940 new(ptr + i) T();
82 411940 ptr[i] = static_cast<T &&>(old[i]);
83 }
84 1833 free(old);
85 1833 memset(ptr + oldlen, 0, (size_t)(bufferlen - oldlen) * sizeof(T));
86 1833 }
87
88 public:
89
90 69147 void reset(int keep = 0)
91 {
92
2/2
✓ Branch 0 taken 18266 times.
✓ Branch 1 taken 17073 times.
 69147 if (keep >= count) return;
93
3/3
✓ Branch 0 taken 11075 times.
✓ Branch 1 taken 5143 times.
✓ Branch 2 taken 1509 times.
 33988 for (int i = keep;i < count;i++) ptr[i].~T();
94 9515 memset(ptr + keep, 0, (size_t)(count - keep) * sizeof(T));
95
1/2
✓ Branch 0 taken 5135 times.
✗ Branch 1 not taken.
 9515 if (keep < bufferlen / 2)
96 {
97
3/4
✓ Branch 0 taken 9865 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4730 times.
✓ Branch 3 taken 5135 times.
 17820 while (keep < bufferlen / 2 && bufferlen>8) bufferlen /= 2;
98 9515 T *old = ptr;
99 9515 ptr = (T*)malloc(sizeof(T)*(size_t)bufferlen);
100
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 5135 times.
 9623 for(int i = 0; i < keep; i++){
101 108 new(ptr + i) T();
102 108 ptr[i] = static_cast<T &&>(old[i]);
103 }
104 9515 free(old);
105
106 }
107 9515 count = keep;
108 }
109
110 3310974 T& operator[](int id)
111 {
112
8/16
✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 18 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 18 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 36 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 54 times.
✗ Branch 13 not taken.
✓ Branch 14 taken 9 times.
✗ Branch 15 not taken.
 5470103 return get(id);
113 }
114
115 22136 const T& operator[](int id) const
116 {
117
2/4
✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2713 times.
✗ Branch 3 not taken.
 24943 return getconst(id);
118 }
119
120 2852 operator T*()
121 {
122
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
 3156 return ptr;
123 }
124
125 operator const T*() const
126 {
127 return ptr;
128 }
129
130 1455730 T& append(const T& item)
131 {
132 1455730 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(ptr + pos, 0, sizeof(T));
145 new(ptr + pos) T();
146 count++;
147 }
148
149 417315 void insert(int pos, const T& item)
150 {
151
3/4
✓ Branch 0 taken 417315 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 208577 times.
✓ Branch 3 taken 208738 times.
 417315 if (pos<0 || pos>count) return;
152
2/2
✓ Branch 0 taken 55 times.
✓ Branch 1 taken 417260 times.
 417315 if (count >= bufferlen - 4)
153 {
154 55 resize(count);
155 }
156 417315 memmove(ptr + pos + 1, ptr + pos, sizeof(T)*(size_t)(count - pos));
157 417315 memset(ptr + pos, 0, sizeof(T));
158 417315 new(ptr + pos) T();
159 417315 ptr[pos] = item;
160 417315 count++;
161 }
162
163 1109293 void remove(int id)
164 {
165
3/4
✓ Branch 0 taken 1107613 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 565888 times.
✓ Branch 3 taken 541725 times.
 1109293 if (id < 0 || id >= count) return;
166 1109293 count--;
167 1109293 ptr[id].~T();
168
2/2
✓ Branch 0 taken 562037 times.
✓ Branch 1 taken 1107613 times.
 1671330 for(int i = id; i < count; i++){
169 562037 ptr[i] = static_cast<T &&>(ptr[i+1]);
170 }
171 }
172
173 26793 autoarray()
174 8938 {
175 26793 ptr = (T*)malloc(sizeof(T) * default_size);
176 26793 memset(ptr, 0, default_size*sizeof(T));
177 26793 bufferlen = default_size;
178 26793 count = 0;
179 28609 }
180
181 26338 ~autoarray()
182 {
183
3/3
✓ Branch 0 taken 21866 times.
✓ Branch 1 taken 17759 times.
✓ Branch 2 taken 3615 times.
 86086 for (int i = 0;i < count;i++) ptr[i].~T();
184 21886 free(ptr);
185 26338 }
186
187 #ifdef SERIALIZER
188 void serialize(serializer& s)
189 {
190 if (s.serializing) s(count);
191 else
192 {
193 int i;
194 s(i);
195 get(i - 1);
196 }
197 for (int i = 0;i < count;i++) s(ptr[i]);
198 }
199 #endif
200 #define SERIALIZER_BANNED
201 };
202