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
|
#ifdef NALL_STRING_INTERNAL_HPP
/*
vector allocator
sizeof(string) == 16 (amd64)
utilizes a raw string pointer
always allocates memory onto the heap when string is not empty
pros:
* potential for in-place resize
* simplicity
cons:
* always allocates heap memory on (capacity > 0)
* pass-by-value requires heap allocation
*/
namespace nall {
char* string::data() {
if(_capacity == 0) reserve(1);
return _data;
}
const char* string::data() const {
if(_capacity == 0) return "";
return _data;
}
void string::reserve(unsigned capacity) {
if(capacity > _capacity) {
_capacity = bit::round(capacity + 1) - 1;
_data = (char*)realloc(_data, _capacity + 1);
_data[_capacity] = 0;
}
}
void string::resize(unsigned size) {
reserve(size);
data()[_size = size] = 0;
}
void string::reset() {
if(_data) { free(_data); _data = nullptr; }
_capacity = 0;
_size = 0;
}
string& string::operator=(const string& source) {
if(&source == this) return *this;
reset();
_data = (char*)malloc(source._size + 1);
_capacity = source._size;
_size = source._size;
memcpy(_data, source.data(), source.size() + 1);
return *this;
}
string& string::operator=(string&& source) {
if(&source == this) return *this;
reset();
_data = source._data;
_capacity = source._capacity;
_size = source._size;
source._data = nullptr;
source._capacity = 0;
source._size = 0;
return *this;
}
template<typename T, typename... Args> string::string(T&& source, Args&&... args) {
construct();
sprint(*this, std::forward<T>(source), std::forward<Args>(args)...);
}
string::string() {
construct();
}
string::~string() {
reset();
}
void string::construct() {
_data = nullptr;
_capacity = 0;
_size = 0;
}
}
#endif
|
