CARMA C++
CobraDataFormat.h
1 #ifndef COBRADATAFORMAT_H
2 #define COBRADATAFORMAT_H
3 
4 #include <vector>
5 #include "carma/util/Serializable.h"
6 
7 namespace carma {
8  namespace correlator {
9  namespace lib {
10 
11  class CobraDataFormat :
12  public carma::util::Serializable {
13  public:
14  CobraDataFormat(){}
15  ~CobraDataFormat(){}
16 
17  int size()
18  {
19  // Return the serialized data size in bytes
20  // (Hmm, this seems kind of ugly. Perhaps
21  // I should put the data members in a struct).
22  return 15*4;
23 
24  }
25 
26  int getSizeInBytes() const {
27  return 15*4;
28  }
29 
30  void mySerialize( char * const byteArray,
31  int * const offset ) const
32  {
33  pack(id_, byteArray, offset);
34  pack(band_, byteArray, offset);
35  pack(nauto_, byteArray, offset);
36  pack(nauto_samples_, byteArray, offset);
37  pack(ncross_, byteArray, offset);
38  pack(ncross_samples_, byteArray, offset);
39  pack(sample_type_, byteArray, offset);
40  pack(sample_domain_, byteArray, offset);
41  pack(sample_format_, byteArray, offset);
42  pack(scale_factor_, byteArray, offset);
43  pack(nint_, byteArray, offset);
44  pack(bandwidth_, byteArray, offset);
45  pack(tint_, byteArray, offset);
46  pack(tpsw_, byteArray, offset);
47  pack(nintegrations_, byteArray, offset);
48  }
49 
50  void deserializeVer0( const char * const byteArray,
51  int * const offset,
52  int byteArraySize )
53  {
54  unpack(id_, byteArray, offset, byteArraySize);
55  unpack(band_, byteArray, offset, byteArraySize);
56  unpack(nauto_, byteArray, offset, byteArraySize);
57  unpack(nauto_samples_, byteArray, offset, byteArraySize);
58  unpack(ncross_, byteArray, offset, byteArraySize);
59  unpack(ncross_samples_, byteArray, offset, byteArraySize);
60  unpack(sample_type_, byteArray, offset, byteArraySize);
61  unpack(sample_domain_, byteArray, offset, byteArraySize);
62  unpack(sample_format_, byteArray, offset, byteArraySize);
63  unpack(scale_factor_, byteArray, offset, byteArraySize);
64  unpack(nint_, byteArray, offset, byteArraySize);
65  unpack(bandwidth_, byteArray, offset, byteArraySize);
66  unpack(tint_, byteArray, offset, byteArraySize);
67  unpack(tpsw_, byteArray, offset, byteArraySize);
68  unpack(nintegrations_, byteArray, offset, byteArraySize);
69  }
70 
71  void deserializeVer1( const char * const byteArray,
72  int * const offset,
73  int byteArraySize )
74  {
75  unpack(id_, byteArray, offset, byteArraySize);
76  unpack(band_, byteArray, offset, byteArraySize);
77  unpack(nauto_, byteArray, offset, byteArraySize);
78  unpack(nauto_samples_, byteArray, offset, byteArraySize);
79  unpack(ncross_, byteArray, offset, byteArraySize);
80  unpack(ncross_samples_, byteArray, offset, byteArraySize);
81  unpack(sample_type_, byteArray, offset, byteArraySize);
82  unpack(sample_domain_, byteArray, offset, byteArraySize);
83  unpack(sample_format_, byteArray, offset, byteArraySize);
84  unpack(scale_factor_, byteArray, offset, byteArraySize);
85  unpack(nint_, byteArray, offset, byteArraySize);
86  unpack(bandwidth_, byteArray, offset, byteArraySize);
87  unpack(tint_, byteArray, offset, byteArraySize);
88  unpack(tpsw_, byteArray, offset, byteArraySize);
89  unpack(nintegrations_, byteArray, offset, byteArraySize);
90  }
91 
92  void deserializeSwapVer0( const char * const byteArray,
93  int * const offset,
94  int byteArraySize )
95  {
96  unpackSwap(id_, byteArray, offset, byteArraySize);
97  unpackSwap(band_, byteArray, offset, byteArraySize);
98  unpackSwap(nauto_, byteArray, offset, byteArraySize);
99  unpackSwap(nauto_samples_, byteArray, offset, byteArraySize);
100  unpackSwap(ncross_, byteArray, offset, byteArraySize);
101  unpackSwap(ncross_samples_, byteArray, offset, byteArraySize);
102  unpackSwap(sample_type_, byteArray, offset, byteArraySize);
103  unpackSwap(sample_domain_, byteArray, offset, byteArraySize);
104  unpackSwap(sample_format_, byteArray, offset, byteArraySize);
105  unpackSwap(scale_factor_, byteArray, offset, byteArraySize);
106  unpackSwap(nint_, byteArray, offset, byteArraySize);
107  unpackSwap(bandwidth_, byteArray, offset, byteArraySize);
108  unpackSwap(tint_, byteArray, offset, byteArraySize);
109  unpackSwap(tpsw_, byteArray, offset, byteArraySize);
110  unpackSwap(nintegrations_, byteArray, offset, byteArraySize);
111  }
112 
113  void deserializeSwapVer1( const char * const byteArray,
114  int * const offset,
115  int byteArraySize )
116  {
117  unpackSwap(id_, byteArray, offset, byteArraySize);
118  unpackSwap(band_, byteArray, offset, byteArraySize);
119  unpackSwap(nauto_, byteArray, offset, byteArraySize);
120  unpackSwap(nauto_samples_, byteArray, offset, byteArraySize);
121  unpackSwap(ncross_, byteArray, offset, byteArraySize);
122  unpackSwap(ncross_samples_, byteArray, offset, byteArraySize);
123  unpackSwap(sample_type_, byteArray, offset, byteArraySize);
124  unpackSwap(sample_domain_, byteArray, offset, byteArraySize);
125  unpackSwap(sample_format_, byteArray, offset, byteArraySize);
126  unpackSwap(scale_factor_, byteArray, offset, byteArraySize);
127  unpackSwap(nint_, byteArray, offset, byteArraySize);
128  unpackSwap(bandwidth_, byteArray, offset, byteArraySize);
129  unpackSwap(tint_, byteArray, offset, byteArraySize);
130  unpackSwap(tpsw_, byteArray, offset, byteArraySize);
131  unpackSwap(nintegrations_, byteArray, offset, byteArraySize);
132  }
133 
134  // Equality operator (used when comparing format objects)
135  bool operator== (const CobraDataFormat &rhs)
136  {
137  return ((id_ == rhs.id_) &&
138  (band_ == rhs.band_) &&
139  (nauto_ == rhs.nauto_) &&
140  (nauto_samples_ == rhs.nauto_samples_) &&
141  (ncross_ == rhs.ncross_) &&
142  (ncross_samples_ == rhs.ncross_samples_) &&
143  (sample_type_ == rhs.sample_type_) &&
144  (sample_domain_ == rhs.sample_domain_) &&
145  (sample_format_ == rhs.sample_format_) &&
146  (scale_factor_ == rhs.scale_factor_) &&
147  (nint_ == rhs.nint_) &&
148  (bandwidth_ == rhs.bandwidth_) &&
149  (tint_ == rhs.tint_) &&
150  (tpsw_ == rhs.tpsw_) &&
151  (nintegrations_ == rhs.nintegrations_));
152  }
153  bool operator!= (const CobraDataFormat &rhs)
154  {
155  return !(*this == rhs);
156  }
157 
158  // Member accessors
159  //
160  // Routines used by data readers, eg. after the format
161  // has been reconstructed via a call to deserialize.
162  //
163  int getId()
164  {return id_;}
165  int getBand()
166  {return band_;}
167  int getNauto()
168  {return nauto_;}
169  int getNautoSamples()
170  {return nauto_samples_;}
171  int getNcross()
172  {return ncross_;}
173  int getNcrossSamples()
174  {return ncross_samples_;}
175  int getSampleType()
176  {return sample_type_;}
177  int getSampleDomain()
178  {return sample_domain_;}
179  int getSampleFormat()
180  {return sample_format_;}
181  int getScaleFactor()
182  {return scale_factor_;}
183  int getNint()
184  {return nint_;}
185  float getBandwidth()
186  {return bandwidth_;}
187  float getTint()
188  {return tint_;}
189  float getTpsw()
190  {return tpsw_;}
191  int getNintegrations()
192  {return nintegrations_;}
193 
194  // Routines used by data writers, eg. before the format
195  // has been deconstructed via a call to mySerialize.
196  //
197  void setId(int id)
198  {id_ = id;}
199  void setBand(int band)
200  {band_ = band;}
201  void setNauto(int nauto)
202  {nauto_ = nauto;}
203  void setNautoSamples(int nauto_samples)
204  {nauto_samples_ = nauto_samples;}
205  void setNcross(int ncross)
206  {ncross_ = ncross;}
207  void setNcrossSamples(int ncross_samples)
208  {ncross_samples_ = ncross_samples;}
209  void setSampleType(int sample_type)
210  {sample_type_ = sample_type;}
211  void setSampleDomain(int sample_domain)
212  {sample_domain_ = sample_domain;}
213  void setSampleFormat(int sample_format)
214  {sample_format_ = sample_format;}
215  void setScaleFactor(int scale_factor)
216  {scale_factor_ = scale_factor;}
217  void setNint(int nint)
218  {nint_ = nint;}
219  void setBandwidth(float bandwidth)
220  {bandwidth_ = bandwidth;}
221  void setTint(float tint)
222  {tint_ = tint;}
223  void setTpsw(float tpsw)
224  {tpsw_ = tpsw;}
225  void setNintegrations(int nintegrations)
226  {nintegrations_ = nintegrations;}
227  private:
228  int id_;
229  int band_;
230  int nauto_;
231  int nauto_samples_;
232  int ncross_;
233  int ncross_samples_;
234  int sample_type_;
235  int sample_domain_;
236  int sample_format_;
237  int scale_factor_;
238  int nint_;
239  float bandwidth_;
240  float tint_;
241  float tpsw_;
242  int nintegrations_;
243  };
244  };
245  };
246 };
247 
248 #endif // COBRADATAFORMAT_H
249 
250 
carma::util::Serializable
Abstract Class used to allow object to serialize themselves into a byte array.
Definition: Serializable.h:32