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