Branch data Line data Source code
1 : : /*!
2 : : * \class vectortemplate
3 : : * \brief for engineering style vector starting from 1
4 : : *
5 : : **/
6 : : #ifndef __MESHKIT_VECTORTEMPLATE_H__
7 : : #define __MESHKIT_VECTORTEMPLATE_H__
8 : :
9 : : #include <string>
10 : : #include <iostream>
11 : : #include <cassert>
12 : : #include <stdlib.h>
13 : :
14 : : // defines the vector template class
15 : : template <class T>
16 : : class CVector
17 : : {
18 : : private:
19 : : int m_nRows; // number of rows in the vector
20 : : T *m_pCells; // address where the vector of
21 : : // type T is stored
22 : : void ErrorHandler (int,int nR=0) const;
23 : : // handles error conditions
24 : : void Release (); // similar to destructor
25 : : std::string m_szName; // vector name
26 : :
27 : : public:
28 : : CVector (); // default constructor
29 : : CVector (int); // constructor
30 : : CVector (const char*); // constructor
31 : : CVector (const char*, int); // constructor
32 : : CVector (const CVector<T>&); // copy constructor
33 : : ~CVector (); // destructor
34 : : void SetSize (int); // sets the size of the vector
35 : : // used with the default constructor
36 : :
37 : : // helper functions
38 : : // gets the current size of the vector
39 : : int GetSize () const;
40 : : // gets the vector name
41 : : void GetName (std::string& szName) const;
42 : :
43 : : // vector manipulations (mutator)
44 : : void Set (T); // sets the value of all
45 : : // elements of a vector
46 : : void SetName (const std::string&); // sets the name of the vector
47 : :
48 : : // overloaded operators
49 : : T& operator() (int); // row access
50 : : const T& operator() (int) const;// row access
51 : : CVector<T>& operator= (const CVector<T>&); // overloaded = operator
52 : : };
53 : :
54 : : // =============== definitions ===========================================
55 : : template <class T>
56 : 334 : CVector<T>::CVector ()
57 : : // ---------------------------------------------------------------------------
58 : : // Function: default ctor
59 : : // Input: none
60 : : // Output: none
61 : : // ---------------------------------------------------------------------------
62 : : {
63 : 167 : m_pCells = NULL;
64 : 167 : m_nRows = 0;
65 : 167 : }
66 : :
67 : : template <class T>
68 : 24 : CVector<T>::CVector (int n)
69 : : // ---------------------------------------------------------------------------
70 : : // Function: overloaded ctor
71 : : // Input: size of the vector
72 : : // Output: none
73 : : // ---------------------------------------------------------------------------
74 : : {
75 : 12 : m_pCells = NULL;
76 : 12 : m_nRows = 0;
77 [ + - # # ]: 12 : SetSize (n);
78 : 12 : }
79 : :
80 : : template <class T>
81 : : CVector<T>::CVector (const char* szName)
82 : : // ---------------------------------------------------------------------------
83 : : // Function: overloaded ctor
84 : : // Input: vector name
85 : : // Output: none
86 : : // ---------------------------------------------------------------------------
87 : : {
88 : : m_pCells = NULL;
89 : : m_nRows = 0;
90 : : m_szName = szName;
91 : : }
92 : :
93 : : template <class T>
94 : : CVector<T>::CVector (const char* szName, int n)
95 : : // ---------------------------------------------------------------------------
96 : : // Function: overloaded ctor
97 : : // Input: vector name and size
98 : : // Output: none
99 : : // ---------------------------------------------------------------------------
100 : : {
101 : : m_pCells = NULL;
102 : : m_nRows = 0;
103 : : m_szName = szName;
104 : : SetSize (n);
105 : : }
106 : :
107 : : template <class T>
108 : 32 : CVector<T>::CVector (const CVector<T>& A)
109 : : // ---------------------------------------------------------------------------
110 : : // Function: copy ctor
111 : : // Input: vector
112 : : // Output: none
113 : : // ---------------------------------------------------------------------------
114 : : {
115 : 16 : m_pCells = NULL;
116 [ + - + - ]: 16 : m_nRows = A.GetSize();
117 [ + - ][ + - ]: 16 : m_szName = A.m_szName;
118 [ + - ][ + - ]: 16 : SetSize (m_nRows);
119 [ + + ][ + + ]: 44 : for (int i=1; i <= m_nRows; i++)
120 [ + - ]: 4 : m_pCells[i] = A.m_pCells[i];
121 : 16 : }
122 : :
123 : : template <class T>
124 : 81 : void CVector<T>::SetSize (int nR)
125 : : // ---------------------------------------------------------------------------
126 : : // Function: dynamically allocates memory
127 : : // Input: vector size
128 : : // Output: none
129 : : // ---------------------------------------------------------------------------
130 : : {
131 : : // check whether NR is legal
132 [ - + ][ - + ]: 81 : if (nR <= 0) ErrorHandler (3);
[ - + ][ - + ]
[ - + ]
133 : 81 : Release ();
134 [ + - ][ + - ]: 177 : try {m_pCells = new T [nR + 1];}
[ + - ][ + - ]
[ + - ][ + + ]
[ # # + - ]
[ + + ][ + - ]
[ + + ][ # # ]
[ # # ]
[ # # + - ]
[ + - ][ + - ]
[ # # # # ]
[ # # ][ + - ]
[ + - ][ + - ]
[ + + ]
[ # # + - ]
[ + - ]
135 [ # # # # : 0 : catch (std::bad_alloc) {ErrorHandler (1);}
# # # # #
# # # # #
# # # # #
# ]
136 : 81 : m_nRows = nR;
137 : : #ifdef __RGGMETER
138 : : m_dAllocated += static_cast<double>(sizeof(T)*(nR+1));
139 : : #endif
140 [ # # ][ # # ]: 81 : }
[ # # ][ # # ]
[ # # ]
141 : :
142 : : template <class T>
143 : 195 : CVector<T>::~CVector ()
144 : : // ---------------------------------------------------------------------------
145 : : // Function: dtor
146 : : // Input: none
147 : : // Output: none
148 : : // ---------------------------------------------------------------------------
149 : : {
150 : : // deallocate storage
151 : 195 : Release ();
152 : 195 : }
153 : :
154 : : template <class T>
155 : 276 : void CVector<T>::Release ()
156 : : // ---------------------------------------------------------------------------
157 : : // Function: dynamically deallocates memory
158 : : // Input: none
159 : : // Output: none
160 : : // ---------------------------------------------------------------------------
161 : : {
162 : : // deallocate storage
163 [ + + ][ + + ]: 276 : if (m_pCells != NULL)
[ + + ][ + + ]
[ + + ]
164 : : {
165 [ + - ][ + - ]: 177 : delete [] m_pCells;
[ + + ][ + - ]
[ + + ][ # ]
[ # # ][ - ]
[ + + ][ + - ]
[ + + ][ # ]
[ # # ]
166 : : #ifdef __RGGMETER
167 : : m_dDeAllocated += static_cast<double>(sizeof(T)*(m_nRows+1));
168 : : #endif
169 : 81 : m_pCells = NULL;
170 : 81 : m_nRows = 0;
171 : : }
172 : 276 : }
173 : :
174 : : // =============== member functions ===========================================
175 : : template <class T>
176 : : void CVector<T>::SetName (const std::string& szName)
177 : : // ---------------------------------------------------------------------------
178 : : // Function: sets the name of the vector
179 : : // Input: vector name
180 : : // Output: none
181 : : // ---------------------------------------------------------------------------
182 : : {
183 : : m_szName = szName;
184 : : }
185 : :
186 : : template <class T>
187 : : void CVector<T>::GetName (std::string& szName) const
188 : : // ---------------------------------------------------------------------------
189 : : // Function: gets the name of the vector
190 : : // Input: string to hold vector name
191 : : // Output: vector name
192 : : // ---------------------------------------------------------------------------
193 : : {
194 : : szName = m_szName;
195 : : }
196 : :
197 : : template <class T>
198 : : void CVector<T>::Set (T dV)
199 : : // ---------------------------------------------------------------------------
200 : : // Function: sets the value of all the elements in the vector to the
201 : : // specified value
202 : : // Input: specified value
203 : : // Output: none
204 : : // ---------------------------------------------------------------------------
205 : : {
206 : : for (int i=1; i <= m_nRows; i++)
207 : : m_pCells[i] = dV;
208 : : }
209 : :
210 : : template <class T>
211 : 71 : int CVector<T>::GetSize () const
212 : : // ---------------------------------------------------------------------------
213 : : // Function: gets the size of the vector
214 : : // Input: none
215 : : // Output: returns the size
216 : : // ---------------------------------------------------------------------------
217 : : {
218 : 71 : return m_nRows;
219 : : }
220 : :
221 : : // ==================== Overloaded Operators ========================
222 : : #ifdef _DEBUG
223 : : template <class T>
224 : : T& CVector<T>::operator() (int nR) // T& is reference
225 : : // ---------------------------------------------------------------------------
226 : : // Function: overloaded () operator to access vector contents
227 : : // carries out bound checking
228 : : // Input: index or location
229 : : // Output: value at the specified index
230 : : // ---------------------------------------------------------------------------
231 : : {
232 : : // row-column reference in bounds?
233 : : if (nR <= 0 || nR > m_nRows)
234 : : {
235 : : ErrorHandler (2,nR);
236 : : return m_pCells[1];
237 : : }
238 : : else
239 : : return m_pCells[nR];
240 : : }
241 : : #else
242 : : template <class T>
243 : 506 : inline T& CVector<T>::operator() (int nR)
244 : : // ---------------------------------------------------------------------------
245 : : // Function: overloaded () operator to access vector contents
246 : : // Input: index or location
247 : : // Output: value at the specified index
248 : : // ---------------------------------------------------------------------------
249 : : {
250 : 506 : return m_pCells[nR];
251 : : }
252 : : #endif
253 : :
254 : : #ifdef _DEBUG
255 : : template <class T>
256 : : const T& CVector<T>::operator() (int nR) const
257 : : // ---------------------------------------------------------------------------
258 : : // Function: overloaded () operator to access vector contents
259 : : // Input: index or location
260 : : // Output: value at the specified index
261 : : // ---------------------------------------------------------------------------
262 : : {
263 : : // row-column reference in bounds?
264 : : if (nR <= 0 || nR > m_nRows) {
265 : : ErrorHandler (2,nR);
266 : : return m_pCells[1];
267 : : }
268 : : else
269 : : return m_pCells[nR];
270 : : }
271 : : #else
272 : : template <class T>
273 : : inline const T& CVector<T>::operator() (int nR) const
274 : : // ---------------------------------------------------------------------------
275 : : // Function: overloaded () operator to access vector contents
276 : : // Input: index or location
277 : : // Output: value at the specified index
278 : : // ---------------------------------------------------------------------------
279 : : {
280 : : return m_pCells[nR];
281 : : }
282 : : #endif
283 : :
284 : : template <class T>
285 : 192 : CVector<T>& CVector<T>::operator= (const CVector& matarg)
286 : : // ---------------------------------------------------------------------------
287 : : // Function: overloaded = operator
288 : : // Input: vector to use as rvalue
289 : : // Output: modified values
290 : : // ---------------------------------------------------------------------------
291 : : {
292 : : // check whether vector is assigned to itself
293 [ + - ][ + - ]: 192 : if (this != &matarg)
294 : : {
295 : : // compatible vectors?
296 [ - + ][ - + ]: 192 : if (m_nRows != matarg.m_nRows)
297 : : {
298 : 0 : ErrorHandler (4);
299 : 0 : return *this;
300 : : }
301 : : // now copy
302 [ # # ][ + + ]: 528 : for (int i=1; i <= matarg.m_nRows; i++)
[ + + ]
303 : 48 : m_pCells[i] = matarg.m_pCells[i];
304 : : }
305 : :
306 : 192 : return *this;
307 : : }
308 : :
309 : : // ==================== Error Handler ========================
310 : : template <class T>
311 : 0 : void CVector<T>::ErrorHandler (int nErrorCode, int nR) const
312 : : // ---------------------------------------------------------------------------
313 : : // Function: channels error message via std:err
314 : : // Input: error code and optional int value
315 : : // Output: none
316 : : // ---------------------------------------------------------------------------
317 : : {
318 : 0 : std::cerr << "CVector::Vector Name: " << m_szName << ".\n";
319 [ # # # # : 0 : switch (nErrorCode)
# # # # #
# # # # #
# # # # #
# # # # #
# ]
320 : : {
321 : : case 1:
322 : 0 : std::cerr << "Memory allocation failure.\n";
323 : 0 : break;
324 : : case 2:
325 : 0 : std::cerr << "Row index is out of bounds.\n";
326 : 0 : break;
327 : : case 3:
328 : 0 : std::cerr << "Constructor. Invalid number of rows "
329 : : "or columns.\n";
330 : 0 : break;
331 : : case 4:
332 : 0 : std::cerr << "Constructor. Incompatible vectors.\n";
333 : 0 : break;
334 : : }
335 : 0 : std::cerr << "Unable to populate vectors." << std::endl;
336 : 0 : exit (1);
337 : : }
338 : :
339 : : #endif
|
