GNU Radio C++ API
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  uint8_t ref(size_t k) const;
42  void set(size_t k, uint8_t x);
43  const uint8_t *elements(size_t &len);
44  uint8_t *writable_elements(size_t &len);
45  const void *uniform_elements(size_t &len);
46  void *uniform_writable_elements(size_t &len);
47 };
48 
49 ////////////////////////////////////////////////////////////////////////////
50 // pmt_s8vector
51 ////////////////////////////////////////////////////////////////////////////
52 
53 class pmt_s8vector : public pmt_uniform_vector
54 {
55  std::vector< int8_t > d_v;
56 
57 public:
58  pmt_s8vector(size_t k, int8_t fill);
59  pmt_s8vector(size_t k, const int8_t *data);
60  // ~pmt_s8vector();
61 
62  bool is_s8vector() const { return true; }
63  size_t length() const { return d_v.size(); }
64  int8_t ref(size_t k) const;
65  void set(size_t k, int8_t x);
66  const int8_t *elements(size_t &len);
67  int8_t *writable_elements(size_t &len);
68  const void *uniform_elements(size_t &len);
69  void *uniform_writable_elements(size_t &len);
70 };
71 
72 ////////////////////////////////////////////////////////////////////////////
73 // pmt_u16vector
74 ////////////////////////////////////////////////////////////////////////////
75 
76 class pmt_u16vector : public pmt_uniform_vector
77 {
78  std::vector< uint16_t > d_v;
79 
80 public:
81  pmt_u16vector(size_t k, uint16_t fill);
82  pmt_u16vector(size_t k, const uint16_t *data);
83  // ~pmt_u16vector();
84 
85  bool is_u16vector() const { return true; }
86  size_t length() const { return d_v.size(); }
87  uint16_t ref(size_t k) const;
88  void set(size_t k, uint16_t x);
89  const uint16_t *elements(size_t &len);
90  uint16_t *writable_elements(size_t &len);
91  const void *uniform_elements(size_t &len);
92  void *uniform_writable_elements(size_t &len);
93 };
94 
95 ////////////////////////////////////////////////////////////////////////////
96 // pmt_s16vector
97 ////////////////////////////////////////////////////////////////////////////
98 
99 class pmt_s16vector : public pmt_uniform_vector
100 {
101  std::vector< int16_t > d_v;
102 
103 public:
104  pmt_s16vector(size_t k, int16_t fill);
105  pmt_s16vector(size_t k, const int16_t *data);
106  // ~pmt_s16vector();
107 
108  bool is_s16vector() const { return true; }
109  size_t length() const { return d_v.size(); }
110  int16_t ref(size_t k) const;
111  void set(size_t k, int16_t x);
112  const int16_t *elements(size_t &len);
113  int16_t *writable_elements(size_t &len);
114  const void *uniform_elements(size_t &len);
115  void *uniform_writable_elements(size_t &len);
116 };
117 
118 ////////////////////////////////////////////////////////////////////////////
119 // pmt_u32vector
120 ////////////////////////////////////////////////////////////////////////////
121 
122 class pmt_u32vector : public pmt_uniform_vector
123 {
124  std::vector< uint32_t > d_v;
125 
126 public:
127  pmt_u32vector(size_t k, uint32_t fill);
128  pmt_u32vector(size_t k, const uint32_t *data);
129  // ~pmt_u32vector();
130 
131  bool is_u32vector() const { return true; }
132  size_t length() const { return d_v.size(); }
133  uint32_t ref(size_t k) const;
134  void set(size_t k, uint32_t x);
135  const uint32_t *elements(size_t &len);
136  uint32_t *writable_elements(size_t &len);
137  const void *uniform_elements(size_t &len);
138  void *uniform_writable_elements(size_t &len);
139 };
140 
141 ////////////////////////////////////////////////////////////////////////////
142 // pmt_s32vector
143 ////////////////////////////////////////////////////////////////////////////
144 
145 class pmt_s32vector : public pmt_uniform_vector
146 {
147  std::vector< int32_t > d_v;
148 
149 public:
150  pmt_s32vector(size_t k, int32_t fill);
151  pmt_s32vector(size_t k, const int32_t *data);
152  // ~pmt_s32vector();
153 
154  bool is_s32vector() const { return true; }
155  size_t length() const { return d_v.size(); }
156  int32_t ref(size_t k) const;
157  void set(size_t k, int32_t x);
158  const int32_t *elements(size_t &len);
159  int32_t *writable_elements(size_t &len);
160  const void *uniform_elements(size_t &len);
161  void *uniform_writable_elements(size_t &len);
162 };
163 
164 ////////////////////////////////////////////////////////////////////////////
165 // pmt_u64vector
166 ////////////////////////////////////////////////////////////////////////////
167 
168 class pmt_u64vector : public pmt_uniform_vector
169 {
170  std::vector< uint64_t > d_v;
171 
172 public:
173  pmt_u64vector(size_t k, uint64_t fill);
174  pmt_u64vector(size_t k, const uint64_t *data);
175  // ~pmt_u64vector();
176 
177  bool is_u64vector() const { return true; }
178  size_t length() const { return d_v.size(); }
179  uint64_t ref(size_t k) const;
180  void set(size_t k, uint64_t x);
181  const uint64_t *elements(size_t &len);
182  uint64_t *writable_elements(size_t &len);
183  const void *uniform_elements(size_t &len);
184  void *uniform_writable_elements(size_t &len);
185 };
186 
187 ////////////////////////////////////////////////////////////////////////////
188 // pmt_s64vector
189 ////////////////////////////////////////////////////////////////////////////
190 
191 class pmt_s64vector : public pmt_uniform_vector
192 {
193  std::vector< int64_t > d_v;
194 
195 public:
196  pmt_s64vector(size_t k, int64_t fill);
197  pmt_s64vector(size_t k, const int64_t *data);
198  // ~pmt_s64vector();
199 
200  bool is_s64vector() const { return true; }
201  size_t length() const { return d_v.size(); }
202  int64_t ref(size_t k) const;
203  void set(size_t k, int64_t x);
204  const int64_t *elements(size_t &len);
205  int64_t *writable_elements(size_t &len);
206  const void *uniform_elements(size_t &len);
207  void *uniform_writable_elements(size_t &len);
208 };
209 
210 ////////////////////////////////////////////////////////////////////////////
211 // pmt_f32vector
212 ////////////////////////////////////////////////////////////////////////////
213 
214 class pmt_f32vector : public pmt_uniform_vector
215 {
216  std::vector< float > d_v;
217 
218 public:
219  pmt_f32vector(size_t k, float fill);
220  pmt_f32vector(size_t k, const float *data);
221  // ~pmt_f32vector();
222 
223  bool is_f32vector() const { return true; }
224  size_t length() const { return d_v.size(); }
225  float ref(size_t k) const;
226  void set(size_t k, float x);
227  const float *elements(size_t &len);
228  float *writable_elements(size_t &len);
229  const void *uniform_elements(size_t &len);
230  void *uniform_writable_elements(size_t &len);
231 };
232 
233 ////////////////////////////////////////////////////////////////////////////
234 // pmt_f64vector
235 ////////////////////////////////////////////////////////////////////////////
236 
237 class pmt_f64vector : public pmt_uniform_vector
238 {
239  std::vector< double > d_v;
240 
241 public:
242  pmt_f64vector(size_t k, double fill);
243  pmt_f64vector(size_t k, const double *data);
244  // ~pmt_f64vector();
245 
246  bool is_f64vector() const { return true; }
247  size_t length() const { return d_v.size(); }
248  double ref(size_t k) const;
249  void set(size_t k, double x);
250  const double *elements(size_t &len);
251  double *writable_elements(size_t &len);
252  const void *uniform_elements(size_t &len);
253  void *uniform_writable_elements(size_t &len);
254 };
255 
256 ////////////////////////////////////////////////////////////////////////////
257 // pmt_c32vector
258 ////////////////////////////////////////////////////////////////////////////
259 
260 class pmt_c32vector : public pmt_uniform_vector
261 {
262  std::vector< std::complex<float> > d_v;
263 
264 public:
265  pmt_c32vector(size_t k, std::complex<float> fill);
266  pmt_c32vector(size_t k, const std::complex<float> *data);
267  // ~pmt_c32vector();
268 
269  bool is_c32vector() const { return true; }
270  size_t length() const { return d_v.size(); }
271  std::complex<float> ref(size_t k) const;
272  void set(size_t k, std::complex<float> x);
273  const std::complex<float> *elements(size_t &len);
274  std::complex<float> *writable_elements(size_t &len);
275  const void *uniform_elements(size_t &len);
276  void *uniform_writable_elements(size_t &len);
277 };
278 
279 ////////////////////////////////////////////////////////////////////////////
280 // pmt_c64vector
281 ////////////////////////////////////////////////////////////////////////////
282 
283 class pmt_c64vector : public pmt_uniform_vector
284 {
285  std::vector< std::complex<double> > d_v;
286 
287 public:
288  pmt_c64vector(size_t k, std::complex<double> fill);
289  pmt_c64vector(size_t k, const std::complex<double> *data);
290  // ~pmt_c64vector();
291 
292  bool is_c64vector() const { return true; }
293  size_t length() const { return d_v.size(); }
294  std::complex<double> ref(size_t k) const;
295  void set(size_t k, std::complex<double> x);
296  const std::complex<double> *elements(size_t &len);
297  std::complex<double> *writable_elements(size_t &len);
298  const void *uniform_elements(size_t &len);
299  void *uniform_writable_elements(size_t &len);
300 };
301 
302 #endif