/home/fwph/code/wurde/rde/core/LocalArray.H

Go to the documentation of this file.
00001 #ifndef LocalArray_H
00002 #define LocalArray_H
00003 
00023 #include <iterator>
00024 
00025 #include <wds-debug.h>
00026 
00027 
00040 
00041 
00044 template <class T, int Size> class LocalArray {
00045 public:
00047         LocalArray() {assert(Size > 0);}
00050         LocalArray(const T &value) {
00051                 assert(Size > 0); for(int i = 0;  i < Size; ++i) m_data[i] = value;}
00052         LocalArray(const LocalArray <T, Size> &array) {
00053                 for(int i = 0; i < Size; ++i) m_data[i] = array.m_data[i];}
00054         ~LocalArray() {}
00055 
00057 
00058 
00059 
00063         LocalArray <T, Size> &operator=(const LocalArray <T, Size> &array) {
00064                 for(int i = 0; i < Size; ++i) m_data[i] = array.m_data[i]; return *this;}
00066 
00068         LocalArray <T, Size> &operator=(const T &value) {
00069                 for(int i = 0; i < Size; ++i) m_data[i] = value; return *this;}
00071 
00073 
00074         typedef T value_type;
00075 
00076         typedef value_type* pointer;
00077         typedef const value_type* const_pointer;
00078         typedef value_type& reference;
00079         typedef const value_type& const_reference;
00080 
00081         typedef ptrdiff_t difference_type;
00082         typedef size_t size_type;
00083 
00084         typedef pointer iterator;
00085         typedef const_pointer const_iterator;
00086 
00087         iterator begin() {return m_data;}
00088         iterator end() {return m_data + Size;}
00089 
00090         const_iterator begin() const {return m_data;}
00091         const_iterator end() const {return m_data + Size;}
00092 
00093         typedef std::reverse_iterator<iterator> reverse_iterator;
00094         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00095 
00096         reverse_iterator rbegin() {return reverse_iterator(end());}
00097         reverse_iterator rend() {return reverse_iterator(begin());}
00098 
00099         const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
00100         const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
00102 
00104 
00105         reference operator[](const size_type index) {assert_range(index, 0, Size); return m_data[index];}
00106         const_reference operator[](const size_type index) const {assert_range(index, 0, Size); return m_data[index];}
00107 
00108         reference operator()(const size_type index) {assert_range(index, 0, Size); return m_data[index];}
00109         const_reference operator()(const size_type index) const {assert_range(index, 0, Size); return m_data[index];}
00111 
00113 
00114         size_type size() const {return Size;}
00116 
00117 private:
00118         T m_data[Size];
00119 };
00120 
00121 
00123 
00126 template <class T, int Rows, int Columns> class LocalArray2d {
00127 public:
00129         LocalArray2d() {
00130                 assert(Rows > 0); assert(Columns > 0);}
00133         LocalArray2d(const T &value) {
00134                 assert(Rows > 0); assert(Columns > 0); for(int i = 0; i < (Rows * Columns); ++i) m_data[i] = value;}
00135         LocalArray2d(const LocalArray2d <T, Rows, Columns> &array) {
00136                 for(int i = 0; i < (Rows * Columns); ++i) m_data[i] = array.m_data[i];}
00137         ~LocalArray2d() {}
00138 
00140 
00141 
00142 
00144         LocalArray2d <T, Rows, Columns> &operator=(const LocalArray2d <T, Rows, Columns> &array) {
00145                 for(int i = 0; i < (Rows * Columns); ++i) m_data[i] = array.m_data[i];}
00147 
00149         LocalArray2d <T, Rows, Columns> &operator=(const T &value) {
00150                 for(int i = 0; i < (Rows * Columns); ++i) m_data[i] = value;}
00152 
00154 
00155         typedef T value_type;
00156 
00157         typedef value_type* pointer;
00158         typedef const value_type* const_pointer;
00159         typedef value_type& reference;
00160         typedef const value_type& const_reference;
00161 
00162         typedef ptrdiff_t difference_type;
00163         typedef size_t size_type;
00164 
00165         typedef pointer iterator;
00166         typedef const_pointer const_iterator;
00167 
00168         iterator begin() {return m_data;}
00169         iterator end() {return m_data + (Rows * Columns);}
00170 
00171         const_iterator begin() const {return m_data;}
00172         const_iterator end() const {return m_data + (Rows * Columns);}
00173 
00174         typedef std::reverse_iterator<iterator> reverse_iterator;
00175         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00176 
00177         reverse_iterator rbegin() {return reverse_iterator(end());}
00178         reverse_iterator rend() {return reverse_iterator(begin());}
00179 
00180         const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
00181         const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
00183 
00185 
00186         reference operator()(const size_type row, const size_type column) {
00187                 assert_range(row, 0, Rows); assert_range(column, 0, Columns); return m_data[row * Columns + column];}
00188         const_reference operator()(const size_type row, const size_type column) const {
00189                 assert_range(row, 0, Rows); assert_range(column, 0, Columns); return m_data[row * Columns + column];}
00191 
00193 
00194         size_type size() const {return (Rows * Columns);}
00195         size_type rows() const {return Rows;}
00196         size_type columns() const {return Columns;}
00198 
00199 private:
00200         T m_data[Rows * Columns];
00201 };
00202 
00203 
00205 
00210 template <class T, int Size> class LocalRing : public LocalArray <T, Size> {
00211 public:
00212         LocalRing() :LocalArray <T, Size> () {}
00213         LocalRing(const T &value) :LocalArray <T, Size> (value) {}
00214         LocalRing(const LocalRing <T, Size> &ring) :LocalArray <T, Size> (ring) {}
00215         ~LocalRing() {}
00216 
00217         using LocalArray <T, Size>::operator=;
00218 
00220 
00221         typedef T value_type;
00222 
00223         typedef value_type* pointer;
00224         typedef const value_type* const_pointer;
00225         typedef value_type& reference;
00226         typedef const value_type& const_reference;
00227 
00228         typedef ptrdiff_t difference_type;
00229         typedef size_t size_type;
00230 
00231         typedef pointer iterator;
00232         typedef const_pointer const_iterator;
00233 
00234         typedef std::reverse_iterator<iterator> reverse_iterator;
00235         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00237 
00239 
00240         reference operator[](const size_type index) {return Array<T>::operator[](wrap_index(index));}
00241         const_reference operator[](const size_type index) const {return Array<T>::operator[](wrap_index(index));}
00242 
00243         reference operator()(const size_type index) {return Array<T>::operation()(wrap_index(index));}
00244         const_reference operator()(const size_type index) const {return Array<T>::operation()(wrap_index(index));}
00246 
00247         using LocalArray<T, Size>::size;
00248 
00249 private:
00250         int wrap_index(const int index) const {return ((index < 0)?(((index - 1) % size())):(index % size()));}
00251 };
00252 
00253 
00255 
00260 template <class T, int Rows, int Columns> class LocalTorus : public LocalArray2d <T, Rows, Columns> {
00261 public:
00262         LocalTorus() :LocalArray2d <T, Rows, Columns> () {}
00263         LocalTorus(const T &value) :LocalArray2d <T, Rows, Columns> (value) {}
00264         LocalTorus(const LocalTorus <T, Rows, Columns> &torus) :LocalArray2d <T, Rows, Columns> (torus) {}
00265         ~LocalTorus() {}
00266 
00267         using LocalArray2d <T, Rows, Columns>::operator=;
00268 
00270 
00271         typedef T value_type;
00272 
00273         typedef value_type* pointer;
00274         typedef const value_type* const_pointer;
00275         typedef value_type& reference;
00276         typedef const value_type& const_reference;
00277 
00278         typedef ptrdiff_t difference_type;
00279         typedef size_t size_type;
00280 
00281         typedef pointer iterator;
00282         typedef const_pointer const_iterator;
00283 
00284         typedef std::reverse_iterator<iterator> reverse_iterator;
00285         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00287 
00289 
00290         reference operator()(const size_type row, const size_type column) {
00291                 return LocalArray2d<T, Rows, Columns>::operation()(wrap_index(row, rows()), wrap_index(columns, columns()));}
00292         const_reference operator()(const size_type row, const size_type column) const {
00293                 return LocalArray2d<T, Rows, Columns>::operation()(wrap_index(row, rows()), wrap_index(columns, columns()));}
00295 
00296         using LocalArray2d<T, Rows, Columns>::size;
00297         using LocalArray2d<T, Rows, Columns>::rows;
00298         using LocalArray2d<T, Rows, Columns>::columns;
00299 
00300 private:
00301         int wrap_index(const int index, const int size) const {return ((index < 0)?(((index - 1) % size)):(index % size));}
00302 };
00303 
00304 
00305 #endif

Generated on Thu Feb 1 15:31:54 2007 for WURDE by  doxygen 1.5.1