My Project
 All Classes Files Functions Variables Enumerations Enumerator Friends Macros Pages
RegMapDataFrameManager.h
Go to the documentation of this file.
1 #ifndef GCP_UTIL_REGMAPDATAFRAMEMANAGER_H
2 #define GCP_UTIL_REGMAPDATAFRAMEMANAGER_H
3 
11 #include <string>
12 
13 #include "gcp/control/code/unix/libunix_src/common/genericregs.h"
14 
15 #include "gcp/util/common/Complex.h"
16 #include "gcp/util/common/DataFrameManager.h"
17 
18 
19 namespace gcp {
20  namespace util {
21 
22  class BoardDataFrameManager;
23  class ArrayMapDataFrameManager;
24  class Date;
25 
26  class RegMapDataFrameManager : public DataFrameManager {
27  public:
28 
32  virtual ~RegMapDataFrameManager();
33 
37  void operator=(DataFrameManager& manager);
38 
42  virtual void operator=(RegMapDataFrameManager& manager);
43 
47  void writeBoard(BoardDataFrameManager& fm, bool lockFrame);
48 
49  //-------------------------------------------------------------
50  // Methods to pack a named register.
51  //-------------------------------------------------------------
52 
53  void writeReg(std::string board, std::string name,
54  unsigned char* data, CoordRange* range=0);
55 
56  void writeReg(std::string board, std::string name,
57  signed char* data, CoordRange* range=0);
58 
59  void writeReg(std::string board, std::string name,
60  bool* data, CoordRange* range=0);
61 
62  void writeReg(std::string board, std::string name,
63  unsigned short* data, CoordRange* range=0);
64 
65  void writeReg(std::string board, std::string name,
66  signed short* data, CoordRange* range=0);
67 
68  void writeReg(std::string board, std::string name,
69  unsigned int* data, CoordRange* range=0);
70 
71  void writeReg(std::string board, std::string name,
72  signed int* data, CoordRange* range=0);
73 
74  void writeReg(std::string board, std::string name,
75  float* data, CoordRange* range=0);
76 
77  void writeReg(std::string board, std::string name,
78  double* data, CoordRange* range=0);
79 
80  void writeReg(std::string board, std::string name,
81  RegDate::Data* data, CoordRange* range=0);
82 
83  void writeReg(std::string board, std::string name,
84  Complex<float>::Data* data, CoordRange* range=0);
85 
86  //------------------------------------------------------------
87  // Methods for writing single values
88  //------------------------------------------------------------
89 
90  void writeReg(std::string board, std::string name,
91  unsigned char data, CoordRange* range=0);
92 
93  void writeReg(std::string board, std::string name,
94  signed char data, CoordRange* range=0);
95 
96  void writeReg(std::string board, std::string name,
97  bool data, CoordRange* range=0);
98 
99  void writeReg(std::string board, std::string name,
100  unsigned short data, CoordRange* range=0);
101 
102  void writeReg(std::string board, std::string name,
103  signed short data, CoordRange* range=0);
104 
105  void writeReg(std::string board, std::string name,
106  unsigned int data, CoordRange* range=0);
107 
108  void writeReg(std::string board, std::string name,
109  signed int data, CoordRange* range=0);
110 
111  void writeReg(std::string board, std::string name,
112  float data, CoordRange* range=0);
113 
114  void writeReg(std::string board, std::string name,
115  double data, CoordRange* range=0);
116 
117  void writeReg(std::string board, std::string name,
118  RegDate::Data data, CoordRange* range=0);
119 
120  void writeReg(std::string board, std::string name,
121  Complex<float>::Data data, CoordRange* range=0);
122 
123  //------------------------------------------------------------
124  // Versions which don't lock
125  //------------------------------------------------------------
126 
127  void writeRegNoLock(std::string board, std::string name,
128  unsigned char* data, CoordRange* range=0);
129 
130  void writeRegNoLock(std::string board, std::string name,
131  signed char* data, CoordRange* range=0);
132 
133  void writeRegNoLock(std::string board, std::string name,
134  bool* data, CoordRange* range=0);
135 
136  void writeRegNoLock(std::string board, std::string name,
137  unsigned short* data, CoordRange* range=0);
138 
139  void writeRegNoLock(std::string board, std::string name,
140  signed short* data, CoordRange* range=0);
141 
142  void writeRegNoLock(std::string board, std::string name,
143  unsigned int* data, CoordRange* range=0);
144 
145  void writeRegNoLock(std::string board, std::string name,
146  signed int* data, CoordRange* range=0);
147 
148  void writeRegNoLock(std::string board, std::string name,
149  float* data, CoordRange* range=0);
150 
151  void writeRegNoLock(std::string board, std::string name,
152  double* data, CoordRange* range=0);
153 
154  void writeRegNoLock(std::string board, std::string name,
155  RegDate::Data* data, CoordRange* range=0);
156 
157  void writeRegNoLock(std::string board, std::string name,
158  Complex<float>::Data* data, CoordRange* range=0);
159 
160  //------------------------------------------------------------
161  // Versions for writing a single value
162  //------------------------------------------------------------
163 
164  void writeRegNoLock(std::string board, std::string name,
165  unsigned char data, CoordRange* range=0);
166 
167  void writeRegNoLock(std::string board, std::string name,
168  signed char data, CoordRange* range=0);
169 
170  void writeRegNoLock(std::string board, std::string name,
171  bool data, CoordRange* range=0);
172 
173  void writeRegNoLock(std::string board, std::string name,
174  unsigned short data, CoordRange* range=0);
175 
176  void writeRegNoLock(std::string board, std::string name,
177  signed short data, CoordRange* range=0);
178 
179  void writeRegNoLock(std::string board, std::string name,
180  unsigned int data, CoordRange* range=0);
181 
182  void writeRegNoLock(std::string board, std::string name,
183  signed int data, CoordRange* range=0);
184 
185  void writeRegNoLock(std::string board, std::string name,
186  float data, CoordRange* range=0);
187 
188  void writeRegNoLock(std::string board, std::string name,
189  double data, CoordRange* range=0);
190 
191  void writeRegNoLock(std::string board, std::string name,
192  RegDate::Data data, CoordRange* range=0);
193 
194  void writeRegNoLock(std::string board, std::string name,
195  Complex<float>::Data data, CoordRange* range=0);
196 
197  //-------------------------------------------------------------
198  // Methods to pack a named register.
199  //-------------------------------------------------------------
200 
201  void writeReg(RegMapBlock* blk,
202  unsigned char* data, CoordRange* range=0);
203 
204  void writeReg(RegMapBlock* blk,
205  signed char* data, CoordRange* range=0);
206 
207  //void writeReg(RegMapBlock* blk,
208  //bool* data, CoordRange* range=0);
209 
210  void writeReg(RegMapBlock* blk,
211  unsigned short* data, CoordRange* range=0);
212 
213  void writeReg(RegMapBlock* blk,
214  signed short* data, CoordRange* range=0);
215 
216  void writeReg(RegMapBlock* blk,
217  unsigned int* data, CoordRange* range=0);
218 
219  void writeReg(RegMapBlock* blk,
220  signed int* data, CoordRange* range=0);
221 
222  void writeReg(RegMapBlock* blk,
223  float* data, CoordRange* range=0);
224 
225  void writeReg(RegMapBlock* blk,
226  double* data, CoordRange* range=0);
227 
228  void writeReg(RegMapBlock* blk,
229  RegDate::Data* data, CoordRange* range=0);
230 
231  void writeReg(RegMapBlock* blk,
232  Complex<float>::Data* data, CoordRange* range=0);
233 
234  //------------------------------------------------------------
235  // Versions for writing a single value
236  //------------------------------------------------------------
237 
238  void writeReg(RegMapBlock* blk,
239  unsigned char data, CoordRange* range=0);
240 
241  void writeReg(RegMapBlock* blk,
242  signed char data, CoordRange* range=0);
243 
244  void writeReg(RegMapBlock* blk,
245  bool data, CoordRange* range=0);
246 
247  void writeReg(RegMapBlock* blk,
248  unsigned short data, CoordRange* range=0);
249 
250  void writeReg(RegMapBlock* blk,
251  signed short data, CoordRange* range=0);
252 
253  void writeReg(RegMapBlock* blk,
254  unsigned int data, CoordRange* range=0);
255 
256  void writeReg(RegMapBlock* blk,
257  signed int data, CoordRange* range=0);
258 
259  void writeReg(RegMapBlock* blk,
260  float data, CoordRange* range=0);
261 
262  void writeDcReg(RegMapBlock* blk,
263  float data, CoordRange* range=0);
264 
265  void writeReg(RegMapBlock* blk,
266  double data, CoordRange* range=0);
267 
268  void writeReg(RegMapBlock* blk,
269  RegDate::Data data, CoordRange* range=0);
270 
271  void writeReg(RegMapBlock* blk,
272  Complex<float>::Data data, CoordRange* range=0);
273 
274  //------------------------------------------------------------
275  // Versions which don't lock
276  //------------------------------------------------------------
277 
278  void writeRegNoLock(RegMapBlock* blk,
279  unsigned char* data, CoordRange* range=0);
280 
281  void writeRegNoLock(RegMapBlock* blk,
282  signed char* data, CoordRange* range=0);
283 
284  void writeRegNoLock(RegMapBlock* blk,
285  bool* data, CoordRange* range=0);
286 
287  void writeRegNoLock(RegMapBlock* blk,
288  unsigned short* data, CoordRange* range=0);
289 
290  void writeRegNoLock(RegMapBlock* blk,
291  signed short* data, CoordRange* range=0);
292 
293  void writeRegNoLock(RegMapBlock* blk,
294  unsigned int* data, CoordRange* range=0);
295 
296  void writeRegNoLock(RegMapBlock* blk,
297  signed int* data, CoordRange* range=0);
298 
299  void writeRegNoLock(RegMapBlock* blk,
300  float* data, CoordRange* range=0);
301 
302  void writeRegNoLock(RegMapBlock* blk,
303  double* data, CoordRange* range=0);
304 
305  void writeRegNoLock(RegMapBlock* blk,
306  RegDate::Data* data, CoordRange* range=0);
307 
308  void writeRegNoLock(RegMapBlock* blk,
309  Complex<float>::Data* data, CoordRange* range=0);
310 
311  //------------------------------------------------------------
312  // Versions for writing a single value
313  //------------------------------------------------------------
314 
315  void writeRegNoLock(RegMapBlock* blk,
316  unsigned char data, CoordRange* range=0);
317 
318  void writeRegNoLock(RegMapBlock* blk,
319  signed char data, CoordRange* range=0);
320 
321  void writeRegNoLock(RegMapBlock* blk,
322  bool data, CoordRange* range=0);
323 
324  void writeRegNoLock(RegMapBlock* blk,
325  unsigned short data, CoordRange* range=0);
326 
327  void writeRegNoLock(RegMapBlock* blk,
328  signed short data, CoordRange* range=0);
329 
330  void writeRegNoLock(RegMapBlock* blk,
331  unsigned int data, CoordRange* range=0);
332 
333  void writeRegNoLock(RegMapBlock* blk,
334  signed int data, CoordRange* range=0);
335 
336  void writeRegNoLock(RegMapBlock* blk,
337  float data, CoordRange* range=0);
338 
339  void writeRegNoLock(RegMapBlock* blk,
340  double data, CoordRange* range=0);
341 
342  void writeRegNoLock(RegMapBlock* blk,
343  RegDate::Data data, CoordRange* range=0);
344 
345  void writeRegNoLock(RegMapBlock* blk,
346  Complex<float>::Data data, CoordRange* range=0);
347 
348  //------------------------------------------------------------
349  // Methods to read a named register
350  //------------------------------------------------------------
351 
352  void readReg(std::string board, std::string name,
353  unsigned char* data, CoordRange* range=0);
354 
355  void readReg(std::string board, std::string name,
356  signed char* data, CoordRange* range=0);
357 
358  void readReg(std::string board, std::string name,
359  bool* data, CoordRange* range=0);
360 
361  void readReg(std::string board, std::string name,
362  unsigned short* data, CoordRange* range=0);
363 
364  void readReg(std::string board, std::string name,
365  signed short* data, CoordRange* range=0);
366 
367  void readReg(std::string board, std::string name,
368  unsigned int* data, CoordRange* range=0);
369 
370  void readReg(std::string board, std::string name,
371  signed int* data, CoordRange* range=0);
372 
373  void readReg(std::string board, std::string name,
374  float* data, CoordRange* range=0);
375 
376  void readReg(std::string board, std::string name,
377  double* data, CoordRange* range=0);
378 
379  void readReg(std::string board, std::string name,
380  RegDate::Data* data, CoordRange* range=0);
381 
382  void readReg(std::string board, std::string name,
383  Complex<float>::Data* data, CoordRange* range=0);
384 
385  //------------------------------------------------------------
386  // Versions which don't lock
387  //------------------------------------------------------------
388 
389  void readRegNoLock(std::string board, std::string name,
390  unsigned char* data, CoordRange* range=0);
391 
392  void readRegNoLock(std::string board, std::string name,
393  signed char* data, CoordRange* range=0);
394 
395  void readRegNoLock(std::string board, std::string name,
396  bool* data, CoordRange* range=0);
397 
398  void readRegNoLock(std::string board, std::string name,
399  unsigned short* data, CoordRange* range=0);
400 
401  void readRegNoLock(std::string board, std::string name,
402  signed short* data, CoordRange* range=0);
403 
404  void readRegNoLock(std::string board, std::string name,
405  unsigned int* data, CoordRange* range=0);
406 
407  void readRegNoLock(std::string board, std::string name,
408  signed int* data, CoordRange* range=0);
409 
410  void readRegNoLock(std::string board, std::string name,
411  float* data, CoordRange* range=0);
412 
413  void readRegNoLock(std::string board, std::string name,
414  double* data, CoordRange* range=0);
415 
416  void readRegNoLock(std::string board, std::string name,
417  RegDate::Data* data, CoordRange* range=0);
418 
419  void readRegNoLock(std::string board, std::string name,
420  Complex<float>::Data* data, CoordRange* range=0);
421 
422  //------------------------------------------------------------
423  // Methods to read a named register
424  //------------------------------------------------------------
425 
426  void readReg(RegMapBlock* blk,
427  unsigned char* data, CoordRange* range=0);
428 
429  void readReg(RegMapBlock* blk,
430  signed char* data, CoordRange* range=0);
431 
432  void readReg(RegMapBlock* blk,
433  bool* data, CoordRange* range=0);
434 
435  void readReg(RegMapBlock* blk,
436  unsigned short* data, CoordRange* range=0);
437 
438  void readReg(RegMapBlock* blk,
439  signed short* data, CoordRange* range=0);
440 
441  void readReg(RegMapBlock* blk,
442  unsigned int* data, CoordRange* range=0);
443 
444  void readReg(RegMapBlock* blk,
445  signed int* data, CoordRange* range=0);
446 
447  void readReg(RegMapBlock* blk,
448  float* data, CoordRange* range=0);
449 
450  void readReg(RegMapBlock* blk,
451  double* data, CoordRange* range=0);
452 
453  void readReg(RegMapBlock* blk,
454  RegDate::Data* data, CoordRange* range=0);
455 
456  void readReg(RegMapBlock* blk,
457  Complex<float>::Data* data, CoordRange* range=0);
458 
459  //------------------------------------------------------------
460  // Versions which don't lock
461  //------------------------------------------------------------
462 
463  void readRegNoLock(RegMapBlock* blk,
464  unsigned char* data, CoordRange* range=0);
465 
466  void readRegNoLock(RegMapBlock* blk,
467  signed char* data, CoordRange* range=0);
468 
469  void readRegNoLock(RegMapBlock* blk,
470  bool* data, CoordRange* range=0);
471 
472  void readRegNoLock(RegMapBlock* blk,
473  unsigned short* data, CoordRange* range=0);
474 
475  void readRegNoLock(RegMapBlock* blk,
476  signed short* data, CoordRange* range=0);
477 
478  void readRegNoLock(RegMapBlock* blk,
479  unsigned int* data, CoordRange* range=0);
480 
481  void readRegNoLock(RegMapBlock* blk,
482  signed int* data, CoordRange* range=0);
483 
484  void readRegNoLock(RegMapBlock* blk,
485  float* data, CoordRange* range=0);
486 
487  void readRegNoLock(RegMapBlock* blk,
488  double* data, CoordRange* range=0);
489 
490  void readRegNoLock(RegMapBlock* blk,
491  RegDate::Data* data, CoordRange* range=0);
492 
493  void readRegNoLock(RegMapBlock* blk,
494  Complex<float>::Data* data, CoordRange* range=0);
495 
496  // Return true if this frame only contains archived registers
497 
498  inline bool archivedOnly() {return archivedOnly_;};
499 
503  unsigned int getId(unsigned nanoSecondInterval);
504 
505  //------------------------------------------------------------
506  // Methods for setting registers maintained by all register maps
507  //------------------------------------------------------------
508 
513  // Set to the current mjd
514 
515  void setMjd();
516 
517  // Set to passed mjd
518 
519  void setMjd(RegDate& regDate);
520  void setMjd(TimeVal& mjd);
521  void setMjd(double mjd);
522 
523  // Increment the record counter for this frame
524 
525  void incrementRecord();
526  void setRecord(unsigned record);
527 
528  // Set the received flag to true for this frame
529 
530  void setReceived(bool received);
531 
532  //------------------------------------------------------------
533  // Methods for looking up registers
534  //------------------------------------------------------------
535 
536  RegMapBlock* findReg(char* boardName, char* blockName);
537 
538  RegMapBoard* findRegMapBoard(std::string boardName);
539 
540  //------------------------------------------------------------
541  // Methods for calculating byte offsets
542  //------------------------------------------------------------
543 
548  int byteOffsetInFrameOf(RegMapBlock* blk, Coord* coord=0);
549  int byteOffsetInFrameOf(std::string board, std::string block,
550  Coord* coord=0);
551 
552  int byteOffsetInFrameOf(RegMapBlock* blk, CoordRange* range);
553  int byteOffsetInFrameOf(std::string board, std::string block,
554  CoordRange* range);
555 
556  int byteOffsetInFrameOf(RegMapBoard* brd, RegMapBlock* blk);
557 
558  int byteOffsetInFrameOf(RegMapBoard* brd);
559  int byteOffsetInFrameOf(std::string board);
560 
564  char* getCharPtr( char* boardName, char* blockName);
565  unsigned char* getUcharPtr( char* boardName, char* blockName);
566  short* getShortPtr( char* boardName, char* blockName);
567  unsigned short* getUshortPtr(char* boardName, char* blockName);
568  unsigned int* getUintPtr( char* boardName, char* blockName);
569  int* getIntPtr( char* boardName, char* blockName);
570  float* getFloatPtr( char* boardName, char* blockName);
571  double* getDoublePtr(char* boardName, char* blockName);
572  RegDate::Data* getDatePtr( char* boardName, char* blockName);
573 
574  protected:
575 
576  friend class ArrayMapDataFrameManager;
577 
578  ArrayMap* arrayMap_;
579 
580  RegMap* regMap_; // A register map
581 
586  bool archivedOnly_;
587 
592  int byteOffsetInRegMapOf(RegMapBlock* blk, Coord* coord=0);
593  int byteOffsetInRegMapOf(std::string board, std::string block,
594  Coord* coord=0);
595  int byteOffsetInRegMapOf(RegMapBlock* blk, CoordRange* range);
596  int byteOffsetInRegMapOf(std::string board, std::string block,
597  CoordRange* range);
598 
602  void packData(RegMapBlock* blk, void* data, CoordRange* range,
603  DataType::Type type, bool lock=true);
604 
605  void packData(std::string board, std::string block, void* data,
606  CoordRange* range, DataType::Type type, bool lock=true);
607 
608  void packValue(RegMapBlock* blk, void* data, CoordRange* range,
609  DataType::Type type, bool lock=true);
610 
611  void packDcValue(RegMapBlock* blk, void* data, CoordRange* range,
612  DataType::Type type, bool lock=true);
613 
614  void packValue(std::string board, std::string block, void* data,
615  CoordRange* range, DataType::Type type, bool lock=true);
619  void unpackData(RegMapBlock* blk, void* data, CoordRange* range,
620  DataType::Type type, bool lock=true);
621  void unpackData(std::string board, std::string block, void* data,
622  CoordRange* range, DataType::Type type, bool lock=true);
623 
628  // Constructor.
629 
630  RegMapDataFrameManager(std::string regmap, bool archivedOnly=false);
631 
632  RegMapDataFrameManager(bool archivedOnly=false);
633 
637  void checkType(std::string board, std::string block,
638  DataType::Type type, CoordRange* range=0);
639 
640  void checkType(RegMapBlock* blk, DataType::Type type,
641  CoordRange* range=0);
642 
646  DataType::Type typeOf(RegMapBlock* blk);
647 
651  RegMapBlock* getReg(std::string board, std::string block);
652 
656  bool boardIsPresent(RegMapBoard* brd);
657 
661  bool blockIsPresent(RegMapBlock* blk);
662 
666  bool boardIsFlagged(RegMapBoard* brd);
667 
668  private:
669 
670  unsigned record_;
671  AxisRange axisRange_;
672 
673  }; // End class RegMapDataFrameManager
674 
675  } // End namespace util
676 } // End namespace gcp
677 
678 
679 
680 
681 #endif // End #ifndef GCP_UTIL_REGMAPDATAFRAMEMANAGER_H
gcp::util::RegMapDataFrameManager::operator=
void operator=(DataFrameManager &manager)
Definition: RegMapDataFrameManager.cc:78
gcp::util::BoardDataFrameManager
Definition: BoardDataFrameManager.h:31
gcp::util::RegMapDataFrameManager::getReg
RegMapBlock * getReg(std::string board, std::string block)
Definition: RegMapDataFrameManager.cc:451
gcp::util::RegMapDataFrameManager::archivedOnly_
bool archivedOnly_
Definition: RegMapDataFrameManager.h:586
gcp::util::RegMapDataFrameManager::checkType
void checkType(std::string board, std::string block, DataType::Type type, CoordRange *range=0)
gcp::util::AxisRange
Definition: AxisRange.h:19
gcp::util::RegMapDataFrameManager::blockIsPresent
bool blockIsPresent(RegMapBlock *blk)
Definition: RegMapDataFrameManager.cc:2399
gcp::util::RegDate::Data
Definition: RegDate.h:22
gcp::util::RegMapDataFrameManager::getCharPtr
char * getCharPtr(char *boardName, char *blockName)
Definition: RegMapDataFrameManager.cc:2502
gcp::util::RegMapDataFrameManager::byteOffsetInFrameOf
int byteOffsetInFrameOf(RegMapBlock *blk, Coord *coord=0)
Definition: RegMapDataFrameManager.cc:254
gcp::util::RegMapDataFrameManager::packData
void packData(RegMapBlock *blk, void *data, CoordRange *range, DataType::Type type, bool lock=true)
Definition: RegMapDataFrameManager.cc:320
gcp::util::RegMapDataFrameManager::setMjd
void setMjd()
Definition: RegMapDataFrameManager.cc:2433
gcp::util::Coord
Definition: Coord.h:21
gcp::util::CoordRange
Definition: CoordRange.h:20
gcp::util::RegMapDataFrameManager::setRecord
void setRecord(unsigned record)
Definition: RegMapDataFrameManager.cc:2451
gcp::util::RegMapDataFrameManager::unpackData
void unpackData(RegMapBlock *blk, void *data, CoordRange *range, DataType::Type type, bool lock=true)
Definition: RegMapDataFrameManager.cc:417
gcp::util::RegMapDataFrameManager::byteOffsetInRegMapOf
int byteOffsetInRegMapOf(RegMapBlock *blk, Coord *coord=0)
Definition: RegMapDataFrameManager.cc:182
gcp::util::DataFrameManager::getId
virtual unsigned int getId()
Definition: DataFrameManager.h:128
gcp::util::DataFrameManager::lock
void lock()
Definition: DataFrameManager.cc:406
gcp::util::ArrayMapDataFrameManager
Definition: ArrayMapDataFrameManager.h:28
gcp::util::RegMapDataFrameManager::writeBoard
void writeBoard(BoardDataFrameManager &fm, bool lockFrame)
Definition: RegMapDataFrameManager.cc:2562
gcp::util::RegMapDataFrameManager::boardIsPresent
bool boardIsPresent(RegMapBoard *brd)
Definition: RegMapDataFrameManager.cc:2388
gcp::util::TimeVal
Definition: TimeVal.h:55
Date
Definition: logfile.c:14
gcp::util::RegDate
Definition: RegDate.h:19
gcp::util::RegMapDataFrameManager::typeOf
DataType::Type typeOf(RegMapBlock *blk)
Definition: RegMapDataFrameManager.cc:539
gcp::util::DataFrameManager
Definition: DataFrameManager.h:23
gcp::util::RegMapDataFrameManager::incrementRecord
void incrementRecord()
Definition: RegMapDataFrameManager.cc:2442
gcp::util::Complex
Definition: Complex.h:26
gcp::util::RegMapDataFrameManager::RegMapDataFrameManager
RegMapDataFrameManager(std::string regmap, bool archivedOnly=false)
gcp::util::RegMapDataFrameManager::packDcValue
void packDcValue(RegMapBlock *blk, void *data, CoordRange *range, DataType::Type type, bool lock=true)
Definition: RegMapDataFrameManager.cc:382
gcp::util::RegMapDataFrameManager
Definition: RegMapDataFrameManager.h:26
gcp::util::RegMapDataFrameManager::~RegMapDataFrameManager
virtual ~RegMapDataFrameManager()
Definition: RegMapDataFrameManager.cc:67
gcp::util::RegMapDataFrameManager::boardIsFlagged
bool boardIsFlagged(RegMapBoard *brd)
Definition: RegMapDataFrameManager.cc:2374
gcp::util::RegMapDataFrameManager::setReceived
void setReceived(bool received)
Definition: RegMapDataFrameManager.cc:2459
gcp::util::RegMapDataFrameManager::packValue
void packValue(RegMapBlock *blk, void *data, CoordRange *range, DataType::Type type, bool lock=true)
Definition: RegMapDataFrameManager.cc:355
ArrayMap
Definition: arraymap.h:177