2
Copyright (C) 2000-2007 MySQL AB
4
This program is free software; you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; version 2 of the License.
8
This program is distributed in the hope that it will be useful,
9
but WITHOUT ANY WARRANTY; without even the implied warranty of
10
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
GNU General Public License for more details.
13
You should have received a copy of the GNU General Public License
14
along with this program; see the file COPYING. If not, write to the
15
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
20
/* mySTL vector implements simple vector, w/ swap
24
#ifndef mySTL_VECTOR_HPP
25
#define mySTL_VECTOR_HPP
27
#include "helpers.hpp" // construct, destory, fill, etc.
28
#include "algorithm.hpp" // swap
29
#include <assert.h> // assert
41
vector_base() : start_(0), finish_(0), end_of_storage_(0) {}
44
start_ = GetArrayMemory<T>(n);
46
end_of_storage_ = start_ + n;
51
FreeArrayMemory(start_);
54
void Swap(vector_base& that)
56
swap(start_, that.start_);
57
swap(finish_, that.finish_);
58
swap(end_of_storage_, that.end_of_storage_);
68
typedef const T* const_iterator;
71
explicit vector(size_t n) : vec_(n)
73
vec_.finish_ = uninit_fill_n(vec_.start_, n, T());
76
~vector() { destroy(vec_.start_, vec_.finish_); }
78
vector(const vector& other) : vec_(other.size())
80
vec_.finish_ = uninit_copy(other.vec_.start_, other.vec_.finish_,
84
size_t capacity() const { return vec_.end_of_storage_ - vec_.start_; }
86
size_t size() const { return vec_.finish_ - vec_.start_; }
88
T& operator[](size_t idx) { return *(vec_.start_ + idx); }
89
const T& operator[](size_t idx) const { return *(vec_.start_ + idx); }
91
const T* begin() const { return vec_.start_; }
92
const T* end() const { return vec_.finish_; }
94
void push_back(const T& v)
96
if (vec_.finish_ != vec_.end_of_storage_) {
97
construct(vec_.finish_, v);
101
vector tmp(size() * 2 + 1, *this);
102
construct(tmp.vec_.finish_, v);
108
void resize(size_t n, const T& v)
110
if (n == size()) return;
113
T* first = vec_.start_ + n;
114
destroy(first, vec_.finish_);
115
vec_.finish_ -= vec_.finish_ - first;
118
vector tmp(n, *this);
119
tmp.vec_.finish_ = uninit_fill_n(tmp.vec_.finish_, n - size(), v);
124
void reserve(size_t n)
126
if (capacity() < n) {
127
vector tmp(n, *this);
132
void Swap(vector& that)
134
vec_.Swap(that.vec_);
139
vector& operator=(const vector&); // hide assign
141
// for growing, n must be bigger than other size
142
vector(size_t n, const vector& other) : vec_(n)
144
assert(n > other.size());
145
vec_.finish_ = uninit_copy(other.vec_.start_, other.vec_.finish_,
154
#endif // mySTL_VECTOR_HPP