dune-common  2.2.0
array.hh
Go to the documentation of this file.
00001 // -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
00002 // vi: set ts=8 sw=2 et sts=2:
00003 
00004 #ifndef DUNE_ARRAY_HH
00005 #define DUNE_ARRAY_HH
00006 
00011 #include<iostream>
00012 #include<iomanip>
00013 #include<string>
00014 
00015 // Include system implementation of array class if present
00016 #ifdef HAVE_ARRAY
00017 #include <array>
00018 #else
00019 #include <algorithm>
00020 #endif
00021 
00022 #include "deprecated.hh"
00023 
00024 namespace Dune 
00025 {
00031 #ifdef HAVE_ARRAY
00032     using std::array;
00033 #else
00034 
00039   template<class T, size_t N>
00040   class array {
00041   public:
00042 
00044       typedef T                                       value_type;
00045 
00047       typedef value_type&                             reference;
00048 
00050       typedef const value_type&                       const_reference;
00051 
00053       typedef value_type*                             iterator;
00054 
00056       typedef const value_type*                       const_iterator;
00057 
00059       typedef std::size_t                             size_type;
00060 
00062       typedef std::ptrdiff_t                          difference_type;
00063 
00065       typedef std::reverse_iterator<iterator>         reverse_iterator;
00066 
00068       typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
00069 
00071       size_type size() const {return N;}
00072 
00074       array<T,N>& operator= (const T& t)
00075       {
00076           fill(t);
00077           return (*this);
00078       }
00079         
00081       void assign(const T& t) DUNE_DEPRECATED
00082       {
00083           fill(t);
00084       }
00085 
00087       void fill(const T& t)
00088       {
00089           for (size_type i=0; i<N; i++) a[i]=t;
00090       }
00091 
00093       reference operator[] (size_type i)
00094       {
00095           return a[i];
00096       }
00097 
00099       const_reference operator[] (size_type i) const
00100       {
00101           return a[i];
00102       }
00103 
00104       iterator begin ()
00105       {
00106         return a;
00107       }
00108 
00109       const_iterator begin () const
00110       {
00111         return a;
00112       }
00113 
00114       iterator end ()
00115       {
00116         return a + N;
00117       }
00118 
00119       const_iterator end () const
00120       {
00121         return a + N;
00122       }
00123 
00124       T a[(N > 0) ? N : 1];
00125   };
00126 
00127 
00128 
00129   // Comparison Operators (see [lib.container.requirements])
00130   // -------------------------------------------------------
00131 
00132   template< class T, size_t N >
00133   inline bool operator< ( const array< T, N > &a, const array< T, N > &b )
00134   {
00135     return std::lexicographical_compare( a.begin(), a.end(), b.begin(), b.end() );
00136   }
00137 
00138   template< class T, size_t N >
00139   inline bool operator> ( const array< T, N > &a, const array< T, N > &b )
00140   {
00141     return b < a;
00142   }
00143 
00144   template< class T, size_t N >
00145   inline bool operator<= ( const array< T, N > &a, const array< T, N > &b )
00146   {
00147     return !(a > b);
00148   }
00149 
00150   template< class T, size_t N >
00151   inline bool operator>= ( const array< T, N > &a, const array< T, N > &b )
00152   {
00153     return !(a < b);
00154   }
00155 #endif
00156 
00158   template < class T, size_t N >
00159   inline std::ostream& operator<< (std::ostream& s, const array<T,N>& e)
00160   {
00161     s << "[";
00162     for (size_t i=0; i<N-1; i++) s << e[i] << ",";
00163     s << e[N-1] << "]";
00164     return s;
00165   }
00166 
00167 #ifndef DOXYGEN
00168   template<class T>
00169   array<T, 1> make_array(const T &t0) {
00170     array<T, 1> result = { t0 };
00171     return result;
00172   }
00173 
00174   template<class T>
00175   array<T, 2> make_array(const T &t0, const T &t1) {
00176     array<T, 2> result = { t0, t1 };
00177     return result;
00178   }
00179 
00180   template<class T>
00181   array<T, 3> make_array(const T &t0, const T &t1, const T &t2) {
00182     array<T, 3> result = { t0, t1, t2 };
00183     return result;
00184   }
00185 
00186   template<class T>
00187   array<T, 4> make_array(const T &t0, const T &t1, const T &t2, const T &t3) {
00188     array<T, 4> result = { t0, t1, t2, t3 };
00189     return result;
00190   }
00191 
00192   template<class T>
00193   array<T, 5> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00194                          const T &t4)
00195   {
00196     array<T, 5> result = { t0, t1, t2, t3, t4 };
00197     return result;
00198   }
00199 
00200   template<class T>
00201   array<T, 6> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00202                          const T &t4, const T &t5)
00203   {
00204     array<T, 6> result = { t0, t1, t2, t3, t4, t5 };
00205     return result;
00206   }
00207 
00208   template<class T>
00209   array<T, 7> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00210                          const T &t4, const T &t5, const T &t6)
00211   {
00212     array<T, 7> result = { t0, t1, t2, t3, t4, t5, t6 };
00213     return result;
00214   }
00215 
00216   template<class T>
00217   array<T, 8> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00218                          const T &t4, const T &t5, const T &t6, const T &t7)
00219   {
00220     array<T, 8> result = { t0, t1, t2, t3, t4, t5, t6, t7 };
00221     return result;
00222   }
00223 
00224   template<class T>
00225   array<T, 9> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00226                          const T &t4, const T &t5, const T &t6, const T &t7,
00227                          const T &t8)
00228   {
00229     array<T, 9> result = { t0, t1, t2, t3, t4, t5, t6, t7, t8 };
00230     return result;
00231   }
00232 #endif // !DOXYGEN
00233 
00235 
00241   template<class T>
00242   array<T, 10> make_array(const T &t0, const T &t1, const T &t2, const T &t3,
00243                           const T &t4, const T &t5, const T &t6, const T &t7,
00244                           const T &t8, const T &t9)
00245   {
00246     array<T, 10> result = { t0, t1, t2, t3, t4, t5, t6, t7, t8, t9 };
00247     return result;
00248   }
00249 
00252 } // end namespace Dune
00253 
00254 #endif