00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 #ifndef OR_TOOLS_BASE_INT_TYPE_INDEXED_VECTOR_H_
00058 #define OR_TOOLS_BASE_INT_TYPE_INDEXED_VECTOR_H_
00059
00060 #include <stddef.h>
00061 #include <string>
00062 #include <vector>
00063
00064 #include "base/macros.h"
00065 #include "base/int-type.h"
00066
00067
00068 template<typename IntType, typename T, typename Alloc = std::allocator<T> >
00069 class ITIVector : protected std::vector<T, Alloc> {
00070 public:
00071 typedef std::vector<T, Alloc> ParentType;
00072 typedef typename ParentType::size_type size_type;
00073 typedef typename ParentType::allocator_type allocator_type;
00074 typedef typename ParentType::value_type value_type;
00075 typedef typename ParentType::reference reference;
00076 typedef typename ParentType::const_reference const_reference;
00077 typedef typename ParentType::pointer pointer;
00078 typedef typename ParentType::const_pointer const_pointer;
00079 typedef typename ParentType::iterator iterator;
00080 typedef typename ParentType::const_iterator const_iterator;
00081 typedef typename ParentType::reverse_iterator reverse_iterator;
00082 typedef typename ParentType::const_reverse_iterator
00083 const_reverse_iterator;
00084
00085 public:
00086 ITIVector() { }
00087 explicit ITIVector(const allocator_type& a) : ParentType(a) { }
00088 ITIVector(size_type n, const value_type& v = value_type(),
00089 const allocator_type& a = allocator_type())
00090 : ParentType(n, v, a) { }
00091 ITIVector(const ITIVector& x) : ParentType(x.get()) { }
00092 template<typename InputIteratorType>
00093 ITIVector(InputIteratorType first, InputIteratorType last,
00094 const allocator_type& a = allocator_type())
00095 : ParentType(first, last, a) { }
00096 ~ITIVector() { }
00097
00098
00099
00100 const ParentType& get() const { return *this; }
00101
00102
00103
00104
00105
00106
00107 ParentType* mutable_get() { return this; }
00108
00109
00110 reference operator[](IntType i) {
00111 return ParentType::operator[](i.template value<size_t>());
00112 }
00113 const_reference operator[](IntType i) const {
00114 return ParentType::operator[](i.template value<size_t>());
00115 }
00116 reference at(IntType i) {
00117 return ParentType::at(i.template value<size_t>());
00118 }
00119 const_reference at(IntType i) const {
00120 return ParentType::at(i.template value<size_t>());
00121 }
00122
00123
00124 ITIVector& operator=(const ITIVector& x) {
00125 ParentType::operator =(x.get());
00126 return *this;
00127 }
00128
00129 void assign(size_type n, const value_type& val) {
00130 ParentType::assign(n, val);
00131 }
00132 template<typename InputIt>
00133 void assign(InputIt f, InputIt l) { ParentType::assign(f, l); }
00134
00135 iterator begin() { return ParentType::begin(); }
00136 const_iterator begin() const { return ParentType::begin(); }
00137 iterator end() { return ParentType::end(); }
00138 const_iterator end() const { return ParentType::end(); }
00139 reverse_iterator rbegin() { return ParentType::rbegin(); }
00140 const_reverse_iterator rbegin() const { return ParentType::rbegin(); }
00141 reverse_iterator rend() { return ParentType::rend(); }
00142 const_reverse_iterator rend() const { return ParentType::rend(); }
00143
00144 size_type size() const { return ParentType::size(); }
00145 size_type max_size() const { return ParentType::max_size(); }
00146
00147 void resize(size_type new_size, value_type x = value_type()) {
00148 ParentType::resize(new_size, x);
00149 }
00150
00151 size_type capacity() const { return ParentType::capacity(); }
00152 bool empty() const { return ParentType::empty(); }
00153 void reserve(size_type n) { ParentType::reserve(n); }
00154 void push_back(const value_type& x) { ParentType::push_back(x); }
00155 void pop_back() { ParentType::pop_back(); }
00156 void swap(ITIVector& x) { ParentType::swap(*x.mutable_get()); }
00157 void clear() { return ParentType::clear(); }
00158
00159 reference front() { return ParentType::front(); }
00160 const_reference front() const { return ParentType::front(); }
00161 reference back() { return ParentType::back(); }
00162 const_reference back() const { return ParentType::back(); }
00163 pointer data() { return ParentType::data(); }
00164 const_pointer data() const { return ParentType::data(); }
00165
00166 iterator erase(iterator pos) {
00167 return ParentType::erase(pos);
00168 }
00169 iterator erase(iterator first, iterator last) {
00170 return ParentType::erase(first, last);
00171 }
00172 iterator insert(iterator pos, const value_type& x) {
00173 return ParentType::insert(pos, x);
00174 }
00175 void insert(iterator pos, size_type n, const value_type& x) {
00176 ParentType::insert(pos, n, x);
00177 }
00178 template<typename IIt>
00179 void insert(iterator pos, IIt first, IIt last) {
00180 ParentType::insert(pos, first, last);
00181 }
00182 };
00183
00184 #define ITIVECTOR_COMPARISON_OP(op) \
00185 template<typename IntType, typename T, typename Alloc> \
00186 inline bool operator op( \
00187 const ITIVector<IntType, T, Alloc>& x, \
00188 const ITIVector<IntType, T, Alloc>& y) { \
00189 return x.get() op y.get(); \
00190 }
00191 ITIVECTOR_COMPARISON_OP(==);
00192 ITIVECTOR_COMPARISON_OP(<);
00193 ITIVECTOR_COMPARISON_OP(<=);
00194 ITIVECTOR_COMPARISON_OP(>);
00195 ITIVECTOR_COMPARISON_OP(>=);
00196 #undef ITIVECTOR_COMPARISON_OP
00197
00198 template <typename IntType, typename T, typename Alloc>
00199 inline void swap(ITIVector<IntType, T, Alloc>& x,
00200 ITIVector<IntType, T, Alloc>& y) {
00201 x.swap(y);
00202 }
00203
00204 #endif // OR_TOOLS_BASE_INT_TYPE_INDEXED_VECTOR_H_