reservedvector.hh

Go to the documentation of this file.
00001 #ifndef RESERVEDVECTOR_HH
00002 #define RESERVEDVECTOR_HH
00003 
00004 #include <iostream>
00005 #include <dune/common/genericiterator.hh>
00006 
00007 #ifdef CHECK_RESERVEDVECTOR
00008 #define CHECKSIZE(X) assert(X)
00009 #else
00010 #define CHECKSIZE(X) {}
00011 #endif
00012 
00013 namespace Dune
00014 {
00029     template<class T, int n>
00030     class ReservedVector
00031     {
00032     public:
00033 
00036 
00037         typedef T value_type;
00039         typedef T* pointer;
00041         typedef T& reference;
00043         typedef const T& const_reference;
00045         typedef size_t size_type;
00047         typedef std::ptrdiff_t difference_type;
00049         typedef Dune::GenericIterator<ReservedVector, value_type> iterator;
00051         typedef Dune::GenericIterator<const ReservedVector, const value_type> const_iterator;
00052 
00057 
00058         ReservedVector() : sz(0) {}
00059         
00064 
00065         void clear()
00066         {
00067             sz = 0;
00068         }
00069 
00071         void resize(size_t s)
00072         {
00073             CHECKSIZE(s<=n);
00074             sz = s;
00075         }
00076         
00078         void push_back(const T& t)
00079         {
00080             CHECKSIZE(sz<n);
00081             data[sz++] = t;
00082         }
00083         
00085         void pop_back()
00086         {
00087             if (! empty()) sz--;
00088         }
00089 
00091         iterator begin(){
00092             return iterator(*this, 0);
00093         }
00094 
00096         const_iterator begin() const{    
00097             return const_iterator(*this, 0);
00098         }
00099 
00101         iterator end(){
00102             return iterator(*this, sz);
00103         }
00104 
00106         const_iterator end() const{    
00107             return const_iterator(*this, sz);
00108         }
00109   
00111         reference operator[] (size_type i)
00112         {
00113             CHECKSIZE(sz>i);
00114             return data[i];
00115         }
00116 
00118         const_reference operator[] (size_type i) const
00119         {
00120             CHECKSIZE(sz>i);
00121             return data[i];
00122         }
00123 
00125         reference front()
00126         {
00127             CHECKSIZE(sz>0);
00128             return data[0];
00129         }
00130 
00132         const_reference front() const
00133         {
00134             CHECKSIZE(sz>0);
00135             return data[0];
00136         }
00137 
00139         reference back()
00140         {
00141             CHECKSIZE(sz>0);
00142             return data[sz-1];
00143         }
00144 
00146         const_reference back() const
00147         {
00148             CHECKSIZE(sz>0);
00149             return data[sz-1];
00150         }
00151 
00156 
00157         size_type size () const
00158         {
00159             return sz;
00160         }
00161 
00163         bool empty() const
00164         {
00165             return sz==0;
00166         }
00167 
00169         static size_type capacity()
00170         {
00171             return n;
00172         }
00173 
00175         static size_type max_size()
00176         {
00177             return n;
00178         }
00179 
00182 
00183         friend std::ostream& operator<< (std::ostream& s, const ReservedVector& v)
00184         {
00185             for (size_t i=0; i<v.size(); i++)
00186                 s << v[i] << "  ";
00187             return s;
00188         }
00189 
00190     private:
00191         T data[n];
00192         size_type sz;
00193     };
00194     
00195 }
00196 
00197 #undef CHECKSIZE
00198 
00199 #endif // RESERVEDVECTOR_HH

Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].