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
