-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathlocalVector.h
More file actions
193 lines (163 loc) · 3.77 KB
/
localVector.h
File metadata and controls
193 lines (163 loc) · 3.77 KB
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
#ifndef CPP_UTIL_COMMON_LOCALVECTOR_H
#define CPP_UTIL_COMMON_LOCALVECTOR_H
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <string>
#include <iostream>
#include <tr1/memory>
#include "common.h"
USING_NAMESPACE(std)
NAMESPACE_SETUP(Util)
const size_t MIN_BUFFER_SIZE = 16;
template <typename T>
class LocalVector {
public:
typedef const T* const_iterator;
typedef T* iterator;
public:
LocalVector();
LocalVector(const LocalVector<T>& vec);
LocalVector(const_iterator begin, const_iterator end);
LocalVector(size_t size, const T& t);
virtual ~LocalVector();
public:
void operator=(const LocalVector<T>& vec);
private:
bool Init();
public:
T& operator[](size_t i);
const T& operator[] (size_t i) const;
void push_back(const T& t);
void reserve(size_t size);
bool empty() const ;
size_t size() const;
size_t capacity() const;
void clear();
public:
const_iterator begin() const {
return mPtr;
}
const_iterator end() const {
return mPtr+mSize;
}
iterator begin() {
return mPtr;
}
iterator end() {
return mPtr+mSize;
}
private:
T* mPtr;
size_t mSize;
size_t mCapacity;
};
template <typename T>
LocalVector<T>::LocalVector() {
assert(Init());
}
template <typename T>
LocalVector<T>::LocalVector(const LocalVector<T>& vec) {
assert(Init());
// call operator= function
*this = vec;
}
template <typename T>
LocalVector<T>::LocalVector(const_iterator begin, const_iterator end) {
assert(Init());
while(begin != end) {
push_back(*begin++);
}
}
template <typename T>
LocalVector<T>::LocalVector(size_t size, const T& t) {
assert(Init());
while(size--) {
push_back(t);
}
}
template <typename T>
LocalVector<T>::~LocalVector() {
free(mPtr);
mPtr = NULL;
}
template <typename T>
void LocalVector<T>::operator=(const LocalVector<T>& vec) {
mSize = vec.size();
mCapacity = vec.capacity();
// copy vec ptr to this ptr
memcpy(mPtr, vec.mPtr, sizeof(T)*mSize);
}
template <typename T>
bool LocalVector<T>::Init() {
// first Init capacity equal min_buffer_size
mPtr = (T*)malloc(sizeof(T)*MIN_BUFFER_SIZE);
assert(mPtr);
mSize = 0;
mCapacity = MIN_BUFFER_SIZE;
return true;
}
template <typename T>
T& LocalVector<T>::operator[](size_t i) {
return mPtr[i];
}
template <typename T>
const T& LocalVector<T>::operator[] (size_t i) const {
return mPtr[i];
}
template <typename T>
void LocalVector<T>::push_back(const T& t) {
// when buffer has full, reserve double size
if(mSize == mCapacity) {
reserve(mCapacity*2);
}
mPtr[mSize++] = t;
}
template <typename T>
void LocalVector<T>::reserve(size_t size) {
if(size <= mCapacity) {
return;
}
// new ptr
T* newPtr = (T*)malloc(sizeof(T)*size);
assert(newPtr);
// copy old data to new ptr
memcpy(newPtr, mPtr, sizeof(T)*mCapacity);
// delete old ptr, reset new ptr and capacity
free(mPtr);
mPtr = newPtr;
mCapacity = size;
}
template <typename T>
bool LocalVector<T>::empty() const {
return mSize == 0;
}
template <typename T>
size_t LocalVector<T>::size() const {
return mSize;
}
template <typename T>
size_t LocalVector<T>::capacity() const {
return mCapacity;
}
template <typename T>
void LocalVector<T>::clear() {
free(mPtr);
mPtr = NULL;
assert(Init());
}
template <typename T>
ostream& operator<<(ostream& os, const LocalVector<T>& vec) {
if(vec.empty()) {
return os << "[]";
}
os << "[\"" << vec[0];
size_t vecSize = vec.size();
for(size_t i = 1; i < vecSize; i++) {
os << "\", \"" << vec[i];
}
os << "\"]";
return os;
}
NAMESPACE_END(Util)
#endif //CPP_UTIL_COMMON_LOCALVECTOR_H