GNU Radio Manual and C++ API Reference  3.7.8.1
The Free & Open Software Radio Ecosystem
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
pmt_unv_int.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2006,2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GNU Radio
6  *
7  * GNU Radio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3, or (at your option)
10  * any later version.
11  *
12  * GNU Radio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with GNU Radio; see the file COPYING. If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street,
20  * Boston, MA 02110-1301, USA.
21  */
22 
23 #ifndef INCLUDED_PMT_UNV_INT_H
24 #define INCLUDED_PMT_UNV_INT_H
25 
26 ////////////////////////////////////////////////////////////////////////////
27 // pmt_u8vector
28 ////////////////////////////////////////////////////////////////////////////
29 
30 class pmt_u8vector : public pmt_uniform_vector
31 {
32  std::vector< uint8_t > d_v;
33 
34 public:
35  pmt_u8vector(size_t k, uint8_t fill);
36  pmt_u8vector(size_t k, const uint8_t *data);
37  // ~pmt_u8vector();
38 
39  bool is_u8vector() const { return true; }
40  size_t length() const { return d_v.size(); }
41  size_t itemsize() const { return sizeof(uint8_t); }
42  uint8_t ref(size_t k) const;
43  void set(size_t k, uint8_t x);
44  const uint8_t *elements(size_t &len);
45  uint8_t *writable_elements(size_t &len);
46  const void *uniform_elements(size_t &len);
47  void *uniform_writable_elements(size_t &len);
48  virtual const std::string string_ref(size_t k) const;
49 };
50 
51 ////////////////////////////////////////////////////////////////////////////
52 // pmt_s8vector
53 ////////////////////////////////////////////////////////////////////////////
54 
55 class pmt_s8vector : public pmt_uniform_vector
56 {
57  std::vector< int8_t > d_v;
58 
59 public:
60  pmt_s8vector(size_t k, int8_t fill);
61  pmt_s8vector(size_t k, const int8_t *data);
62  // ~pmt_s8vector();
63 
64  bool is_s8vector() const { return true; }
65  size_t length() const { return d_v.size(); }
66  size_t itemsize() const { return sizeof(int8_t); }
67  int8_t ref(size_t k) const;
68  void set(size_t k, int8_t x);
69  const int8_t *elements(size_t &len);
70  int8_t *writable_elements(size_t &len);
71  const void *uniform_elements(size_t &len);
72  void *uniform_writable_elements(size_t &len);
73  virtual const std::string string_ref(size_t k) const;
74 };
75 
76 ////////////////////////////////////////////////////////////////////////////
77 // pmt_u16vector
78 ////////////////////////////////////////////////////////////////////////////
79 
80 class pmt_u16vector : public pmt_uniform_vector
81 {
82  std::vector< uint16_t > d_v;
83 
84 public:
85  pmt_u16vector(size_t k, uint16_t fill);
86  pmt_u16vector(size_t k, const uint16_t *data);
87  // ~pmt_u16vector();
88 
89  bool is_u16vector() const { return true; }
90  size_t length() const { return d_v.size(); }
91  size_t itemsize() const { return sizeof(uint16_t); }
92  uint16_t ref(size_t k) const;
93  void set(size_t k, uint16_t x);
94  const uint16_t *elements(size_t &len);
95  uint16_t *writable_elements(size_t &len);
96  const void *uniform_elements(size_t &len);
97  void *uniform_writable_elements(size_t &len);
98  virtual const std::string string_ref(size_t k) const;
99 };
100 
101 ////////////////////////////////////////////////////////////////////////////
102 // pmt_s16vector
103 ////////////////////////////////////////////////////////////////////////////
104 
105 class pmt_s16vector : public pmt_uniform_vector
106 {
107  std::vector< int16_t > d_v;
108 
109 public:
110  pmt_s16vector(size_t k, int16_t fill);
111  pmt_s16vector(size_t k, const int16_t *data);
112  // ~pmt_s16vector();
113 
114  bool is_s16vector() const { return true; }
115  size_t length() const { return d_v.size(); }
116  size_t itemsize() const { return sizeof(int16_t); }
117  int16_t ref(size_t k) const;
118  void set(size_t k, int16_t x);
119  const int16_t *elements(size_t &len);
120  int16_t *writable_elements(size_t &len);
121  const void *uniform_elements(size_t &len);
122  void *uniform_writable_elements(size_t &len);
123  virtual const std::string string_ref(size_t k) const;
124 };
125 
126 ////////////////////////////////////////////////////////////////////////////
127 // pmt_u32vector
128 ////////////////////////////////////////////////////////////////////////////
129 
130 class pmt_u32vector : public pmt_uniform_vector
131 {
132  std::vector< uint32_t > d_v;
133 
134 public:
135  pmt_u32vector(size_t k, uint32_t fill);
136  pmt_u32vector(size_t k, const uint32_t *data);
137  // ~pmt_u32vector();
138 
139  bool is_u32vector() const { return true; }
140  size_t length() const { return d_v.size(); }
141  size_t itemsize() const { return sizeof(uint32_t); }
142  uint32_t ref(size_t k) const;
143  void set(size_t k, uint32_t x);
144  const uint32_t *elements(size_t &len);
145  uint32_t *writable_elements(size_t &len);
146  const void *uniform_elements(size_t &len);
147  void *uniform_writable_elements(size_t &len);
148  virtual const std::string string_ref(size_t k) const;
149 };
150 
151 ////////////////////////////////////////////////////////////////////////////
152 // pmt_s32vector
153 ////////////////////////////////////////////////////////////////////////////
154 
155 class pmt_s32vector : public pmt_uniform_vector
156 {
157  std::vector< int32_t > d_v;
158 
159 public:
160  pmt_s32vector(size_t k, int32_t fill);
161  pmt_s32vector(size_t k, const int32_t *data);
162  // ~pmt_s32vector();
163 
164  bool is_s32vector() const { return true; }
165  size_t length() const { return d_v.size(); }
166  size_t itemsize() const { return sizeof(int32_t); }
167  int32_t ref(size_t k) const;
168  void set(size_t k, int32_t x);
169  const int32_t *elements(size_t &len);
170  int32_t *writable_elements(size_t &len);
171  const void *uniform_elements(size_t &len);
172  void *uniform_writable_elements(size_t &len);
173  virtual const std::string string_ref(size_t k) const;
174 };
175 
176 ////////////////////////////////////////////////////////////////////////////
177 // pmt_u64vector
178 ////////////////////////////////////////////////////////////////////////////
179 
180 class pmt_u64vector : public pmt_uniform_vector
181 {
182  std::vector< uint64_t > d_v;
183 
184 public:
185  pmt_u64vector(size_t k, uint64_t fill);
186  pmt_u64vector(size_t k, const uint64_t *data);
187  // ~pmt_u64vector();
188 
189  bool is_u64vector() const { return true; }
190  size_t length() const { return d_v.size(); }
191  size_t itemsize() const { return sizeof(uint64_t); }
192  uint64_t ref(size_t k) const;
193  void set(size_t k, uint64_t x);
194  const uint64_t *elements(size_t &len);
195  uint64_t *writable_elements(size_t &len);
196  const void *uniform_elements(size_t &len);
197  void *uniform_writable_elements(size_t &len);
198  virtual const std::string string_ref(size_t k) const;
199 };
200 
201 ////////////////////////////////////////////////////////////////////////////
202 // pmt_s64vector
203 ////////////////////////////////////////////////////////////////////////////
204 
205 class pmt_s64vector : public pmt_uniform_vector
206 {
207  std::vector< int64_t > d_v;
208 
209 public:
210  pmt_s64vector(size_t k, int64_t fill);
211  pmt_s64vector(size_t k, const int64_t *data);
212  // ~pmt_s64vector();
213 
214  bool is_s64vector() const { return true; }
215  size_t length() const { return d_v.size(); }
216  size_t itemsize() const { return sizeof(int64_t); }
217  int64_t ref(size_t k) const;
218  void set(size_t k, int64_t x);
219  const int64_t *elements(size_t &len);
220  int64_t *writable_elements(size_t &len);
221  const void *uniform_elements(size_t &len);
222  void *uniform_writable_elements(size_t &len);
223  virtual const std::string string_ref(size_t k) const;
224 };
225 
226 ////////////////////////////////////////////////////////////////////////////
227 // pmt_f32vector
228 ////////////////////////////////////////////////////////////////////////////
229 
230 class pmt_f32vector : public pmt_uniform_vector
231 {
232  std::vector< float > d_v;
233 
234 public:
235  pmt_f32vector(size_t k, float fill);
236  pmt_f32vector(size_t k, const float *data);
237  // ~pmt_f32vector();
238 
239  bool is_f32vector() const { return true; }
240  size_t length() const { return d_v.size(); }
241  size_t itemsize() const { return sizeof(float); }
242  float ref(size_t k) const;
243  void set(size_t k, float x);
244  const float *elements(size_t &len);
245  float *writable_elements(size_t &len);
246  const void *uniform_elements(size_t &len);
247  void *uniform_writable_elements(size_t &len);
248  virtual const std::string string_ref(size_t k) const;
249 };
250 
251 ////////////////////////////////////////////////////////////////////////////
252 // pmt_f64vector
253 ////////////////////////////////////////////////////////////////////////////
254 
255 class pmt_f64vector : public pmt_uniform_vector
256 {
257  std::vector< double > d_v;
258 
259 public:
260  pmt_f64vector(size_t k, double fill);
261  pmt_f64vector(size_t k, const double *data);
262  // ~pmt_f64vector();
263 
264  bool is_f64vector() const { return true; }
265  size_t length() const { return d_v.size(); }
266  size_t itemsize() const { return sizeof(double); }
267  double ref(size_t k) const;
268  void set(size_t k, double x);
269  const double *elements(size_t &len);
270  double *writable_elements(size_t &len);
271  const void *uniform_elements(size_t &len);
272  void *uniform_writable_elements(size_t &len);
273  virtual const std::string string_ref(size_t k) const;
274 };
275 
276 ////////////////////////////////////////////////////////////////////////////
277 // pmt_c32vector
278 ////////////////////////////////////////////////////////////////////////////
279 
280 class pmt_c32vector : public pmt_uniform_vector
281 {
282  std::vector< std::complex<float> > d_v;
283 
284 public:
285  pmt_c32vector(size_t k, std::complex<float> fill);
286  pmt_c32vector(size_t k, const std::complex<float> *data);
287  // ~pmt_c32vector();
288 
289  bool is_c32vector() const { return true; }
290  size_t length() const { return d_v.size(); }
291  size_t itemsize() const { return sizeof(std::complex<float>); }
292  std::complex<float> ref(size_t k) const;
293  void set(size_t k, std::complex<float> x);
294  const std::complex<float> *elements(size_t &len);
295  std::complex<float> *writable_elements(size_t &len);
296  const void *uniform_elements(size_t &len);
297  void *uniform_writable_elements(size_t &len);
298  virtual const std::string string_ref(size_t k) const;
299 };
300 
301 ////////////////////////////////////////////////////////////////////////////
302 // pmt_c64vector
303 ////////////////////////////////////////////////////////////////////////////
304 
305 class pmt_c64vector : public pmt_uniform_vector
306 {
307  std::vector< std::complex<double> > d_v;
308 
309 public:
310  pmt_c64vector(size_t k, std::complex<double> fill);
311  pmt_c64vector(size_t k, const std::complex<double> *data);
312  // ~pmt_c64vector();
313 
314  bool is_c64vector() const { return true; }
315  size_t length() const { return d_v.size(); }
316  size_t itemsize() const { return sizeof(std::complex<double>); }
317  std::complex<double> ref(size_t k) const;
318  void set(size_t k, std::complex<double> x);
319  const std::complex<double> *elements(size_t &len);
320  std::complex<double> *writable_elements(size_t &len);
321  const void *uniform_elements(size_t &len);
322  void *uniform_writable_elements(size_t &len);
323  virtual const std::string string_ref(size_t k) const;
324 };
325 
326 #endif
int8_t * writable_elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:265
int16_t ref(size_t k) const
int64_t ref(size_t k) const
pmt_s16vector(size_t k, int16_t fill)
pmt_u8vector(size_t k, uint8_t fill)
int16_t * writable_elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:140
void set(size_t k, uint16_t x)
const std::complex< float > * elements(size_t &len)
bool is_s8vector() const
Definition: pmt_unv_int.h:64
void * uniform_writable_elements(size_t &len)
void set(size_t k, float x)
size_t length() const
Definition: pmt_unv_int.h:215
void set(size_t k, int8_t x)
const void * uniform_elements(size_t &len)
void set(size_t k, uint64_t x)
int32_t ref(size_t k) const
std::complex< float > ref(size_t k) const
Definition: pmt_unv_int.h:155
Definition: pmt_unv_int.h:130
bool is_u8vector() const
Definition: pmt_unv_int.h:39
double * writable_elements(size_t &len)
size_t itemsize() const
Definition: pmt_unv_int.h:291
size_t length() const
Definition: pmt_unv_int.h:240
size_t itemsize() const
Definition: pmt_unv_int.h:216
size_t length() const
Definition: pmt_unv_int.h:165
uint32_t ref(size_t k) const
const double * elements(size_t &len)
void set(size_t k, int64_t x)
Definition: pmt_unv_int.h:280
virtual const std::string string_ref(size_t k) const
const void * uniform_elements(size_t &len)
void * uniform_writable_elements(size_t &len)
std::complex< float > * writable_elements(size_t &len)
Definition: pmt_unv_int.h:230
const uint64_t * elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:290
void * uniform_writable_elements(size_t &len)
pmt_s8vector(size_t k, int8_t fill)
bool is_f64vector() const
Definition: pmt_unv_int.h:264
std::complex< double > * writable_elements(size_t &len)
bool is_c32vector() const
Definition: pmt_unv_int.h:289
const uint8_t * elements(size_t &len)
size_t itemsize() const
Definition: pmt_unv_int.h:316
void set(size_t k, uint32_t x)
virtual const std::string string_ref(size_t k) const
int8_t ref(size_t k) const
pmt_s32vector(size_t k, int32_t fill)
std::complex< double > ref(size_t k) const
const void * uniform_elements(size_t &len)
bool is_s16vector() const
Definition: pmt_unv_int.h:114
void * uniform_writable_elements(size_t &len)
bool is_u16vector() const
Definition: pmt_unv_int.h:89
Definition: pmt_unv_int.h:105
size_t itemsize() const
Definition: pmt_unv_int.h:166
Definition: pmt_unv_int.h:80
virtual const std::string string_ref(size_t k) const
void * uniform_writable_elements(size_t &len)
virtual const std::string string_ref(size_t k) const
size_t itemsize() const
Definition: pmt_unv_int.h:116
size_t length() const
Definition: pmt_unv_int.h:315
int32_t * writable_elements(size_t &len)
const int8_t * elements(size_t &len)
pmt_u64vector(size_t k, uint64_t fill)
virtual const std::string string_ref(size_t k) const
pmt_f32vector(size_t k, float fill)
size_t length() const
Definition: pmt_unv_int.h:40
const uint16_t * elements(size_t &len)
const void * uniform_elements(size_t &len)
virtual const std::string string_ref(size_t k) const
pmt_u32vector(size_t k, uint32_t fill)
void set(size_t k, std::complex< float > x)
uint8_t * writable_elements(size_t &len)
float * writable_elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:115
size_t itemsize() const
Definition: pmt_unv_int.h:241
void set(size_t k, int16_t x)
size_t itemsize() const
Definition: pmt_unv_int.h:266
bool is_s32vector() const
Definition: pmt_unv_int.h:164
const void * uniform_elements(size_t &len)
const void * uniform_elements(size_t &len)
Definition: pmt_unv_int.h:30
virtual const std::string string_ref(size_t k) const
virtual const std::string string_ref(size_t k) const
void set(size_t k, int32_t x)
void * uniform_writable_elements(size_t &len)
void set(size_t k, uint8_t x)
bool is_c64vector() const
Definition: pmt_unv_int.h:314
void * uniform_writable_elements(size_t &len)
void * uniform_writable_elements(size_t &len)
void * uniform_writable_elements(size_t &len)
pmt_c64vector(size_t k, std::complex< double > fill)
pmt_c32vector(size_t k, std::complex< float > fill)
uint64_t ref(size_t k) const
int64_t * writable_elements(size_t &len)
pmt_f64vector(size_t k, double fill)
size_t itemsize() const
Definition: pmt_unv_int.h:191
virtual const std::string string_ref(size_t k) const
const void * uniform_elements(size_t &len)
const void * uniform_elements(size_t &len)
const int16_t * elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:90
const uint32_t * elements(size_t &len)
uint64_t * writable_elements(size_t &len)
const void * uniform_elements(size_t &len)
size_t length() const
Definition: pmt_unv_int.h:65
const std::complex< double > * elements(size_t &len)
float ref(size_t k) const
const void * uniform_elements(size_t &len)
bool is_u32vector() const
Definition: pmt_unv_int.h:139
Definition: pmt_unv_int.h:205
virtual const std::string string_ref(size_t k) const
uint32_t * writable_elements(size_t &len)
const float * elements(size_t &len)
Definition: pmt_unv_int.h:180
Definition: pmt_unv_int.h:55
bool is_f32vector() const
Definition: pmt_unv_int.h:239
void * uniform_writable_elements(size_t &len)
bool is_u64vector() const
Definition: pmt_unv_int.h:189
uint16_t * writable_elements(size_t &len)
void * uniform_writable_elements(size_t &len)
uint16_t ref(size_t k) const
virtual const std::string string_ref(size_t k) const
size_t itemsize() const
Definition: pmt_unv_int.h:141
size_t itemsize() const
Definition: pmt_unv_int.h:91
Definition: pmt_unv_int.h:305
void * uniform_writable_elements(size_t &len)
Definition: pmt_unv_int.h:255
size_t length() const
Definition: pmt_unv_int.h:190
double ref(size_t k) const
void set(size_t k, std::complex< double > x)
const void * uniform_elements(size_t &len)
const void * uniform_elements(size_t &len)
const int32_t * elements(size_t &len)
const int64_t * elements(size_t &len)
bool is_s64vector() const
Definition: pmt_unv_int.h:214
pmt_s64vector(size_t k, int64_t fill)
virtual const std::string string_ref(size_t k) const
void set(size_t k, double x)
size_t itemsize() const
Definition: pmt_unv_int.h:41
pmt_u16vector(size_t k, uint16_t fill)
uint8_t ref(size_t k) const
size_t itemsize() const
Definition: pmt_unv_int.h:66