git.gag.com Git - debian/gnuradio/blob - pmt/src/lib/pmt_unv_int.h

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2006 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