dune-common  2.2.0
reservedvector.hh
Go to the documentation of this file.
00001 #ifndef RESERVEDVECTOR_HH
00002 #define RESERVEDVECTOR_HH
00003 
00008 #include <iostream>
00009 #include <dune/common/genericiterator.hh>
00010 
00011 #ifdef CHECK_RESERVEDVECTOR
00012 #define CHECKSIZE(X) assert(X)
00013 #else
00014 #define CHECKSIZE(X) {}
00015 #endif
00016 
00017 namespace Dune
00018 {
00033     template<class T, int n>
00034     class ReservedVector
00035     {
00036     public:
00037 
00040 
00041         typedef T value_type;
00043         typedef T* pointer;
00045         typedef T& reference;
00047         typedef const T& const_reference;
00049         typedef size_t size_type;
00051         typedef std::ptrdiff_t difference_type;
00053         typedef Dune::GenericIterator<ReservedVector, value_type> iterator;
00055         typedef Dune::GenericIterator<const ReservedVector, const value_type> const_iterator;
00056 
00061 
00062         ReservedVector() : sz(0) {}
00063         
00068 
00069         void clear()
00070         {
00071             sz = 0;
00072         }
00073 
00075         void resize(size_t s)
00076         {
00077             CHECKSIZE(s<=n);
00078             sz = s;
00079         }
00080         
00082         void push_back(const T& t)
00083         {
00084             CHECKSIZE(sz<n);
00085             data[sz++] = t;
00086         }
00087         
00089         void pop_back()
00090         {
00091             if (! empty()) sz--;
00092         }
00093         
00095         iterator begin(){
00096             return iterator(*this, 0);
00097         }
00098 
00100         const_iterator begin() const{    
00101             return const_iterator(*this, 0);
00102         }
00103 
00105         iterator end(){
00106             return iterator(*this, sz);
00107         }
00108 
00110         const_iterator end() const{    
00111             return const_iterator(*this, sz);
00112         }
00113   
00115         reference operator[] (size_type i)
00116         {
00117             CHECKSIZE(sz>i);
00118             return data[i];
00119         }
00120 
00122         const_reference operator[] (size_type i) const
00123         {
00124             CHECKSIZE(sz>i);
00125             return data[i];
00126         }
00127 
00129         reference front()
00130         {
00131             CHECKSIZE(sz>0);
00132             return data[0];
00133         }
00134 
00136         const_reference front() const
00137         {
00138             CHECKSIZE(sz>0);
00139             return data[0];
00140         }
00141 
00143         reference back()
00144         {
00145             CHECKSIZE(sz>0);
00146             return data[sz-1];
00147         }
00148 
00150         const_reference back() const
00151         {
00152             CHECKSIZE(sz>0);
00153             return data[sz-1];
00154         }
00155 
00160 
00161         size_type size () const
00162         {
00163             return sz;
00164         }
00165 
00167         bool empty() const
00168         {
00169             return sz==0;
00170         }
00171 
00173         static size_type capacity()
00174         {
00175             return n;
00176         }
00177 
00179         static size_type max_size()
00180         {
00181             return n;
00182         }
00183 
00186 
00187         friend std::ostream& operator<< (std::ostream& s, const ReservedVector& v)
00188         {
00189             for (size_t i=0; i<v.size(); i++)
00190                 s << v[i] << "  ";
00191             return s;
00192         }
00193 
00194     private:
00195         T data[n];
00196         size_type sz;
00197     };
00198     
00199 }
00200 
00201 #undef CHECKSIZE
00202 
00203 #endif // RESERVEDVECTOR_HH