1 #ifndef MARISA_ALPHA_VECTOR_INLINE_H_
2 #define MARISA_ALPHA_VECTOR_INLINE_H_
3
4 namespace marisa_alpha {
5
6 template <typename T>
Vector()7 Vector<T>::Vector()
8 : buf_(NULL), objs_(NULL), size_(0), capacity_(0), fixed_(false) {}
9
10 template <typename T>
~Vector()11 Vector<T>::~Vector() {
12 if (buf_ != NULL) {
13 for (std::size_t i = 0; i < size_; ++i) {
14 buf_[i].~T();
15 }
16 delete [] reinterpret_cast<char *>(buf_);
17 }
18 }
19
20 template <typename T>
mmap(Mapper * mapper,const char * filename,long offset,int whence)21 void Vector<T>::mmap(Mapper *mapper, const char *filename,
22 long offset, int whence) {
23 MARISA_ALPHA_THROW_IF(mapper == NULL, MARISA_ALPHA_PARAM_ERROR);
24 Mapper temp_mapper;
25 temp_mapper.open(filename, offset, whence);
26 map(temp_mapper);
27 temp_mapper.swap(mapper);
28 }
29
30 template <typename T>
map(const void * ptr,std::size_t size)31 void Vector<T>::map(const void *ptr, std::size_t size) {
32 Mapper mapper(ptr, size);
33 map(mapper);
34 }
35
36 template <typename T>
map(Mapper & mapper)37 void Vector<T>::map(Mapper &mapper) {
38 UInt32 size;
39 mapper.map(&size);
40 Vector temp;
41 mapper.map(&temp.objs_, size);
42 temp.size_ = size;
43 temp.fix();
44 temp.swap(this);
45 }
46
47 template <typename T>
load(const char * filename,long offset,int whence)48 void Vector<T>::load(const char *filename,
49 long offset, int whence) {
50 Reader reader;
51 reader.open(filename, offset, whence);
52 read(reader);
53 }
54
55 template <typename T>
fread(std::FILE * file)56 void Vector<T>::fread(std::FILE *file) {
57 Reader reader(file);
58 read(reader);
59 }
60
61 template <typename T>
read(int fd)62 void Vector<T>::read(int fd) {
63 Reader reader(fd);
64 read(reader);
65 }
66
67 template <typename T>
read(std::istream & stream)68 void Vector<T>::read(std::istream &stream) {
69 Reader reader(&stream);
70 read(reader);
71 }
72
73 template <typename T>
read(Reader & reader)74 void Vector<T>::read(Reader &reader) {
75 UInt32 size;
76 reader.read(&size);
77 Vector temp;
78 temp.resize(size);
79 reader.read(temp.buf_, size);
80 temp.swap(this);
81 }
82
83 template <typename T>
save(const char * filename,bool trunc_flag,long offset,int whence)84 void Vector<T>::save(const char *filename, bool trunc_flag,
85 long offset, int whence) const {
86 Writer writer;
87 writer.open(filename, trunc_flag, offset, whence);
88 write(writer);
89 }
90
91 template <typename T>
fwrite(std::FILE * file)92 void Vector<T>::fwrite(std::FILE *file) const {
93 Writer writer(file);
94 write(writer);
95 }
96
97 template <typename T>
write(int fd)98 void Vector<T>::write(int fd) const {
99 Writer writer(fd);
100 write(writer);
101 }
102
103 template <typename T>
write(std::ostream & stream)104 void Vector<T>::write(std::ostream &stream) const {
105 Writer writer(&stream);
106 write(writer);
107 }
108
109 template <typename T>
write(Writer & writer)110 void Vector<T>::write(Writer &writer) const {
111 writer.write(size_);
112 writer.write(objs_, size_);
113 }
114
115 template <typename T>
push_back(const T & x)116 void Vector<T>::push_back(const T &x) {
117 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
118 MARISA_ALPHA_THROW_IF(size_ == max_size(), MARISA_ALPHA_SIZE_ERROR);
119 reserve(size_ + 1);
120 new (&buf_[size_++]) T(x);
121 }
122
123 template <typename T>
pop_back()124 void Vector<T>::pop_back() {
125 MARISA_ALPHA_THROW_IF(fixed_ || (size_ == 0), MARISA_ALPHA_STATE_ERROR);
126 buf_[--size_].~T();
127 }
128
129 template <typename T>
resize(std::size_t size)130 void Vector<T>::resize(std::size_t size) {
131 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
132 reserve(size);
133 for (std::size_t i = size_; i < size; ++i) {
134 new (&buf_[i]) T;
135 }
136 for (std::size_t i = size; i < size_; ++i) {
137 buf_[i].~T();
138 }
139 size_ = (UInt32)size;
140 }
141
142 template <typename T>
resize(std::size_t size,const T & x)143 void Vector<T>::resize(std::size_t size, const T &x) {
144 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
145 reserve(size);
146 for (std::size_t i = size_; i < size; ++i) {
147 new (&buf_[i]) T(x);
148 }
149 for (std::size_t i = size; i < size_; ++i) {
150 buf_[i].~T();
151 }
152 size_ = (UInt32)size;
153 }
154
155 template <typename T>
reserve(std::size_t capacity)156 void Vector<T>::reserve(std::size_t capacity) {
157 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
158 MARISA_ALPHA_THROW_IF(capacity > max_size(), MARISA_ALPHA_SIZE_ERROR);
159 if (capacity <= capacity_) {
160 return;
161 }
162 std::size_t new_capacity = capacity;
163 if (capacity_ > (capacity / 2)) {
164 if (capacity_ > (max_size() / 2)) {
165 new_capacity = max_size();
166 } else {
167 new_capacity = capacity_ * 2;
168 }
169 }
170 realloc(new_capacity);
171 }
172
173 template <typename T>
shrink()174 void Vector<T>::shrink() {
175 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
176 if (size_ != capacity_) {
177 realloc(size_);
178 }
179 }
180
181 template <typename T>
fix()182 void Vector<T>::fix() {
183 MARISA_ALPHA_THROW_IF(fixed_, MARISA_ALPHA_STATE_ERROR);
184 fixed_ = true;
185 }
186
187 template <typename T>
swap(Vector * rhs)188 void Vector<T>::swap(Vector *rhs) {
189 MARISA_ALPHA_THROW_IF(rhs == NULL, MARISA_ALPHA_PARAM_ERROR);
190 Swap(&buf_, &rhs->buf_);
191 Swap(&objs_, &rhs->objs_);
192 Swap(&size_, &rhs->size_);
193 Swap(&capacity_, &rhs->capacity_);
194 Swap(&fixed_, &rhs->fixed_);
195 }
196
197 template <typename T>
realloc(std::size_t new_capacity)198 void Vector<T>::realloc(std::size_t new_capacity) {
199 MARISA_ALPHA_THROW_IF(new_capacity > (MARISA_ALPHA_SIZE_MAX / sizeof(T)),
200 MARISA_ALPHA_SIZE_ERROR);
201 T * const new_buf = reinterpret_cast<T *>(
202 new (std::nothrow) char[sizeof(T) * new_capacity]);
203 MARISA_ALPHA_THROW_IF(new_buf == NULL, MARISA_ALPHA_MEMORY_ERROR);
204 for (std::size_t i = 0; i < size_; ++i) {
205 new (&new_buf[i]) T(buf_[i]);
206 buf_[i].~T();
207 }
208 delete [] reinterpret_cast<char *>(buf_);
209 buf_ = new_buf;
210 objs_ = new_buf;
211 capacity_ = (UInt32)new_capacity;
212 }
213
214 } // namespace marisa_alpha
215
216 #endif // MARISA_ALPHA_VECTOR_INLINE_H_
217