3 * Copyright 2006 Free Software Foundation, Inc.
5 * This file is part of GNU Radio
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)
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.
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.
23 #ifndef INCLUDED_PMT_UNV_INT_H
24 #define INCLUDED_PMT_UNV_INT_H
26 ////////////////////////////////////////////////////////////////////////////
28 ////////////////////////////////////////////////////////////////////////////
30 class pmt_u8vector : public pmt_uniform_vector
32 std::vector< uint8_t > d_v;
35 pmt_u8vector(size_t k, uint8_t fill);
36 pmt_u8vector(size_t k, const uint8_t *data);
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);
49 ////////////////////////////////////////////////////////////////////////////
51 ////////////////////////////////////////////////////////////////////////////
53 class pmt_s8vector : public pmt_uniform_vector
55 std::vector< int8_t > d_v;
58 pmt_s8vector(size_t k, int8_t fill);
59 pmt_s8vector(size_t k, const int8_t *data);
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);
72 ////////////////////////////////////////////////////////////////////////////
74 ////////////////////////////////////////////////////////////////////////////
76 class pmt_u16vector : public pmt_uniform_vector
78 std::vector< uint16_t > d_v;
81 pmt_u16vector(size_t k, uint16_t fill);
82 pmt_u16vector(size_t k, const uint16_t *data);
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);
95 ////////////////////////////////////////////////////////////////////////////
97 ////////////////////////////////////////////////////////////////////////////
99 class pmt_s16vector : public pmt_uniform_vector
101 std::vector< int16_t > d_v;
104 pmt_s16vector(size_t k, int16_t fill);
105 pmt_s16vector(size_t k, const int16_t *data);
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);
118 ////////////////////////////////////////////////////////////////////////////
120 ////////////////////////////////////////////////////////////////////////////
122 class pmt_u32vector : public pmt_uniform_vector
124 std::vector< uint32_t > d_v;
127 pmt_u32vector(size_t k, uint32_t fill);
128 pmt_u32vector(size_t k, const uint32_t *data);
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);
141 ////////////////////////////////////////////////////////////////////////////
143 ////////////////////////////////////////////////////////////////////////////
145 class pmt_s32vector : public pmt_uniform_vector
147 std::vector< int32_t > d_v;
150 pmt_s32vector(size_t k, int32_t fill);
151 pmt_s32vector(size_t k, const int32_t *data);
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);
164 ////////////////////////////////////////////////////////////////////////////
166 ////////////////////////////////////////////////////////////////////////////
168 class pmt_u64vector : public pmt_uniform_vector
170 std::vector< uint64_t > d_v;
173 pmt_u64vector(size_t k, uint64_t fill);
174 pmt_u64vector(size_t k, const uint64_t *data);
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);
187 ////////////////////////////////////////////////////////////////////////////
189 ////////////////////////////////////////////////////////////////////////////
191 class pmt_s64vector : public pmt_uniform_vector
193 std::vector< int64_t > d_v;
196 pmt_s64vector(size_t k, int64_t fill);
197 pmt_s64vector(size_t k, const int64_t *data);
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);
210 ////////////////////////////////////////////////////////////////////////////
212 ////////////////////////////////////////////////////////////////////////////
214 class pmt_f32vector : public pmt_uniform_vector
216 std::vector< float > d_v;
219 pmt_f32vector(size_t k, float fill);
220 pmt_f32vector(size_t k, const float *data);
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);
233 ////////////////////////////////////////////////////////////////////////////
235 ////////////////////////////////////////////////////////////////////////////
237 class pmt_f64vector : public pmt_uniform_vector
239 std::vector< double > d_v;
242 pmt_f64vector(size_t k, double fill);
243 pmt_f64vector(size_t k, const double *data);
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);
256 ////////////////////////////////////////////////////////////////////////////
258 ////////////////////////////////////////////////////////////////////////////
260 class pmt_c32vector : public pmt_uniform_vector
262 std::vector< std::complex<float> > d_v;
265 pmt_c32vector(size_t k, std::complex<float> fill);
266 pmt_c32vector(size_t k, const std::complex<float> *data);
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);
279 ////////////////////////////////////////////////////////////////////////////
281 ////////////////////////////////////////////////////////////////////////////
283 class pmt_c64vector : public pmt_uniform_vector
285 std::vector< std::complex<double> > d_v;
288 pmt_c64vector(size_t k, std::complex<double> fill);
289 pmt_c64vector(size_t k, const std::complex<double> *data);
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);