git.gag.com Git - debian/gnuradio/blob - pmt/src/lib/pmt_unv.cc

   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 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26 #include <vector>
  27 #include <pmt.h>
  28 #include "pmt_int.h"
  29
  30 ////////////////////////////////////////////////////////////////////////////
  31 //                           pmt_u8vector
  32 ////////////////////////////////////////////////////////////////////////////
  33
  34 static pmt_u8vector *
  35 _u8vector(pmt_t x)
  36 {
  37   return dynamic_cast<pmt_u8vector*>(x.get());
  38 }
  39
  40
  41 pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill)
  42   : d_v(k)
  43 {
  44   for (size_t i = 0; i < k; i++)
  45     d_v[i] = fill;
  46 }
  47
  48 pmt_u8vector::pmt_u8vector(size_t k, const uint8_t *data)
  49   : d_v(k)
  50 {
  51   for (size_t i = 0; i < k; i++)
  52     d_v[i] = data[i];
  53 }
  54
  55 uint8_t
  56 pmt_u8vector::ref(size_t k) const
  57 {
  58   if (k >= length())
  59     throw pmt_out_of_range("pmt_u8vector_ref", pmt_from_long(k));
  60   return d_v[k];
  61 }
  62
  63 void
  64 pmt_u8vector::set(size_t k, uint8_t x)
  65 {
  66   if (k >= length())
  67     throw pmt_out_of_range("pmt_u8vector_set", pmt_from_long(k));
  68   d_v[k] = x;
  69 }
  70
  71 const uint8_t *
  72 pmt_u8vector::elements(size_t &len)
  73 {
  74   len = length();
  75   return &d_v[0];
  76 }
  77
  78 uint8_t *
  79 pmt_u8vector::writable_elements(size_t &len)
  80 {
  81   len = length();
  82   return &d_v[0];
  83 }
  84
  85 const void*
  86 pmt_u8vector::uniform_elements(size_t &len)
  87 {
  88   len = length() * sizeof(uint8_t);
  89   return &d_v[0];
  90 }
  91
  92 void*
  93 pmt_u8vector::uniform_writable_elements(size_t &len)
  94 {
  95   len = length() * sizeof(uint8_t);
  96   return &d_v[0];
  97 }
  98
  99 bool
 100 pmt_is_u8vector(pmt_t obj)
 101 {
 102   return obj->is_u8vector();
 103 }
 104
 105 pmt_t
 106 pmt_make_u8vector(size_t k, uint8_t fill)
 107 {
 108   return pmt_t(new pmt_u8vector(k, fill));
 109 }
 110
 111 pmt_t
 112 pmt_init_u8vector(size_t k, const uint8_t *data)
 113 {
 114   return pmt_t(new pmt_u8vector(k, data));
 115 }
 116
 117 uint8_t
 118 pmt_u8vector_ref(pmt_t vector, size_t k)
 119 {
 120   if (!vector->is_u8vector())
 121     throw pmt_wrong_type("pmt_u8vector_ref", vector);
 122   return _u8vector(vector)->ref(k);
 123 }
 124
 125 void
 126 pmt_u8vector_set(pmt_t vector, size_t k, uint8_t obj)
 127 {
 128   if (!vector->is_u8vector())
 129     throw pmt_wrong_type("pmt_u8vector_set", vector);
 130   _u8vector(vector)->set(k, obj);
 131 }
 132
 133 const uint8_t *
 134 pmt_u8vector_elements(pmt_t vector, size_t &len)
 135 {
 136   if (!vector->is_u8vector())
 137     throw pmt_wrong_type("pmt_u8vector_elements", vector);
 138   return _u8vector(vector)->elements(len);
 139 }
 140
 141 uint8_t *
 142 pmt_u8vector_writable_elements(pmt_t vector, size_t &len)
 143 {
 144   if (!vector->is_u8vector())
 145     throw pmt_wrong_type("pmt_u8vector_writable_elements", vector);
 146   return _u8vector(vector)->writable_elements(len);
 147 }
 148 ////////////////////////////////////////////////////////////////////////////
 149 //                           pmt_s8vector
 150 ////////////////////////////////////////////////////////////////////////////
 151
 152 static pmt_s8vector *
 153 _s8vector(pmt_t x)
 154 {
 155   return dynamic_cast<pmt_s8vector*>(x.get());
 156 }
 157
 158
 159 pmt_s8vector::pmt_s8vector(size_t k, int8_t fill)
 160   : d_v(k)
 161 {
 162   for (size_t i = 0; i < k; i++)
 163     d_v[i] = fill;
 164 }
 165
 166 pmt_s8vector::pmt_s8vector(size_t k, const int8_t *data)
 167   : d_v(k)
 168 {
 169   for (size_t i = 0; i < k; i++)
 170     d_v[i] = data[i];
 171 }
 172
 173 int8_t
 174 pmt_s8vector::ref(size_t k) const
 175 {
 176   if (k >= length())
 177     throw pmt_out_of_range("pmt_s8vector_ref", pmt_from_long(k));
 178   return d_v[k];
 179 }
 180
 181 void
 182 pmt_s8vector::set(size_t k, int8_t x)
 183 {
 184   if (k >= length())
 185     throw pmt_out_of_range("pmt_s8vector_set", pmt_from_long(k));
 186   d_v[k] = x;
 187 }
 188
 189 const int8_t *
 190 pmt_s8vector::elements(size_t &len)
 191 {
 192   len = length();
 193   return &d_v[0];
 194 }
 195
 196 int8_t *
 197 pmt_s8vector::writable_elements(size_t &len)
 198 {
 199   len = length();
 200   return &d_v[0];
 201 }
 202
 203 const void*
 204 pmt_s8vector::uniform_elements(size_t &len)
 205 {
 206   len = length() * sizeof(int8_t);
 207   return &d_v[0];
 208 }
 209
 210 void*
 211 pmt_s8vector::uniform_writable_elements(size_t &len)
 212 {
 213   len = length() * sizeof(int8_t);
 214   return &d_v[0];
 215 }
 216
 217 bool
 218 pmt_is_s8vector(pmt_t obj)
 219 {
 220   return obj->is_s8vector();
 221 }
 222
 223 pmt_t
 224 pmt_make_s8vector(size_t k, int8_t fill)
 225 {
 226   return pmt_t(new pmt_s8vector(k, fill));
 227 }
 228
 229 pmt_t
 230 pmt_init_s8vector(size_t k, const int8_t *data)
 231 {
 232   return pmt_t(new pmt_s8vector(k, data));
 233 }
 234
 235 int8_t
 236 pmt_s8vector_ref(pmt_t vector, size_t k)
 237 {
 238   if (!vector->is_s8vector())
 239     throw pmt_wrong_type("pmt_s8vector_ref", vector);
 240   return _s8vector(vector)->ref(k);
 241 }
 242
 243 void
 244 pmt_s8vector_set(pmt_t vector, size_t k, int8_t obj)
 245 {
 246   if (!vector->is_s8vector())
 247     throw pmt_wrong_type("pmt_s8vector_set", vector);
 248   _s8vector(vector)->set(k, obj);
 249 }
 250
 251 const int8_t *
 252 pmt_s8vector_elements(pmt_t vector, size_t &len)
 253 {
 254   if (!vector->is_s8vector())
 255     throw pmt_wrong_type("pmt_s8vector_elements", vector);
 256   return _s8vector(vector)->elements(len);
 257 }
 258
 259 int8_t *
 260 pmt_s8vector_writable_elements(pmt_t vector, size_t &len)
 261 {
 262   if (!vector->is_s8vector())
 263     throw pmt_wrong_type("pmt_s8vector_writable_elements", vector);
 264   return _s8vector(vector)->writable_elements(len);
 265 }
 266 ////////////////////////////////////////////////////////////////////////////
 267 //                           pmt_u16vector
 268 ////////////////////////////////////////////////////////////////////////////
 269
 270 static pmt_u16vector *
 271 _u16vector(pmt_t x)
 272 {
 273   return dynamic_cast<pmt_u16vector*>(x.get());
 274 }
 275
 276
 277 pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill)
 278   : d_v(k)
 279 {
 280   for (size_t i = 0; i < k; i++)
 281     d_v[i] = fill;
 282 }
 283
 284 pmt_u16vector::pmt_u16vector(size_t k, const uint16_t *data)
 285   : d_v(k)
 286 {
 287   for (size_t i = 0; i < k; i++)
 288     d_v[i] = data[i];
 289 }
 290
 291 uint16_t
 292 pmt_u16vector::ref(size_t k) const
 293 {
 294   if (k >= length())
 295     throw pmt_out_of_range("pmt_u16vector_ref", pmt_from_long(k));
 296   return d_v[k];
 297 }
 298
 299 void
 300 pmt_u16vector::set(size_t k, uint16_t x)
 301 {
 302   if (k >= length())
 303     throw pmt_out_of_range("pmt_u16vector_set", pmt_from_long(k));
 304   d_v[k] = x;
 305 }
 306
 307 const uint16_t *
 308 pmt_u16vector::elements(size_t &len)
 309 {
 310   len = length();
 311   return &d_v[0];
 312 }
 313
 314 uint16_t *
 315 pmt_u16vector::writable_elements(size_t &len)
 316 {
 317   len = length();
 318   return &d_v[0];
 319 }
 320
 321 const void*
 322 pmt_u16vector::uniform_elements(size_t &len)
 323 {
 324   len = length() * sizeof(uint16_t);
 325   return &d_v[0];
 326 }
 327
 328 void*
 329 pmt_u16vector::uniform_writable_elements(size_t &len)
 330 {
 331   len = length() * sizeof(uint16_t);
 332   return &d_v[0];
 333 }
 334
 335 bool
 336 pmt_is_u16vector(pmt_t obj)
 337 {
 338   return obj->is_u16vector();
 339 }
 340
 341 pmt_t
 342 pmt_make_u16vector(size_t k, uint16_t fill)
 343 {
 344   return pmt_t(new pmt_u16vector(k, fill));
 345 }
 346
 347 pmt_t
 348 pmt_init_u16vector(size_t k, const uint16_t *data)
 349 {
 350   return pmt_t(new pmt_u16vector(k, data));
 351 }
 352
 353 uint16_t
 354 pmt_u16vector_ref(pmt_t vector, size_t k)
 355 {
 356   if (!vector->is_u16vector())
 357     throw pmt_wrong_type("pmt_u16vector_ref", vector);
 358   return _u16vector(vector)->ref(k);
 359 }
 360
 361 void
 362 pmt_u16vector_set(pmt_t vector, size_t k, uint16_t obj)
 363 {
 364   if (!vector->is_u16vector())
 365     throw pmt_wrong_type("pmt_u16vector_set", vector);
 366   _u16vector(vector)->set(k, obj);
 367 }
 368
 369 const uint16_t *
 370 pmt_u16vector_elements(pmt_t vector, size_t &len)
 371 {
 372   if (!vector->is_u16vector())
 373     throw pmt_wrong_type("pmt_u16vector_elements", vector);
 374   return _u16vector(vector)->elements(len);
 375 }
 376
 377 uint16_t *
 378 pmt_u16vector_writable_elements(pmt_t vector, size_t &len)
 379 {
 380   if (!vector->is_u16vector())
 381     throw pmt_wrong_type("pmt_u16vector_writable_elements", vector);
 382   return _u16vector(vector)->writable_elements(len);
 383 }
 384 ////////////////////////////////////////////////////////////////////////////
 385 //                           pmt_s16vector
 386 ////////////////////////////////////////////////////////////////////////////
 387
 388 static pmt_s16vector *
 389 _s16vector(pmt_t x)
 390 {
 391   return dynamic_cast<pmt_s16vector*>(x.get());
 392 }
 393
 394
 395 pmt_s16vector::pmt_s16vector(size_t k, int16_t fill)
 396   : d_v(k)
 397 {
 398   for (size_t i = 0; i < k; i++)
 399     d_v[i] = fill;
 400 }
 401
 402 pmt_s16vector::pmt_s16vector(size_t k, const int16_t *data)
 403   : d_v(k)
 404 {
 405   for (size_t i = 0; i < k; i++)
 406     d_v[i] = data[i];
 407 }
 408
 409 int16_t
 410 pmt_s16vector::ref(size_t k) const
 411 {
 412   if (k >= length())
 413     throw pmt_out_of_range("pmt_s16vector_ref", pmt_from_long(k));
 414   return d_v[k];
 415 }
 416
 417 void
 418 pmt_s16vector::set(size_t k, int16_t x)
 419 {
 420   if (k >= length())
 421     throw pmt_out_of_range("pmt_s16vector_set", pmt_from_long(k));
 422   d_v[k] = x;
 423 }
 424
 425 const int16_t *
 426 pmt_s16vector::elements(size_t &len)
 427 {
 428   len = length();
 429   return &d_v[0];
 430 }
 431
 432 int16_t *
 433 pmt_s16vector::writable_elements(size_t &len)
 434 {
 435   len = length();
 436   return &d_v[0];
 437 }
 438
 439 const void*
 440 pmt_s16vector::uniform_elements(size_t &len)
 441 {
 442   len = length() * sizeof(int16_t);
 443   return &d_v[0];
 444 }
 445
 446 void*
 447 pmt_s16vector::uniform_writable_elements(size_t &len)
 448 {
 449   len = length() * sizeof(int16_t);
 450   return &d_v[0];
 451 }
 452
 453 bool
 454 pmt_is_s16vector(pmt_t obj)
 455 {
 456   return obj->is_s16vector();
 457 }
 458
 459 pmt_t
 460 pmt_make_s16vector(size_t k, int16_t fill)
 461 {
 462   return pmt_t(new pmt_s16vector(k, fill));
 463 }
 464
 465 pmt_t
 466 pmt_init_s16vector(size_t k, const int16_t *data)
 467 {
 468   return pmt_t(new pmt_s16vector(k, data));
 469 }
 470
 471 int16_t
 472 pmt_s16vector_ref(pmt_t vector, size_t k)
 473 {
 474   if (!vector->is_s16vector())
 475     throw pmt_wrong_type("pmt_s16vector_ref", vector);
 476   return _s16vector(vector)->ref(k);
 477 }
 478
 479 void
 480 pmt_s16vector_set(pmt_t vector, size_t k, int16_t obj)
 481 {
 482   if (!vector->is_s16vector())
 483     throw pmt_wrong_type("pmt_s16vector_set", vector);
 484   _s16vector(vector)->set(k, obj);
 485 }
 486
 487 const int16_t *
 488 pmt_s16vector_elements(pmt_t vector, size_t &len)
 489 {
 490   if (!vector->is_s16vector())
 491     throw pmt_wrong_type("pmt_s16vector_elements", vector);
 492   return _s16vector(vector)->elements(len);
 493 }
 494
 495 int16_t *
 496 pmt_s16vector_writable_elements(pmt_t vector, size_t &len)
 497 {
 498   if (!vector->is_s16vector())
 499     throw pmt_wrong_type("pmt_s16vector_writable_elements", vector);
 500   return _s16vector(vector)->writable_elements(len);
 501 }
 502 ////////////////////////////////////////////////////////////////////////////
 503 //                           pmt_u32vector
 504 ////////////////////////////////////////////////////////////////////////////
 505
 506 static pmt_u32vector *
 507 _u32vector(pmt_t x)
 508 {
 509   return dynamic_cast<pmt_u32vector*>(x.get());
 510 }
 511
 512
 513 pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill)
 514   : d_v(k)
 515 {
 516   for (size_t i = 0; i < k; i++)
 517     d_v[i] = fill;
 518 }
 519
 520 pmt_u32vector::pmt_u32vector(size_t k, const uint32_t *data)
 521   : d_v(k)
 522 {
 523   for (size_t i = 0; i < k; i++)
 524     d_v[i] = data[i];
 525 }
 526
 527 uint32_t
 528 pmt_u32vector::ref(size_t k) const
 529 {
 530   if (k >= length())
 531     throw pmt_out_of_range("pmt_u32vector_ref", pmt_from_long(k));
 532   return d_v[k];
 533 }
 534
 535 void
 536 pmt_u32vector::set(size_t k, uint32_t x)
 537 {
 538   if (k >= length())
 539     throw pmt_out_of_range("pmt_u32vector_set", pmt_from_long(k));
 540   d_v[k] = x;
 541 }
 542
 543 const uint32_t *
 544 pmt_u32vector::elements(size_t &len)
 545 {
 546   len = length();
 547   return &d_v[0];
 548 }
 549
 550 uint32_t *
 551 pmt_u32vector::writable_elements(size_t &len)
 552 {
 553   len = length();
 554   return &d_v[0];
 555 }
 556
 557 const void*
 558 pmt_u32vector::uniform_elements(size_t &len)
 559 {
 560   len = length() * sizeof(uint32_t);
 561   return &d_v[0];
 562 }
 563
 564 void*
 565 pmt_u32vector::uniform_writable_elements(size_t &len)
 566 {
 567   len = length() * sizeof(uint32_t);
 568   return &d_v[0];
 569 }
 570
 571 bool
 572 pmt_is_u32vector(pmt_t obj)
 573 {
 574   return obj->is_u32vector();
 575 }
 576
 577 pmt_t
 578 pmt_make_u32vector(size_t k, uint32_t fill)
 579 {
 580   return pmt_t(new pmt_u32vector(k, fill));
 581 }
 582
 583 pmt_t
 584 pmt_init_u32vector(size_t k, const uint32_t *data)
 585 {
 586   return pmt_t(new pmt_u32vector(k, data));
 587 }
 588
 589 uint32_t
 590 pmt_u32vector_ref(pmt_t vector, size_t k)
 591 {
 592   if (!vector->is_u32vector())
 593     throw pmt_wrong_type("pmt_u32vector_ref", vector);
 594   return _u32vector(vector)->ref(k);
 595 }
 596
 597 void
 598 pmt_u32vector_set(pmt_t vector, size_t k, uint32_t obj)
 599 {
 600   if (!vector->is_u32vector())
 601     throw pmt_wrong_type("pmt_u32vector_set", vector);
 602   _u32vector(vector)->set(k, obj);
 603 }
 604
 605 const uint32_t *
 606 pmt_u32vector_elements(pmt_t vector, size_t &len)
 607 {
 608   if (!vector->is_u32vector())
 609     throw pmt_wrong_type("pmt_u32vector_elements", vector);
 610   return _u32vector(vector)->elements(len);
 611 }
 612
 613 uint32_t *
 614 pmt_u32vector_writable_elements(pmt_t vector, size_t &len)
 615 {
 616   if (!vector->is_u32vector())
 617     throw pmt_wrong_type("pmt_u32vector_writable_elements", vector);
 618   return _u32vector(vector)->writable_elements(len);
 619 }
 620 ////////////////////////////////////////////////////////////////////////////
 621 //                           pmt_s32vector
 622 ////////////////////////////////////////////////////////////////////////////
 623
 624 static pmt_s32vector *
 625 _s32vector(pmt_t x)
 626 {
 627   return dynamic_cast<pmt_s32vector*>(x.get());
 628 }
 629
 630
 631 pmt_s32vector::pmt_s32vector(size_t k, int32_t fill)
 632   : d_v(k)
 633 {
 634   for (size_t i = 0; i < k; i++)
 635     d_v[i] = fill;
 636 }
 637
 638 pmt_s32vector::pmt_s32vector(size_t k, const int32_t *data)
 639   : d_v(k)
 640 {
 641   for (size_t i = 0; i < k; i++)
 642     d_v[i] = data[i];
 643 }
 644
 645 int32_t
 646 pmt_s32vector::ref(size_t k) const
 647 {
 648   if (k >= length())
 649     throw pmt_out_of_range("pmt_s32vector_ref", pmt_from_long(k));
 650   return d_v[k];
 651 }
 652
 653 void
 654 pmt_s32vector::set(size_t k, int32_t x)
 655 {
 656   if (k >= length())
 657     throw pmt_out_of_range("pmt_s32vector_set", pmt_from_long(k));
 658   d_v[k] = x;
 659 }
 660
 661 const int32_t *
 662 pmt_s32vector::elements(size_t &len)
 663 {
 664   len = length();
 665   return &d_v[0];
 666 }
 667
 668 int32_t *
 669 pmt_s32vector::writable_elements(size_t &len)
 670 {
 671   len = length();
 672   return &d_v[0];
 673 }
 674
 675 const void*
 676 pmt_s32vector::uniform_elements(size_t &len)
 677 {
 678   len = length() * sizeof(int32_t);
 679   return &d_v[0];
 680 }
 681
 682 void*
 683 pmt_s32vector::uniform_writable_elements(size_t &len)
 684 {
 685   len = length() * sizeof(int32_t);
 686   return &d_v[0];
 687 }
 688
 689 bool
 690 pmt_is_s32vector(pmt_t obj)
 691 {
 692   return obj->is_s32vector();
 693 }
 694
 695 pmt_t
 696 pmt_make_s32vector(size_t k, int32_t fill)
 697 {
 698   return pmt_t(new pmt_s32vector(k, fill));
 699 }
 700
 701 pmt_t
 702 pmt_init_s32vector(size_t k, const int32_t *data)
 703 {
 704   return pmt_t(new pmt_s32vector(k, data));
 705 }
 706
 707 int32_t
 708 pmt_s32vector_ref(pmt_t vector, size_t k)
 709 {
 710   if (!vector->is_s32vector())
 711     throw pmt_wrong_type("pmt_s32vector_ref", vector);
 712   return _s32vector(vector)->ref(k);
 713 }
 714
 715 void
 716 pmt_s32vector_set(pmt_t vector, size_t k, int32_t obj)
 717 {
 718   if (!vector->is_s32vector())
 719     throw pmt_wrong_type("pmt_s32vector_set", vector);
 720   _s32vector(vector)->set(k, obj);
 721 }
 722
 723 const int32_t *
 724 pmt_s32vector_elements(pmt_t vector, size_t &len)
 725 {
 726   if (!vector->is_s32vector())
 727     throw pmt_wrong_type("pmt_s32vector_elements", vector);
 728   return _s32vector(vector)->elements(len);
 729 }
 730
 731 int32_t *
 732 pmt_s32vector_writable_elements(pmt_t vector, size_t &len)
 733 {
 734   if (!vector->is_s32vector())
 735     throw pmt_wrong_type("pmt_s32vector_writable_elements", vector);
 736   return _s32vector(vector)->writable_elements(len);
 737 }
 738 ////////////////////////////////////////////////////////////////////////////
 739 //                           pmt_u64vector
 740 ////////////////////////////////////////////////////////////////////////////
 741
 742 static pmt_u64vector *
 743 _u64vector(pmt_t x)
 744 {
 745   return dynamic_cast<pmt_u64vector*>(x.get());
 746 }
 747
 748
 749 pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill)
 750   : d_v(k)
 751 {
 752   for (size_t i = 0; i < k; i++)
 753     d_v[i] = fill;
 754 }
 755
 756 pmt_u64vector::pmt_u64vector(size_t k, const uint64_t *data)
 757   : d_v(k)
 758 {
 759   for (size_t i = 0; i < k; i++)
 760     d_v[i] = data[i];
 761 }
 762
 763 uint64_t
 764 pmt_u64vector::ref(size_t k) const
 765 {
 766   if (k >= length())
 767     throw pmt_out_of_range("pmt_u64vector_ref", pmt_from_long(k));
 768   return d_v[k];
 769 }
 770
 771 void
 772 pmt_u64vector::set(size_t k, uint64_t x)
 773 {
 774   if (k >= length())
 775     throw pmt_out_of_range("pmt_u64vector_set", pmt_from_long(k));
 776   d_v[k] = x;
 777 }
 778
 779 const uint64_t *
 780 pmt_u64vector::elements(size_t &len)
 781 {
 782   len = length();
 783   return &d_v[0];
 784 }
 785
 786 uint64_t *
 787 pmt_u64vector::writable_elements(size_t &len)
 788 {
 789   len = length();
 790   return &d_v[0];
 791 }
 792
 793 const void*
 794 pmt_u64vector::uniform_elements(size_t &len)
 795 {
 796   len = length() * sizeof(uint64_t);
 797   return &d_v[0];
 798 }
 799
 800 void*
 801 pmt_u64vector::uniform_writable_elements(size_t &len)
 802 {
 803   len = length() * sizeof(uint64_t);
 804   return &d_v[0];
 805 }
 806
 807 bool
 808 pmt_is_u64vector(pmt_t obj)
 809 {
 810   return obj->is_u64vector();
 811 }
 812
 813 pmt_t
 814 pmt_make_u64vector(size_t k, uint64_t fill)
 815 {
 816   return pmt_t(new pmt_u64vector(k, fill));
 817 }
 818
 819 pmt_t
 820 pmt_init_u64vector(size_t k, const uint64_t *data)
 821 {
 822   return pmt_t(new pmt_u64vector(k, data));
 823 }
 824
 825 uint64_t
 826 pmt_u64vector_ref(pmt_t vector, size_t k)
 827 {
 828   if (!vector->is_u64vector())
 829     throw pmt_wrong_type("pmt_u64vector_ref", vector);
 830   return _u64vector(vector)->ref(k);
 831 }
 832
 833 void
 834 pmt_u64vector_set(pmt_t vector, size_t k, uint64_t obj)
 835 {
 836   if (!vector->is_u64vector())
 837     throw pmt_wrong_type("pmt_u64vector_set", vector);
 838   _u64vector(vector)->set(k, obj);
 839 }
 840
 841 const uint64_t *
 842 pmt_u64vector_elements(pmt_t vector, size_t &len)
 843 {
 844   if (!vector->is_u64vector())
 845     throw pmt_wrong_type("pmt_u64vector_elements", vector);
 846   return _u64vector(vector)->elements(len);
 847 }
 848
 849 uint64_t *
 850 pmt_u64vector_writable_elements(pmt_t vector, size_t &len)
 851 {
 852   if (!vector->is_u64vector())
 853     throw pmt_wrong_type("pmt_u64vector_writable_elements", vector);
 854   return _u64vector(vector)->writable_elements(len);
 855 }
 856 ////////////////////////////////////////////////////////////////////////////
 857 //                           pmt_s64vector
 858 ////////////////////////////////////////////////////////////////////////////
 859
 860 static pmt_s64vector *
 861 _s64vector(pmt_t x)
 862 {
 863   return dynamic_cast<pmt_s64vector*>(x.get());
 864 }
 865
 866
 867 pmt_s64vector::pmt_s64vector(size_t k, int64_t fill)
 868   : d_v(k)
 869 {
 870   for (size_t i = 0; i < k; i++)
 871     d_v[i] = fill;
 872 }
 873
 874 pmt_s64vector::pmt_s64vector(size_t k, const int64_t *data)
 875   : d_v(k)
 876 {
 877   for (size_t i = 0; i < k; i++)
 878     d_v[i] = data[i];
 879 }
 880
 881 int64_t
 882 pmt_s64vector::ref(size_t k) const
 883 {
 884   if (k >= length())
 885     throw pmt_out_of_range("pmt_s64vector_ref", pmt_from_long(k));
 886   return d_v[k];
 887 }
 888
 889 void
 890 pmt_s64vector::set(size_t k, int64_t x)
 891 {
 892   if (k >= length())
 893     throw pmt_out_of_range("pmt_s64vector_set", pmt_from_long(k));
 894   d_v[k] = x;
 895 }
 896
 897 const int64_t *
 898 pmt_s64vector::elements(size_t &len)
 899 {
 900   len = length();
 901   return &d_v[0];
 902 }
 903
 904 int64_t *
 905 pmt_s64vector::writable_elements(size_t &len)
 906 {
 907   len = length();
 908   return &d_v[0];
 909 }
 910
 911 const void*
 912 pmt_s64vector::uniform_elements(size_t &len)
 913 {
 914   len = length() * sizeof(int64_t);
 915   return &d_v[0];
 916 }
 917
 918 void*
 919 pmt_s64vector::uniform_writable_elements(size_t &len)
 920 {
 921   len = length() * sizeof(int64_t);
 922   return &d_v[0];
 923 }
 924
 925 bool
 926 pmt_is_s64vector(pmt_t obj)
 927 {
 928   return obj->is_s64vector();
 929 }
 930
 931 pmt_t
 932 pmt_make_s64vector(size_t k, int64_t fill)
 933 {
 934   return pmt_t(new pmt_s64vector(k, fill));
 935 }
 936
 937 pmt_t
 938 pmt_init_s64vector(size_t k, const int64_t *data)
 939 {
 940   return pmt_t(new pmt_s64vector(k, data));
 941 }
 942
 943 int64_t
 944 pmt_s64vector_ref(pmt_t vector, size_t k)
 945 {
 946   if (!vector->is_s64vector())
 947     throw pmt_wrong_type("pmt_s64vector_ref", vector);
 948   return _s64vector(vector)->ref(k);
 949 }
 950
 951 void
 952 pmt_s64vector_set(pmt_t vector, size_t k, int64_t obj)
 953 {
 954   if (!vector->is_s64vector())
 955     throw pmt_wrong_type("pmt_s64vector_set", vector);
 956   _s64vector(vector)->set(k, obj);
 957 }
 958
 959 const int64_t *
 960 pmt_s64vector_elements(pmt_t vector, size_t &len)
 961 {
 962   if (!vector->is_s64vector())
 963     throw pmt_wrong_type("pmt_s64vector_elements", vector);
 964   return _s64vector(vector)->elements(len);
 965 }
 966
 967 int64_t *
 968 pmt_s64vector_writable_elements(pmt_t vector, size_t &len)
 969 {
 970   if (!vector->is_s64vector())
 971     throw pmt_wrong_type("pmt_s64vector_writable_elements", vector);
 972   return _s64vector(vector)->writable_elements(len);
 973 }
 974 ////////////////////////////////////////////////////////////////////////////
 975 //                           pmt_f32vector
 976 ////////////////////////////////////////////////////////////////////////////
 977
 978 static pmt_f32vector *
 979 _f32vector(pmt_t x)
 980 {
 981   return dynamic_cast<pmt_f32vector*>(x.get());
 982 }
 983
 984
 985 pmt_f32vector::pmt_f32vector(size_t k, float fill)
 986   : d_v(k)
 987 {
 988   for (size_t i = 0; i < k; i++)
 989     d_v[i] = fill;
 990 }
 991
 992 pmt_f32vector::pmt_f32vector(size_t k, const float *data)
 993   : d_v(k)
 994 {
 995   for (size_t i = 0; i < k; i++)
 996     d_v[i] = data[i];
 997 }
 998
 999 float
