source: SymbolTable/arrays/HeapArray2D.h @ 1173

Last change on this file since 1173 was 1173, checked in by ksherdy, 8 years ago

Initial check in of SIMD amenable dynamic array classes.

File size: 6.7 KB
Line 
1/*
2 *  HeapArray2D.h
3 *
4 *  Created on: 22-Oct-2009
5 *  Author: ksherdy
6 *  Description: Heap allocated, dynamic, jagged, 2D array.
7 *
8 *               The semantics for bounds checking is that a bounds check is performed
9 *               for each of the push_back method variants. Bounds checking is optionally performed
10 *               for all other interface methods which may potentially violate array boundaries. If
11 *               the BOUNDS_CHECK preprocessor directive is defined at compile time then a boundary
12 *               check is performed.
13 */
14 
15#ifndef HEAPARRAY2D_H_
16#define HEAPARRAY2D_H_
17
18#include "HeapArray.h"
19#include <memory.h>
20#include <cstdlib>
21#include <iostream>
22using namespace std;
23
24//COMPILE TIME FLAGS
25//
26//#define HEAPARRAY2D_DEBUG     // Print debug information to standard out.
27//#define BOUNDS_CHECK          // Perform boundary checking on set(), get(), size() operations.
28
29template <typename T>
30class HeapArray2D {
31
32public:
33       
34        // Allocates 'cols' rounded up to the next multiple of chunk_size elements per row.
35        HeapArray2D(size_t rows=0, size_t cols=0, size_t chunk_size=1, size_t byte_alignment=16);
36        ~HeapArray2D();
37
38        // Push a single item. Performs bounds checks. Allocates memory if required. Copy value.
39        inline void push_back(const size_t row_idx, const T value); 
40       
41        // Push multiple items. Performs bounds checks. Allocates memory if required. Copy value.
42        inline void push_back(const size_t row_idx, const T * value, const size_t count);       
43       
44        // Push multiple items and advance 'adv_count' bytes. Performs bounds checks. Allocates memory if required. Copy value.
45        inline void push_back_adv(const size_t row_idx, const T * value, const size_t count, const size_t adv_count);   
46       
47        // WARNING: No bounds checking performed unless BOUNDS_CHECK is defined. Allocates memory if required.
48        inline void set(const size_t row_idx, const size_t col_idx, T value);
49       
50        // WARNING: No bounds checking performed unless BOUNDS_CHECK is defined.
51        inline T & get(const size_t row_idx, const size_t col_idx) const;
52       
53        // WARNING: No bounds checking performed unless BOUNDS_CHECK is defined. Returns current number of entries by row index.
54        inline size_t size(const size_t row_idx) const;
55
56        // Returns total number of elements.
57        inline size_t size() const;
58       
59        // Returns current number of rows.
60        inline size_t rows() const;     
61       
62        // Reserves additional rows.
63        size_t reserve(const size_t next_size);
64       
65        // Clear all rows contents.
66        void clear();   
67               
68        // Updates minimum column size for expansion.
69        inline void set_min_col_size(const size_t min_col_size) { min_col_size_ = min_col_size; }
70       
71private:
72        // Private Copy Constructor/ Assignment Operator
73        HeapArray2D(const HeapArray2D &);
74        HeapArray2D & operator=(const HeapArray2D &);
75
76        // Expand vertically the number of rows.
77        void expand(const size_t next_size);
78               
79        size_t max_rows_size_; 
80        size_t min_col_size_;
81        size_t chunk_size_;
82        size_t byte_alignment_;
83       
84        HeapArray<T> ** ary_;
85       
86        size_t crt_elems_;
87
88};
89
90template <typename T>
91HeapArray2D<T>::HeapArray2D(size_t rows, size_t cols, size_t chunk_size, size_t byte_alignment) {
92       
93#ifdef HEAPARRAY2D_DEBUG
94        cout << "HeapArray2D<T>::HeapArray2D(" << rows << "," << cols << ")" << endl; 
95#endif 
96       
97        max_rows_size_ = rows;
98        min_col_size_ = cols;
99        chunk_size_ = chunk_size;
100        byte_alignment_ = byte_alignment;
101       
102        ary_ = new HeapArray<T> * [max_rows_size_];
103        for(size_t i = 0; i<max_rows_size_; i++) {
104                ary_[i] = new HeapArray<T>(min_col_size_, chunk_size_, byte_alignment_);       
105        }
106       
107        crt_elems_ = 0;
108}
109
110template <typename T>
111HeapArray2D<T>::~HeapArray2D() {
112
113        for(size_t i = 0; i<max_rows_size_; i++) {
114                delete ary_[i]; 
115                ary_[i] = NULL;
116        }
117        delete [] ary_;
118        ary_ = NULL;
119       
120#ifdef HEAPARRAY2D_DEBUG
121        cout << "HeapArray2D<T>::~HeapArray2D()" << endl; 
122#endif         
123}
124
125template <typename T>
126inline void HeapArray2D<T>::push_back(const size_t row_idx, const T value) {//#ifdef BOUNDS_CHECK       
127        if(row_idx >= max_rows_size_) { // expand vertically
128                size_t next_size = ((max_rows_size_ << 1) + row_idx + 1); 
129                expand(next_size);     
130        } 
131
132        ary_[row_idx]->push_back(value);
133        crt_elems_++;
134}
135
136template <typename T>
137inline void HeapArray2D<T>::push_back(const size_t row_idx, const T * value, const size_t count) {
138        if(row_idx >= max_rows_size_) { // expand vertically
139                size_t next_size = ((max_rows_size_ << 1) + row_idx + 1); 
140                expand(next_size);     
141        } 
142
143        ary_[row_idx]->push_back(value, count);
144        crt_elems_+=count;
145}
146
147template <typename T>
148inline void HeapArray2D<T>::push_back_adv(const size_t row_idx, const T * value, const size_t count, const size_t adv_count) {
149        if(row_idx >= max_rows_size_) { // expand vertically
150                size_t next_size = ((max_rows_size_ << 1) + row_idx + 1); 
151                expand(next_size);     
152        } 
153       
154        ary_[row_idx]->push_back_adv(value, count, adv_count);
155        crt_elems_+= (count + adv_count);
156}
157
158template <typename T> 
159inline void HeapArray2D<T>::set(const size_t row_idx, const size_t col_idx, T value) {
160#ifdef BOUNDS_CHECK
161        if(row_idx >= max_rows_size_) {
162                cerr << "HeapArray2D<T>::set (" << row_idx << ", " << col_idx << "). " << "Row index out of range." << endl;
163                exit(1);       
164        }
165#endif
166        ary_[row_idx]->set(col_idx, value);
167}
168
169template <typename T>
170inline T & HeapArray2D<T>::get(const size_t row_idx, const size_t col_idx) const {
171#ifdef BOUNDS_CHECK
172        if(row_idx >= max_rows_size_) {
173                cerr << "HeapArray2D<T>::get (" << row_idx << ", " << col_idx << "). " << "Row index out of range." << endl;
174                exit(1);               
175        }
176#endif
177        return ary_[row_idx]->get(col_idx);
178}
179
180template <typename T>
181inline size_t HeapArray2D<T>::size(const size_t row_idx) const {
182#ifdef BOUNDS_CHECK
183        if(row_idx >= max_rows_size_) {         
184                cerr << "HeapArray2D<T>::get (" << row_idx << "). " << "Row index out of range." << endl;
185                exit(1);
186        }
187#endif
188
189        return ary_[row_idx]->size();   
190}
191
192template <typename T>
193inline size_t HeapArray2D<T>::size() const {
194        return crt_elems_;     
195}
196
197template <typename T>
198inline size_t HeapArray2D<T>::rows() const {
199        return max_rows_size_; 
200}
201
202template <typename T>
203size_t HeapArray2D<T>::reserve(const size_t next_size) {
204        if(next_size > max_rows_size_) {
205                expand(next_size);
206        }
207        return max_rows_size_;
208}
209
210template <typename T>
211void HeapArray2D<T>::clear() {
212        for(int i=0;i<max_rows_size_;i++) {
213                ary_[i]->clear();
214        }
215        crt_elems_=0;
216}
217
218template <typename T>
219void HeapArray2D<T>::expand(const size_t next_size) {
220
221#ifdef HEAPARRAY2D_DEBUG
222        cout << "HeapArray2D<T>::resize(" << next_size <<  ")" << endl; 
223#endif 
224
225        if(next_size > max_rows_size_) {
226       
227                HeapArray<T> ** temp = new HeapArray<T> * [next_size];
228               
229                for(size_t i=0;i<max_rows_size_;i++) {
230                        temp[i] = ary_[i];     
231                }       
232               
233                for(size_t i=max_rows_size_;i<next_size;i++) {
234                        temp[i] = new HeapArray<T>(min_col_size_, chunk_size_, byte_alignment_);
235                }
236               
237                delete [] ary_;
238                ary_ = temp;
239               
240                max_rows_size_ = next_size;
241        }
242}
243
244#endif /*HEAPARRAY2D_*/
245
246
Note: See TracBrowser for help on using the repository browser.