CARMA C++
RegMapDataFrameManager.h
Go to the documentation of this file.
1 #ifndef SZA_UTIL_REGMAPDATAFRAMEMANAGER_H
2 #define SZA_UTIL_REGMAPDATAFRAMEMANAGER_H
3 
11 #include <string>
12 
13 #include "carma/szaarrayutils/szaregs.h"
14 
15 #include "carma/szautil/Complex.h"
16 #include "carma/szautil/DataFrameManager.h"
17 
18 
19 namespace sza {
20  namespace util {
21 
22  class ArrayMapDataFrameManager;
23  class Date;
24 
25  class RegMapDataFrameManager : public DataFrameManager {
26  public:
27 
31  virtual ~RegMapDataFrameManager();
32 
36  void operator=(DataFrameManager& manager);
37 
41  virtual void operator=(RegMapDataFrameManager& manager);
42 
43  //-------------------------------------------------------------
44  // Methods to pack a named register.
45  //-------------------------------------------------------------
46 
47  void writeReg(std::string board, std::string name,
48  unsigned char* data, CoordRange* range=0);
49 
50  void writeReg(std::string board, std::string name,
51  signed char* data, CoordRange* range=0);
52 
53  void writeReg(std::string board, std::string name,
54  bool* data, CoordRange* range=0);
55 
56  void writeReg(std::string board, std::string name,
57  unsigned short* data, CoordRange* range=0);
58 
59  void writeReg(std::string board, std::string name,
60  signed short* data, CoordRange* range=0);
61 
62  void writeReg(std::string board, std::string name,
63  unsigned int* data, CoordRange* range=0);
64 
65  void writeReg(std::string board, std::string name,
66  signed int* data, CoordRange* range=0);
67 
68  void writeReg(std::string board, std::string name,
69  float* data, CoordRange* range=0);
70 
71  void writeReg(std::string board, std::string name,
72  double* data, CoordRange* range=0);
73 
74  void writeReg(std::string board, std::string name,
75  RegDate::Data* data, CoordRange* range=0);
76 
77  void writeReg(std::string board, std::string name,
78  Complex<float>::Data* data, CoordRange* range=0);
79 
80  //------------------------------------------------------------
81  // Methods for writing single values
82  //------------------------------------------------------------
83 
84  void writeReg(std::string board, std::string name,
85  unsigned char data, CoordRange* range=0);
86 
87  void writeReg(std::string board, std::string name,
88  signed char data, CoordRange* range=0);
89 
90  void writeReg(std::string board, std::string name,
91  bool data, CoordRange* range=0);
92 
93  void writeReg(std::string board, std::string name,
94  unsigned short data, CoordRange* range=0);
95 
96  void writeReg(std::string board, std::string name,
97  signed short data, CoordRange* range=0);
98 
99  void writeReg(std::string board, std::string name,
100  unsigned int data, CoordRange* range=0);
101 
102  void writeReg(std::string board, std::string name,
103  signed int data, CoordRange* range=0);
104 
105  void writeReg(std::string board, std::string name,
106  float data, CoordRange* range=0);
107 
108  void writeReg(std::string board, std::string name,
109  double data, CoordRange* range=0);
110 
111  void writeReg(std::string board, std::string name,
112  RegDate::Data data, CoordRange* range=0);
113 
114  void writeReg(std::string board, std::string name,
115  Complex<float>::Data data, CoordRange* range=0);
116 
117  //------------------------------------------------------------
118  // Versions which don't lock
119  //------------------------------------------------------------
120 
121  void writeRegNoLock(std::string board, std::string name,
122  unsigned char* data, CoordRange* range=0);
123 
124  void writeRegNoLock(std::string board, std::string name,
125  signed char* data, CoordRange* range=0);
126 
127  void writeRegNoLock(std::string board, std::string name,
128  bool* data, CoordRange* range=0);
129 
130  void writeRegNoLock(std::string board, std::string name,
131  unsigned short* data, CoordRange* range=0);
132 
133  void writeRegNoLock(std::string board, std::string name,
134  signed short* data, CoordRange* range=0);
135 
136  void writeRegNoLock(std::string board, std::string name,
137  unsigned int* data, CoordRange* range=0);
138 
139  void writeRegNoLock(std::string board, std::string name,
140  signed int* data, CoordRange* range=0);
141 
142  void writeRegNoLock(std::string board, std::string name,
143  float* data, CoordRange* range=0);
144 
145  void writeRegNoLock(std::string board, std::string name,
146  double* data, CoordRange* range=0);
147 
148  void writeRegNoLock(std::string board, std::string name,
149  RegDate::Data* data, CoordRange* range=0);
150 
151  void writeRegNoLock(std::string board, std::string name,
152  Complex<float>::Data* data, CoordRange* range=0);
153 
154  //------------------------------------------------------------
155  // Versions for writing a single value
156  //------------------------------------------------------------
157 
158  void writeRegNoLock(std::string board, std::string name,
159  unsigned char data, CoordRange* range=0);
160 
161  void writeRegNoLock(std::string board, std::string name,
162  signed char data, CoordRange* range=0);
163 
164  void writeRegNoLock(std::string board, std::string name,
165  bool data, CoordRange* range=0);
166 
167  void writeRegNoLock(std::string board, std::string name,
168  unsigned short data, CoordRange* range=0);
169 
170  void writeRegNoLock(std::string board, std::string name,
171  signed short data, CoordRange* range=0);
172 
173  void writeRegNoLock(std::string board, std::string name,
174  unsigned int data, CoordRange* range=0);
175 
176  void writeRegNoLock(std::string board, std::string name,
177  signed int data, CoordRange* range=0);
178 
179  void writeRegNoLock(std::string board, std::string name,
180  float data, CoordRange* range=0);
181 
182  void writeRegNoLock(std::string board, std::string name,
183  double data, CoordRange* range=0);
184 
185  void writeRegNoLock(std::string board, std::string name,
186  RegDate::Data data, CoordRange* range=0);
187 
188  void writeRegNoLock(std::string board, std::string name,
189  Complex<float>::Data data, CoordRange* range=0);
190 
191  //-------------------------------------------------------------
192  // Methods to pack a named register.
193  //-------------------------------------------------------------
194 
195  void writeReg(RegMapBlock* blk,
196  unsigned char* data, CoordRange* range=0);
197 
198  void writeReg(RegMapBlock* blk,
199  signed char* data, CoordRange* range=0);
200 
201  void writeReg(RegMapBlock* blk,
202  bool* data, CoordRange* range=0);
203 
204  void writeReg(RegMapBlock* blk,
205  unsigned short* data, CoordRange* range=0);
206 
207  void writeReg(RegMapBlock* blk,
208  signed short* data, CoordRange* range=0);
209 
210  void writeReg(RegMapBlock* blk,
211  unsigned int* data, CoordRange* range=0);
212 
213  void writeReg(RegMapBlock* blk,
214  signed int* data, CoordRange* range=0);
215 
216  void writeReg(RegMapBlock* blk,
217  float* data, CoordRange* range=0);
218 
219  void writeReg(RegMapBlock* blk,
220  double* data, CoordRange* range=0);
221 
222  void writeReg(RegMapBlock* blk,
223  RegDate::Data* data, CoordRange* range=0);
224 
225  void writeReg(RegMapBlock* blk,
226  Complex<float>::Data* data, CoordRange* range=0);
227 
228  //------------------------------------------------------------
229  // Versions for writing a single value
230  //------------------------------------------------------------
231 
232  void writeReg(RegMapBlock* blk,
233  unsigned char data, CoordRange* range=0);
234 
235  void writeReg(RegMapBlock* blk,
236  signed char data, CoordRange* range=0);
237 
238  void writeReg(RegMapBlock* blk,
239  bool data, CoordRange* range=0);
240 
241  void writeReg(RegMapBlock* blk,
242  unsigned short data, CoordRange* range=0);
243 
244  void writeReg(RegMapBlock* blk,
245  signed short data, CoordRange* range=0);
246 
247  void writeReg(RegMapBlock* blk,
248  unsigned int data, CoordRange* range=0);
249 
250  void writeReg(RegMapBlock* blk,
251  signed int data, CoordRange* range=0);
252 
253  void writeReg(RegMapBlock* blk,
254  float data, CoordRange* range=0);
255 
256  void writeReg(RegMapBlock* blk,
257  double data, CoordRange* range=0);
258 
259  void writeReg(RegMapBlock* blk,
260  RegDate::Data data, CoordRange* range=0);
261 
262  void writeReg(RegMapBlock* blk,
263  Complex<float>::Data data, CoordRange* range=0);
264 
265  //------------------------------------------------------------
266  // Versions which don't lock
267  //------------------------------------------------------------
268 
269  void writeRegNoLock(RegMapBlock* blk,
270  unsigned char* data, CoordRange* range=0);
271 
272  void writeRegNoLock(RegMapBlock* blk,
273  signed char* data, CoordRange* range=0);
274 
275  void writeRegNoLock(RegMapBlock* blk,
276  bool* data, CoordRange* range=0);
277 
278  void writeRegNoLock(RegMapBlock* blk,
279  unsigned short* data, CoordRange* range=0);
280 
281  void writeRegNoLock(RegMapBlock* blk,
282  signed short* data, CoordRange* range=0);
283 
284  void writeRegNoLock(RegMapBlock* blk,
285  unsigned int* data, CoordRange* range=0);
286 
287  void writeRegNoLock(RegMapBlock* blk,
288  signed int* data, CoordRange* range=0);
289 
290  void writeRegNoLock(RegMapBlock* blk,
291  float* data, CoordRange* range=0);
292 
293  void writeRegNoLock(RegMapBlock* blk,
294  double* data, CoordRange* range=0);
295 
296  void writeRegNoLock(RegMapBlock* blk,
297  RegDate::Data* data, CoordRange* range=0);
298 
299  void writeRegNoLock(RegMapBlock* blk,
300  Complex<float>::Data* data, CoordRange* range=0);
301 
302  //------------------------------------------------------------
303  // Versions for writing a single value
304  //------------------------------------------------------------
305 
306  void writeRegNoLock(RegMapBlock* blk,
307  unsigned char data, CoordRange* range=0);
308 
309  void writeRegNoLock(RegMapBlock* blk,
310  signed char data, CoordRange* range=0);
311 
312  void writeRegNoLock(RegMapBlock* blk,
313  bool data, CoordRange* range=0);
314 
315  void writeRegNoLock(RegMapBlock* blk,
316  unsigned short data, CoordRange* range=0);
317 
318  void writeRegNoLock(RegMapBlock* blk,
319  signed short data, CoordRange* range=0);
320 
321  void writeRegNoLock(RegMapBlock* blk,
322  unsigned int data, CoordRange* range=0);
323 
324  void writeRegNoLock(RegMapBlock* blk,
325  signed int data, CoordRange* range=0);
326 
327  void writeRegNoLock(RegMapBlock* blk,
328  float data, CoordRange* range=0);
329 
330  void writeRegNoLock(RegMapBlock* blk,
331  double data, CoordRange* range=0);
332 
333  void writeRegNoLock(RegMapBlock* blk,
334  RegDate::Data data, CoordRange* range=0);
335 
336  void writeRegNoLock(RegMapBlock* blk,
337  Complex<float>::Data data, CoordRange* range=0);
338 
339  //------------------------------------------------------------
340  // Methods to read a named register
341  //------------------------------------------------------------
342 
343  void readReg(std::string board, std::string name,
344  unsigned char* data, CoordRange* range=0);
345 
346  void readReg(std::string board, std::string name,
347  signed char* data, CoordRange* range=0);
348 
349  void readReg(std::string board, std::string name,
350  bool* data, CoordRange* range=0);
351 
352  void readReg(std::string board, std::string name,
353  unsigned short* data, CoordRange* range=0);
354 
355  void readReg(std::string board, std::string name,
356  signed short* data, CoordRange* range=0);
357 
358  void readReg(std::string board, std::string name,
359  unsigned int* data, CoordRange* range=0);
360 
361  void readReg(std::string board, std::string name,
362  signed int* data, CoordRange* range=0);
363 
364  void readReg(std::string board, std::string name,
365  float* data, CoordRange* range=0);
366 
367  void readReg(std::string board, std::string name,
368  double* data, CoordRange* range=0);
369 
370  void readReg(std::string board, std::string name,
371  RegDate::Data* data, CoordRange* range=0);
372 
373  void readReg(std::string board, std::string name,
374  Complex<float>::Data* data, CoordRange* range=0);
375 
376  //------------------------------------------------------------
377  // Versions which don't lock
378  //------------------------------------------------------------
379 
380  void readRegNoLock(std::string board, std::string name,
381  unsigned char* data, CoordRange* range=0);
382 
383  void readRegNoLock(std::string board, std::string name,
384  signed char* data, CoordRange* range=0);
385 
386  void readRegNoLock(std::string board, std::string name,
387  bool* data, CoordRange* range=0);
388 
389  void readRegNoLock(std::string board, std::string name,
390  unsigned short* data, CoordRange* range=0);
391 
392  void readRegNoLock(std::string board, std::string name,
393  signed short* data, CoordRange* range=0);
394 
395  void readRegNoLock(std::string board, std::string name,
396  unsigned int* data, CoordRange* range=0);
397 
398  void readRegNoLock(std::string board, std::string name,
399  signed int* data, CoordRange* range=0);
400 
401  void readRegNoLock(std::string board, std::string name,
402  float* data, CoordRange* range=0);
403 
404  void readRegNoLock(std::string board, std::string name,
405  double* data, CoordRange* range=0);
406 
407  void readRegNoLock(std::string board, std::string name,
408  RegDate::Data* data, CoordRange* range=0);
409 
410  void readRegNoLock(std::string board, std::string name,
411  Complex<float>::Data* data, CoordRange* range=0);
412 
413  //------------------------------------------------------------
414  // Methods to read a named register
415  //------------------------------------------------------------
416 
417  void readReg(RegMapBlock* blk,
418  unsigned char* data, CoordRange* range=0);
419 
420  void readReg(RegMapBlock* blk,
421  signed char* data, CoordRange* range=0);
422 
423  void readReg(RegMapBlock* blk,
424  bool* data, CoordRange* range=0);
425 
426  void readReg(RegMapBlock* blk,
427  unsigned short* data, CoordRange* range=0);
428 
429  void readReg(RegMapBlock* blk,
430  signed short* data, CoordRange* range=0);
431 
432  void readReg(RegMapBlock* blk,
433  unsigned int* data, CoordRange* range=0);
434 
435  void readReg(RegMapBlock* blk,
436  signed int* data, CoordRange* range=0);
437 
438  void readReg(RegMapBlock* blk,
439  float* data, CoordRange* range=0);
440 
441  void readReg(RegMapBlock* blk,
442  double* data, CoordRange* range=0);
443 
444  void readReg(RegMapBlock* blk,
445  RegDate::Data* data, CoordRange* range=0);
446 
447  void readReg(RegMapBlock* blk,
448  Complex<float>::Data* data, CoordRange* range=0);
449 
450  //------------------------------------------------------------
451  // Versions which don't lock
452  //------------------------------------------------------------
453 
454  void readRegNoLock(RegMapBlock* blk,
455  unsigned char* data, CoordRange* range=0);
456 
457  void readRegNoLock(RegMapBlock* blk,
458  signed char* data, CoordRange* range=0);
459 
460  void readRegNoLock(RegMapBlock* blk,
461  bool* data, CoordRange* range=0);
462 
463  void readRegNoLock(RegMapBlock* blk,
464  unsigned short* data, CoordRange* range=0);
465 
466  void readRegNoLock(RegMapBlock* blk,
467  signed short* data, CoordRange* range=0);
468 
469  void readRegNoLock(RegMapBlock* blk,
470  unsigned int* data, CoordRange* range=0);
471 
472  void readRegNoLock(RegMapBlock* blk,
473  signed int* data, CoordRange* range=0);
474 
475  void readRegNoLock(RegMapBlock* blk,
476  float* data, CoordRange* range=0);
477 
478  void readRegNoLock(RegMapBlock* blk,
479  double* data, CoordRange* range=0);
480 
481  void readRegNoLock(RegMapBlock* blk,
482  RegDate::Data* data, CoordRange* range=0);
483 
484  void readRegNoLock(RegMapBlock* blk,
485  Complex<float>::Data* data, CoordRange* range=0);
486 
487  // Return true if this frame only contains archived registers
488 
489  inline bool archivedOnly() {return archivedOnly_;};
490 
494  unsigned int getId(unsigned nanoSecondInterval);
495 
499  void setMjd(TimeVal& mjd);
500  void setMjd(double mjd);
501 
502  RegMapBlock* findReg(char* boardName, char* blockName);
503 
504  RegMapBoard* findRegMapBoard(std::string boardName);
505 
510  int byteOffsetInFrameOf(RegMapBlock* blk, Coord* coord=0);
511  int byteOffsetInFrameOf(std::string board, std::string block,
512  Coord* coord=0);
513 
514  int byteOffsetInFrameOf(RegMapBlock* blk, CoordRange* range);
515  int byteOffsetInFrameOf(std::string board, std::string block,
516  CoordRange* range);
517 
518  protected:
519 
520  friend class ArrayMapDataFrameManager;
521 
522  SzaRegMap* regMap_; // An SZA register map
523 
528  bool archivedOnly_;
529 
534  int byteOffsetInRegMapOf(RegMapBlock* blk, Coord* coord=0);
535  int byteOffsetInRegMapOf(std::string board, std::string block,
536  Coord* coord=0);
537  int byteOffsetInRegMapOf(RegMapBlock* blk, CoordRange* range);
538  int byteOffsetInRegMapOf(std::string board, std::string block,
539  CoordRange* range);
540 
544  virtual void packData(RegMapBlock* blk, void* data, CoordRange* range,
545  DataType::Type type, bool lock=true);
546 
547  virtual void packData(std::string board, std::string block, void* data,
548  CoordRange* range, DataType::Type type, bool lock=true);
549 
550  virtual void packValue(RegMapBlock* blk, void* data, CoordRange* range,
551  DataType::Type type, bool lock=true);
552 
553  virtual void packValue(std::string board, std::string block, void* data,
554  CoordRange* range, DataType::Type type, bool lock=true);
555 
559  void unpackData(RegMapBlock* blk, void* data, CoordRange* range,
560  DataType::Type type, bool lock=true);
561 
562  void unpackData(std::string board, std::string block, void* data,
563  CoordRange* range, DataType::Type type, bool lock=true);
564 
568  RegMapDataFrameManager(bool archivedOnly=false);
569 
573  void checkType(std::string board, std::string block, DataType::Type type,
574  CoordRange* range);
575 
576  void checkType(RegMapBlock* blk, DataType::Type type,
577  CoordRange* range);
578 
579  public:
583  RegMapBlock* getReg(std::string board, std::string block);
584 
585  protected:
589  bool boardIsPresent(RegMapBoard* brd);
590 
594  bool blockIsPresent(RegMapBlock* blk);
595 
599  bool boardIsFlagged(RegMapBoard* brd);
600 
601  private:
602 
603  AxisRange axisRange_;
604 
605  }; // End class RegMapDataFrameManager
606 
607  } // End namespace util
608 } // End namespace sza
609 
610 
611 
612 #endif // End #ifndef SZA_UTIL_REGMAPDATAFRAMEMANAGER_H
sza::util::DataFrameManager::getId
virtual unsigned int getId()
Get a unique frame id based on integral MJD half-seconds.
Definition: DataFrameManager.h:128
Complex.h
Tagged: Tue Oct 12 10:25:49 PDT 2004.
DataFrameManager.h
Tagged: Fri Nov 14 12:37:53 UTC 2003.