1000 pmt_f32vector::ref(size_t k) const
1001 {
1002   if (k >= length())
1003     throw pmt_out_of_range("pmt_f32vector_ref", pmt_from_long(k));
1004   return d_v[k];
1005 }
1006
1007 void
1008 pmt_f32vector::set(size_t k, float x)
1009 {
1010   if (k >= length())
1011     throw pmt_out_of_range("pmt_f32vector_set", pmt_from_long(k));
1012   d_v[k] = x;
1013 }
1014
1015 const float *
1016 pmt_f32vector::elements(size_t &len)
1017 {
1018   len = length();
1019   return &d_v[0];
1020 }
1021
1022 float *
1023 pmt_f32vector::writable_elements(size_t &len)
1024 {
1025   len = length();
1026   return &d_v[0];
1027 }
1028
1029 const void*
1030 pmt_f32vector::uniform_elements(size_t &len)
1031 {
1032   len = length() * sizeof(float);
1033   return &d_v[0];
1034 }
1035
1036 void*
1037 pmt_f32vector::uniform_writable_elements(size_t &len)
1038 {
1039   len = length() * sizeof(float);
1040   return &d_v[0];
1041 }
1042
1043 bool
1044 pmt_is_f32vector(pmt_t obj)
1045 {
1046   return obj->is_f32vector();
1047 }
1048
1049 pmt_t
1050 pmt_make_f32vector(size_t k, float fill)
1051 {
1052   return pmt_t(new pmt_f32vector(k, fill));
1053 }
1054
1055 pmt_t
1056 pmt_init_f32vector(size_t k, const float *data)
1057 {
1058   return pmt_t(new pmt_f32vector(k, data));
1059 }
1060
1061 float
1062 pmt_f32vector_ref(pmt_t vector, size_t k)
1063 {
1064   if (!vector->is_f32vector())
1065     throw pmt_wrong_type("pmt_f32vector_ref", vector);
1066   return _f32vector(vector)->ref(k);
1067 }
1068
1069 void
1070 pmt_f32vector_set(pmt_t vector, size_t k, float obj)
1071 {
1072   if (!vector->is_f32vector())
1073     throw pmt_wrong_type("pmt_f32vector_set", vector);
1074   _f32vector(vector)->set(k, obj);
1075 }
1076
1077 const float *
1078 pmt_f32vector_elements(pmt_t vector, size_t &len)
1079 {
1080   if (!vector->is_f32vector())
1081     throw pmt_wrong_type("pmt_f32vector_elements", vector);
1082   return _f32vector(vector)->elements(len);
1083 }
1084
1085 float *
1086 pmt_f32vector_writable_elements(pmt_t vector, size_t &len)
1087 {
1088   if (!vector->is_f32vector())
1089     throw pmt_wrong_type("pmt_f32vector_writable_elements", vector);
1090   return _f32vector(vector)->writable_elements(len);
1091 }
1092 ////////////////////////////////////////////////////////////////////////////
1093 //                           pmt_f64vector
1094 ////////////////////////////////////////////////////////////////////////////
1095
1096 static pmt_f64vector *
1097 _f64vector(pmt_t x)
1098 {
1099   return dynamic_cast<pmt_f64vector*>(x.get());
1100 }
1101
1102
1103 pmt_f64vector::pmt_f64vector(size_t k, double fill)
1104   : d_v(k)
1105 {
1106   for (size_t i = 0; i < k; i++)
1107     d_v[i] = fill;
1108 }
1109
1110 pmt_f64vector::pmt_f64vector(size_t k, const double *data)
1111   : d_v(k)
1112 {
1113   for (size_t i = 0; i < k; i++)
1114     d_v[i] = data[i];
1115 }
1116
1117 double
1118 pmt_f64vector::ref(size_t k) const
1119 {
1120   if (k >= length())
1121     throw pmt_out_of_range("pmt_f64vector_ref", pmt_from_long(k));
1122   return d_v[k];
1123 }
1124
1125 void
1126 pmt_f64vector::set(size_t k, double x)
1127 {
1128   if (k >= length())
1129     throw pmt_out_of_range("pmt_f64vector_set", pmt_from_long(k));
1130   d_v[k] = x;
1131 }
1132
1133 const double *
1134 pmt_f64vector::elements(size_t &len)
1135 {
1136   len = length();
1137   return &d_v[0];
1138 }
1139
1140 double *
1141 pmt_f64vector::writable_elements(size_t &len)
1142 {
1143   len = length();
1144   return &d_v[0];
1145 }
1146
1147 const void*
1148 pmt_f64vector::uniform_elements(size_t &len)
1149 {
1150   len = length() * sizeof(double);
1151   return &d_v[0];
1152 }
1153
1154 void*
1155 pmt_f64vector::uniform_writable_elements(size_t &len)
1156 {
1157   len = length() * sizeof(double);
1158   return &d_v[0];
1159 }
1160
1161 bool
1162 pmt_is_f64vector(pmt_t obj)
1163 {
1164   return obj->is_f64vector();
1165 }
1166
1167 pmt_t
1168 pmt_make_f64vector(size_t k, double fill)
1169 {
1170   return pmt_t(new pmt_f64vector(k, fill));
1171 }
1172
1173 pmt_t
1174 pmt_init_f64vector(size_t k, const double *data)
1175 {
1176   return pmt_t(new pmt_f64vector(k, data));
1177 }
1178
1179 double
1180 pmt_f64vector_ref(pmt_t vector, size_t k)
1181 {
1182   if (!vector->is_f64vector())
1183     throw pmt_wrong_type("pmt_f64vector_ref", vector);
1184   return _f64vector(vector)->ref(k);
1185 }
1186
1187 void
1188 pmt_f64vector_set(pmt_t vector, size_t k, double obj)
1189 {
1190   if (!vector->is_f64vector())
1191     throw pmt_wrong_type("pmt_f64vector_set", vector);
1192   _f64vector(vector)->set(k, obj);
1193 }
1194
1195 const double *
1196 pmt_f64vector_elements(pmt_t vector, size_t &len)
1197 {
1198   if (!vector->is_f64vector())
1199     throw pmt_wrong_type("pmt_f64vector_elements", vector);
1200   return _f64vector(vector)->elements(len);
1201 }
1202
1203 double *
1204 pmt_f64vector_writable_elements(pmt_t vector, size_t &len)
1205 {
1206   if (!vector->is_f64vector())
1207     throw pmt_wrong_type("pmt_f64vector_writable_elements", vector);
1208   return _f64vector(vector)->writable_elements(len);
1209 }
1210 ////////////////////////////////////////////////////////////////////////////
1211 //                           pmt_c32vector
1212 ////////////////////////////////////////////////////////////////////////////
1213
1214 static pmt_c32vector *
1215 _c32vector(pmt_t x)
1216 {
1217   return dynamic_cast<pmt_c32vector*>(x.get());
1218 }
1219
1220
1221 pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill)
1222   : d_v(k)
1223 {
1224   for (size_t i = 0; i < k; i++)
1225     d_v[i] = fill;
1226 }
1227
1228 pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float> *data)
1229   : d_v(k)
1230 {
1231   for (size_t i = 0; i < k; i++)
1232     d_v[i] = data[i];
1233 }
1234
1235 std::complex<float>
1236 pmt_c32vector::ref(size_t k) const
1237 {
1238   if (k >= length())
1239     throw pmt_out_of_range("pmt_c32vector_ref", pmt_from_long(k));
1240   return d_v[k];
1241 }
1242
1243 void
1244 pmt_c32vector::set(size_t k, std::complex<float> x)
1245 {
1246   if (k >= length())
1247     throw pmt_out_of_range("pmt_c32vector_set", pmt_from_long(k));
1248   d_v[k] = x;
1249 }
1250
1251 const std::complex<float> *
1252 pmt_c32vector::elements(size_t &len)
1253 {
1254   len = length();
1255   return &d_v[0];
1256 }
1257
1258 std::complex<float> *
1259 pmt_c32vector::writable_elements(size_t &len)
1260 {
1261   len = length();
1262   return &d_v[0];
1263 }
1264
1265 const void*
1266 pmt_c32vector::uniform_elements(size_t &len)
1267 {
1268   len = length() * sizeof(std::complex<float>);
1269   return &d_v[0];
1270 }
1271
1272 void*
1273 pmt_c32vector::uniform_writable_elements(size_t &len)
1274 {
1275   len = length() * sizeof(std::complex<float>);
1276   return &d_v[0];
1277 }
1278
1279 bool
1280 pmt_is_c32vector(pmt_t obj)
1281 {
1282   return obj->is_c32vector();
1283 }
1284
1285 pmt_t
1286 pmt_make_c32vector(size_t k, std::complex<float> fill)
1287 {
1288   return pmt_t(new pmt_c32vector(k, fill));
1289 }
1290
1291 pmt_t
1292 pmt_init_c32vector(size_t k, const std::complex<float> *data)
1293 {
1294   return pmt_t(new pmt_c32vector(k, data));
1295 }
1296
1297 std::complex<float>
1298 pmt_c32vector_ref(pmt_t vector, size_t k)
1299 {
1300   if (!vector->is_c32vector())
1301     throw pmt_wrong_type("pmt_c32vector_ref", vector);
1302   return _c32vector(vector)->ref(k);
1303 }
1304
1305 void
1306 pmt_c32vector_set(pmt_t vector, size_t k, std::complex<float> obj)
1307 {
1308   if (!vector->is_c32vector())
1309     throw pmt_wrong_type("pmt_c32vector_set", vector);
1310   _c32vector(vector)->set(k, obj);
1311 }
1312
1313 const std::complex<float> *
1314 pmt_c32vector_elements(pmt_t vector, size_t &len)
1315 {
1316   if (!vector->is_c32vector())
1317     throw pmt_wrong_type("pmt_c32vector_elements", vector);
1318   return _c32vector(vector)->elements(len);
1319 }
1320
1321 std::complex<float> *
1322 pmt_c32vector_writable_elements(pmt_t vector, size_t &len)
1323 {
1324   if (!vector->is_c32vector())
1325     throw pmt_wrong_type("pmt_c32vector_writable_elements", vector);
1326   return _c32vector(vector)->writable_elements(len);
1327 }
1328 ////////////////////////////////////////////////////////////////////////////
1329 //                           pmt_c64vector
1330 ////////////////////////////////////////////////////////////////////////////
1331
1332 static pmt_c64vector *
1333 _c64vector(pmt_t x)
1334 {
1335   return dynamic_cast<pmt_c64vector*>(x.get());
1336 }
1337
1338
1339 pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill)
1340   : d_v(k)
1341 {
1342   for (size_t i = 0; i < k; i++)
1343     d_v[i] = fill;
1344 }
1345
1346 pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double> *data)
1347   : d_v(k)
1348 {
1349   for (size_t i = 0; i < k; i++)
1350     d_v[i] = data[i];
1351 }
1352
1353 std::complex<double>
1354 pmt_c64vector::ref(size_t k) const
1355 {
1356   if (k >= length())
1357     throw pmt_out_of_range("pmt_c64vector_ref", pmt_from_long(k));
1358   return d_v[k];
1359 }
1360
1361 void
1362 pmt_c64vector::set(size_t k, std::complex<double> x)
1363 {
1364   if (k >= length())
1365     throw pmt_out_of_range("pmt_c64vector_set", pmt_from_long(k));
1366   d_v[k] = x;
1367 }
1368
1369 const std::complex<double> *
1370 pmt_c64vector::elements(size_t &len)
1371 {
1372   len = length();
1373   return &d_v[0];
1374 }
1375
1376 std::complex<double> *
1377 pmt_c64vector::writable_elements(size_t &len)
1378 {
1379   len = length();
1380   return &d_v[0];
1381 }
1382
1383 const void*
1384 pmt_c64vector::uniform_elements(size_t &len)
1385 {
1386   len = length() * sizeof(std::complex<double>);
1387   return &d_v[0];
1388 }
1389
1390 void*
1391 pmt_c64vector::uniform_writable_elements(size_t &len)
1392 {
1393   len = length() * sizeof(std::complex<double>);
1394   return &d_v[0];
1395 }
1396
1397 bool
1398 pmt_is_c64vector(pmt_t obj)
1399 {
1400   return obj->is_c64vector();
1401 }
1402
1403 pmt_t
1404 pmt_make_c64vector(size_t k, std::complex<double> fill)
1405 {
1406   return pmt_t(new pmt_c64vector(k, fill));
1407 }
1408
1409 pmt_t
1410 pmt_init_c64vector(size_t k, const std::complex<double> *data)
1411 {
1412   return pmt_t(new pmt_c64vector(k, data));
1413 }
1414
1415 std::complex<double>
1416 pmt_c64vector_ref(pmt_t vector, size_t k)
1417 {
1418   if (!vector->is_c64vector())
1419     throw pmt_wrong_type("pmt_c64vector_ref", vector);
1420   return _c64vector(vector)->ref(k);
1421 }
1422
1423 void
1424 pmt_c64vector_set(pmt_t vector, size_t k, std::complex<double> obj)
1425 {
1426   if (!vector->is_c64vector())
1427     throw pmt_wrong_type("pmt_c64vector_set", vector);
1428   _c64vector(vector)->set(k, obj);
1429 }
1430
1431 const std::complex<double> *
1432 pmt_c64vector_elements(pmt_t vector, size_t &len)
1433 {
1434   if (!vector->is_c64vector())
1435     throw pmt_wrong_type("pmt_c64vector_elements", vector);
1436   return _c64vector(vector)->elements(len);
1437 }
1438
1439 std::complex<double> *
1440 pmt_c64vector_writable_elements(pmt_t vector, size_t &len)
1441 {
1442   if (!vector->is_c64vector())
1443     throw pmt_wrong_type("pmt_c64vector_writable_elements", vector);
1444   return _c64vector(vector)->writable_elements(len);
1445 }