00001
00002
00003 #ifndef DUNE_COMMON_RESERVEDVECTOR_HH
00004 #define DUNE_COMMON_RESERVEDVECTOR_HH
00005
00010 #include <algorithm>
00011 #include <iostream>
00012 #include <cstddef>
00013 #include <dune/common/genericiterator.hh>
00014 #include <initializer_list>
00015
00016 #ifdef CHECK_RESERVEDVECTOR
00017 #define CHECKSIZE(X) assert(X)
00018 #else
00019 #define CHECKSIZE(X) {}
00020 #endif
00021
00022 namespace Dune
00023 {
00038 template<class T, int n>
00039 class ReservedVector
00040 {
00041 public:
00042
00045
00046 typedef T value_type;
00048 typedef T* pointer;
00050 typedef T& reference;
00052 typedef const T& const_reference;
00054 typedef size_t size_type;
00056 typedef std::ptrdiff_t difference_type;
00058 typedef Dune::GenericIterator<ReservedVector, value_type> iterator;
00060 typedef Dune::GenericIterator<const ReservedVector, const value_type> const_iterator;
00061
00066
00067 ReservedVector() : sz(0) {}
00068
00069 ReservedVector(std::initializer_list<T> const &l)
00070 {
00071 assert(l.size() <= n);
00072 sz = l.size();
00073 std::copy_n(l.begin(), sz, data);
00074 }
00075
00080
00081 void clear()
00082 {
00083 sz = 0;
00084 }
00085
00087 void resize(size_t s)
00088 {
00089 CHECKSIZE(s<=n);
00090 sz = s;
00091 }
00092
00094 void push_back(const T& t)
00095 {
00096 CHECKSIZE(sz<n);
00097 data[sz++] = t;
00098 }
00099
00101 void pop_back()
00102 {
00103 if (! empty()) sz--;
00104 }
00105
00107 iterator begin(){
00108 return iterator(*this, 0);
00109 }
00110
00112 const_iterator begin() const {
00113 return const_iterator(*this, 0);
00114 }
00115
00117 iterator end(){
00118 return iterator(*this, sz);
00119 }
00120
00122 const_iterator end() const {
00123 return const_iterator(*this, sz);
00124 }
00125
00127 reference operator[] (size_type i)
00128 {
00129 CHECKSIZE(sz>i);
00130 return data[i];
00131 }
00132
00134 const_reference operator[] (size_type i) const
00135 {
00136 CHECKSIZE(sz>i);
00137 return data[i];
00138 }
00139
00141 reference front()
00142 {
00143 CHECKSIZE(sz>0);
00144 return data[0];
00145 }
00146
00148 const_reference front() const
00149 {
00150 CHECKSIZE(sz>0);
00151 return data[0];
00152 }
00153
00155 reference back()
00156 {
00157 CHECKSIZE(sz>0);
00158 return data[sz-1];
00159 }
00160
00162 const_reference back() const
00163 {
00164 CHECKSIZE(sz>0);
00165 return data[sz-1];
00166 }
00167
00172
00173 size_type size () const
00174 {
00175 return sz;
00176 }
00177
00179 bool empty() const
00180 {
00181 return sz==0;
00182 }
00183
00185 static constexpr size_type capacity()
00186 {
00187 return n;
00188 }
00189
00191 static constexpr size_type max_size()
00192 {
00193 return n;
00194 }
00195
00198
00199 friend std::ostream& operator<< (std::ostream& s, const ReservedVector& v)
00200 {
00201 for (size_t i=0; i<v.size(); i++)
00202 s << v[i] << " ";
00203 return s;
00204 }
00205
00206 private:
00207 T data[n];
00208 size_type sz;
00209 };
00210
00211 }
00212
00213 #undef CHECKSIZE
00214
00215 #endif // DUNE_COMMON_RESERVEDVECTOR_HH