CARMA C++
ArrayMapDataFrameManager.h
Go to the documentation of this file.
1 #ifndef SZA_UTIL_ARRAYMAPDATAFRAMEMANAGER_H
2 #define SZA_UTIL_ARRAYMAPDATAFRAMEMANAGER_H
3 
11 #include <string>
12 
13 #include "carma/szaarrayutils/arraymap.h"
14 
15 #include "carma/szautil/DataFrameManager.h"
16 #include "carma/szautil/RegMapDataFrameManager.h"
17 #include "carma/szautil/RegRange.h"
18 #include "carma/szautil/Complex.h"
19 
20 namespace sza {
21  namespace util {
22 
23  class CoordRange;
24  class Date;
25  class RegDescription;
26 
27  class ArrayMapDataFrameManager : public DataFrameManager {
28  public:
29 
33  virtual ~ArrayMapDataFrameManager();
34 
38  void operator=(DataFrameManager& manager);
39 
43  virtual void operator=(ArrayMapDataFrameManager& manager);
44 
50  ArrayMapDataFrameManager& operator+=(ArrayMapDataFrameManager& fm);
51 
55  void writeRegMap(ArrRegMap* aregmap,
56  RegMapDataFrameManager& fm, bool lockFrame);
57 
58  void writeRegMap(std::string regmap,
59  RegMapDataFrameManager& fm, bool lockFrame);
60 
64  void readRegMap(ArrRegMap* aregmap, RegMapDataFrameManager& fm);
65  void readRegMap(std::string regmap, RegMapDataFrameManager& fm);
66 
67  //-------------------------------------------------------------
68  // Methods to pack a named register.
69  //-------------------------------------------------------------
70 
71  void writeReg(std::string regmap, std::string board, std::string name,
72  unsigned char* data, CoordRange* range=0);
73 
74  void writeReg(std::string regmap, std::string board, std::string name,
75  signed char* data, CoordRange* range=0);
76 
77  void writeReg(std::string regmap, std::string board, std::string name,
78  bool* data, CoordRange* range=0);
79 
80  void writeReg(std::string regmap, std::string board, std::string name,
81  unsigned short* data, CoordRange* range=0);
82 
83  void writeReg(std::string regmap, std::string board, std::string name,
84  signed short* data, CoordRange* range=0);
85 
86  void writeReg(std::string regmap, std::string board, std::string name,
87  unsigned int* data, CoordRange* range=0);
88 
89  void writeReg(std::string regmap, std::string board, std::string name,
90  signed int* data, CoordRange* range=0);
91 
92  void writeReg(std::string regmap, std::string board, std::string name,
93  float* data, CoordRange* range=0);
94 
95  void writeReg(std::string regmap, std::string board, std::string name,
96  double* data, CoordRange* range=0);
97 
98  void writeReg(std::string regmap, std::string board, std::string name,
99  RegDate::Data* data, CoordRange* range=0);
100 
101  void writeReg(std::string regmap, std::string board, std::string name,
102  Complex<float>::Data* data, CoordRange* range=0);
103 
104  //-------------------------------------------------------------
105  // Methods to pack single-valued registers.
106  //-------------------------------------------------------------
107 
108  void writeReg(std::string regmap, std::string board, std::string name,
109  unsigned char data, CoordRange* range=0);
110 
111  void writeReg(std::string regmap, std::string board, std::string name,
112  signed char data, CoordRange* range=0);
113 
114  void writeReg(std::string regmap, std::string board, std::string name,
115  bool data, CoordRange* range=0);
116 
117  void writeReg(std::string regmap, std::string board, std::string name,
118  unsigned short data, CoordRange* range=0);
119 
120  void writeReg(std::string regmap, std::string board, std::string name,
121  signed short data, CoordRange* range=0);
122 
123  void writeReg(std::string regmap, std::string board, std::string name,
124  unsigned int data, CoordRange* range=0);
125 
126  void writeReg(std::string regmap, std::string board, std::string name,
127  signed int data, CoordRange* range=0);
128 
129  void writeReg(std::string regmap, std::string board, std::string name,
130  float data, CoordRange* range=0);
131 
132  void writeReg(std::string regmap, std::string board, std::string name,
133  double data, CoordRange* range=0);
134 
135  void writeReg(std::string regmap, std::string board, std::string name,
136  RegDate::Data data, CoordRange* range=0);
137 
138  void writeReg(std::string regmap, std::string board, std::string name,
139  Complex<float>::Data data, CoordRange* range=0);
140 
141  //-------------------------------------------------------------
142  // Methods to pack a named register.
143  //-------------------------------------------------------------
144 
145  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
146  unsigned char* data, CoordRange* range=0, bool lockFrame=true);
147 
148  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
149  signed char* data, CoordRange* range=0, bool lockFrame=true);
150 
151  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
152  bool* data, CoordRange* range=0, bool lockFrame=true);
153 
154  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
155  unsigned short* data, CoordRange* range=0, bool lockFrame=true);
156 
157  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
158  signed short* data, CoordRange* range=0, bool lockFrame=true);
159 
160  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
161  unsigned int* data, CoordRange* range=0, bool lockFrame=true);
162 
163  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
164  signed int* data, CoordRange* range=0, bool lockFrame=true);
165 
166  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
167  float* data, CoordRange* range=0, bool lockFrame=true);
168 
169  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
170  double* data, CoordRange* range=0, bool lockFrame=true);
171 
172  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
173  RegDate::Data* data, CoordRange* range=0, bool lockFrame=true);
174 
175  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
176  Complex<float>::Data* data, CoordRange* range=0, bool lockFrame=true);
177 
178  //-------------------------------------------------------------
179  // Methods to pack a single-valued register.
180  //-------------------------------------------------------------
181 
182  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
183  unsigned char data, CoordRange* range=0);
184 
185  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
186  signed char data, CoordRange* range=0);
187 
188  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
189  bool data, CoordRange* range=0);
190 
191  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
192  unsigned short data, CoordRange* range=0);
193 
194  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
195  signed short data, CoordRange* range=0);
196 
197  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
198  unsigned int data, CoordRange* range=0);
199 
200  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
201  signed int data, CoordRange* range=0);
202 
203  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
204  float data, CoordRange* range=0);
205 
206  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
207  double data, CoordRange* range=0);
208 
209  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
210  RegDate::Data data, CoordRange* range=0);
211 
212  void writeReg(ArrRegMap* aregmap, RegMapBlock* blk,
213  Complex<float>::Data data, CoordRange* range=0);
214 
215  //------------------------------------------------------------
216  // Methods to read a named register
217  //------------------------------------------------------------
218 
219  void readReg(std::string regmap, std::string board, std::string name,
220  unsigned char* data, CoordRange* range=0);
221 
222  void readReg(std::string regmap, std::string board, std::string name,
223  signed char* data, CoordRange* range=0);
224 
225  void readReg(std::string regmap, std::string board, std::string name,
226  bool* data, CoordRange* range=0);
227 
228  void readReg(std::string regmap, std::string board, std::string name,
229  unsigned short* data, CoordRange* range=0);
230 
231  void readReg(std::string regmap, std::string board, std::string name,
232  signed short* data, CoordRange* range=0);
233 
234  void readReg(std::string regmap, std::string board, std::string name,
235  unsigned int* data, CoordRange* range=0);
236 
237  void readReg(std::string regmap, std::string board, std::string name,
238  signed int* data, CoordRange* range=0);
239 
240  void readReg(std::string regmap, std::string board, std::string name,
241  float* data, CoordRange* range=0);
242 
243  void readReg(std::string regmap, std::string board, std::string name,
244  double* data, CoordRange* range=0);
245 
246  void readReg(std::string regmap, std::string board, std::string name,
247  RegDate::Data* data, CoordRange* range=0);
248 
249  void readReg(std::string regmap, std::string board, std::string name,
250  Complex<float>::Data* data, CoordRange* range=0);
251 
252  //------------------------------------------------------------
253  // Methods to read a named register
254  //------------------------------------------------------------
255 
256  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
257  unsigned char* data, CoordRange* range=0);
258 
259  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
260  signed char* data, CoordRange* range=0);
261 
262  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
263  bool* data, CoordRange* range=0);
264 
265  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
266  unsigned short* data, CoordRange* range=0);
267 
268  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
269  signed short* data, CoordRange* range=0);
270 
271  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
272  unsigned int* data, CoordRange* range=0);
273 
274  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
275  signed int* data, CoordRange* range=0);
276 
277  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
278  float* data, CoordRange* range=0);
279 
280  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
281  double* data, CoordRange* range=0);
282 
283  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
284  RegDate::Data* data, CoordRange* range=0);
285 
286  void readReg(ArrRegMap* aregmap, RegMapBlock* blk,
287  Complex<float>::Data* data, CoordRange* range=0);
288 
289  // Return the value of the current register in a range, cast as
290  // a double
291 
292  double getRegVal(RegRange& range, bool lockFrame);
293 
294  // Return the value of the requested register index, cast as a double
295 
296  double getRegVal(RegDescription& desc);
297 
298  // Return true if this frame only contains archived registers
299 
300  inline bool archivedOnly() {return archivedOnly_;};
301 
302  // Return a pointer to the array map
303 
304  inline SzaArrayMap* arrayMap() {
305  return arrayMap_;
306  }
307 
311  unsigned int getId(unsigned nanoSecondInterval);
312 
313  int byteOffsetInFrameOf(std::string regmap, std::string board,
314  std::string block, Coord* coord=0);
315 
316  // Get a pointer to the start of the register described in a
317  // RegDescription, in our data frame.
318 
319  void* getPtr(RegDescription& desc);
320 
321  public:
322 
323  SzaArrayMap* arrayMap_; // The SZA array map
324 
325  bool archivedOnly_; // True if this frame should
326  // contain only archived registers
330  ArrayMapDataFrameManager(bool archivedOnly_=false);
331 
336  int byteOffsetInFrameOf(ArrRegMap* aregmap, RegMapBlock* blk,
337  Coord* coord=0);
338  int byteOffsetInFrameOf(ArrRegMap* aregmap);
339 
343  void packData(ArrRegMap* aregmap, RegMapBlock* blk,
344  void* data, CoordRange* range,
345  DataType::Type type, bool lockFrame=true);
346  void packData(std::string regmap, std::string board, std::string block,
347  void* data, CoordRange* range,
348  DataType::Type type, bool lockFrame=true);
349 
353  void unpackData(ArrRegMap* aregmap, RegMapBlock* blk,
354  void* data, CoordRange* range,
355  DataType::Type type, bool lockFrame=true);
356  void unpackData(std::string regmap, std::string board, std::string block,
357  void* data, CoordRange* range,
358  DataType::Type type,bool lockFrame=true);
359 
363  void checkType(std::string regmap, std::string board, std::string block,
364  DataType::Type type,
365  CoordRange* range);
366 
367  void checkType(ArrRegMap* aregmap, RegMapBlock* blk, DataType::Type type,
368  CoordRange* range);
369 
370  public:
374  RegMapBlock* getReg(std::string regmap, std::string board,
375  std::string block);
376 
377  RegMapBlock* findReg(std::string regmap, std::string board,
378  std::string block);
379 
380  ArrRegMap* getArrReg(std::string regmap);
381 
385  bool regMapIsPresent(RegMap* regmap);
386 
390  bool boardIsPresent(RegMapBoard* brd);
391 
395  bool boardIsFlagged(ArrRegMap* aregmap, RegMapBoard* brd);
396 
400  bool blockIsPresent(RegMapBlock* blk);
401 
402  }; // End class ArrayMapDataFrameManager
403 
404  } // End namespace util
405 } // End namespace sza
406 
407 
408 
409 #endif // End #ifndef SZA_UTIL_ARRAYMAPDATAFRAMEMANAGER_H
RegMapDataFrameManager.h
Tagged: Sat Aug 14 13:12:19 UTC 2004.
RegRange.h
Tagged: Sun Sep 26 14:35:48 UTC 2004.
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.