1 files changed, 303 insertions, 0 deletions
diff --git a/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc b/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc
new file mode 100644
index 0000000000..cc8804f79d
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc
@@ -0,0 +1,303 @@
+/*
+ * Copyright 2014,2015 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <boost/assign/ptr_map_inserter.hpp>
+#include <gnuradio/rpcpmtconverters_thrift.h>
+#include <gnuradio/gr_complex.h>
+#include "thrift/gnuradio_types.h"
+#include <iostream>
+
+GNURadio::Knob
+rpcpmtconverter::from_pmt(const pmt::pmt_t& knob)
+{
+  if(pmt::is_real(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::DOUBLE;
+    result.value.__set_a_double(pmt::to_double(knob));
+    return result;
+  }
+  else if(pmt::is_symbol(knob)) {
+    std::string value = pmt::symbol_to_string(knob);
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::STRING;
+    result.value.__set_a_string(value);
+    return result;
+  }
+  else if(pmt::is_integer(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::LONG;
+    result.value.__set_a_long(pmt::to_long(knob));
+    return result;
+  }
+  else if(pmt::is_bool(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::BOOL;
+    result.value.__set_a_bool(pmt::to_bool(knob));
+    return result;
+  }
+  else if(pmt::is_uint64(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::LONG;
+    result.value.__set_a_long(pmt::to_uint64(knob));
+    return result;
+  }
+  else if(pmt::is_complex(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::COMPLEX;
+    std::complex<double> tmp = pmt::to_complex(knob);
+    GNURadio::complex cpx;
+    cpx.re = tmp.real();
+    cpx.im = tmp.imag();
+    result.value.__set_a_complex(cpx);
+    return result;
+  }
+  else if(pmt::is_f32vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::F32VECTOR;
+    size_t size(pmt::length(knob));
+    const float* start((const float*)pmt::f32vector_elements(knob,size));
+    result.value.__set_a_f32vector(std::vector<double>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_f64vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::F64VECTOR;
+    size_t size(pmt::length(knob));
+    const double* start((const double*)pmt::f64vector_elements(knob,size));
+    result.value.__set_a_f64vector(std::vector<double>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_s64vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::S64VECTOR;
+    size_t size(pmt::length(knob));
+    const int64_t* start((const int64_t*)pmt::s64vector_elements(knob,size));
+    result.value.__set_a_s64vector(std::vector<int64_t>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_s32vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::S32VECTOR;
+    size_t size(pmt::length(knob));
+    const int32_t* start((const int32_t*)pmt::s32vector_elements(knob,size));
+    result.value.__set_a_s32vector(std::vector<int32_t>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_s16vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::S16VECTOR;
+    size_t size(pmt::length(knob));
+    const int16_t* start((const int16_t*)pmt::s16vector_elements(knob,size));
+    result.value.__set_a_s16vector(std::vector<int16_t>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_s8vector(knob)) {
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::S8VECTOR;
+    size_t size(pmt::length(knob));
+    const int8_t* start((const int8_t*)pmt::s8vector_elements(knob,size));
+    result.value.__set_a_s8vector(std::basic_string<char>(start,start+size));
+    return result;
+  }
+  else if(pmt::is_c32vector(knob)) {
+    std::vector< GNURadio::complex > z;
+
+    GNURadio::Knob result;
+    result.type = GNURadio::BaseTypes::C32VECTOR;
+    size_t size(pmt::length(knob));
+    const gr_complex* start((const gr_complex*)pmt::c32vector_elements(knob,size));
+    for(size_t s = 0; s < size; s++) {
+      GNURadio::complex z0;
+      gr_complex z1 = gr_complex(*(start+s));
+      z0.__set_re(z1.real());
+      z0.__set_im(z1.imag());
+      z.push_back(z0);
+    }
+    result.value.__set_a_c32vector(z);
+    return result;
+  }
+  else {
+    std::cerr << "Error: Don't know how to handle Knob Type (from): " << knob << std::endl;
+    assert(0);
+  }
+  return GNURadio::Knob();
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_byte_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::mp(knob.value.a_byte);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_short_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::mp(knob.value.a_short);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_int_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::mp(knob.value.a_int);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_long_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::from_long(knob.value.a_long);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_double_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::mp(knob.value.a_double);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_string_f::operator()(const GNURadio::Knob& knob)
+{
+  return pmt::string_to_symbol(knob.value.a_string);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_bool_f::operator()(const GNURadio::Knob& knob)
+{
+  if(knob.value.a_bool)
+    return pmt::PMT_T;
+  else
+    return pmt::PMT_F;
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_complex_f::operator()(const GNURadio::Knob& knob)
+{
+  gr_complexd cpx(knob.value.a_complex.re, knob.value.a_complex.im);
+  return pmt::from_complex(cpx);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_f32vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<double> v_double = knob.value.a_f32vector;
+  std::vector<float> v(v_double.begin(), v_double.end());
+  return pmt::init_f32vector(v.size(), v);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_f64vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<double> v = knob.value.a_f64vector;
+  return pmt::init_f64vector(v.size(), v);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_s64vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<int64_t> v = knob.value.a_s64vector;
+  return pmt::init_s64vector(v.size(), v);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_s32vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<int32_t> v = knob.value.a_s32vector;
+  return pmt::init_s32vector(v.size(), v);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_s16vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<int16_t> v = knob.value.a_s16vector;
+  return pmt::init_s16vector(v.size(), v);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_s8vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::basic_string<char> v = knob.value.a_s8vector;
+  return pmt::init_s8vector(v.size(), reinterpret_cast<const int8_t*>(v.data()));
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_c32vect_f::operator()(const GNURadio::Knob& knob)
+{
+  std::vector<GNURadio::complex> v0 = knob.value.a_c32vector;
+  std::vector<GNURadio::complex>::iterator vitr;
+  std::vector<gr_complex> v;
+  for(vitr = v0.begin(); vitr != v0.end(); vitr++) {
+    v.push_back(gr_complex(vitr->re, vitr->im));
+  }
+  return pmt::init_c32vector(v.size(), v);
+}
+
+rpcpmtconverter::To_PMT rpcpmtconverter::To_PMT::instance;
+
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_bool_f>    reg_bool(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::BOOL);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_byte_f>    reg_byte(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::BYTE);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_short_f>   reg_short(rpcpmtconverter::To_PMT::instance,
+                                                                         GNURadio::BaseTypes::SHORT);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_int_f>     reg_int(rpcpmtconverter::To_PMT::instance,
+                                                                       GNURadio::BaseTypes::INT);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_long_f>    reg_long(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::LONG);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_double_f>  reg_double(rpcpmtconverter::To_PMT::instance,
+                                                                          GNURadio::BaseTypes::DOUBLE);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_string_f>  reg_string(rpcpmtconverter::To_PMT::instance,
+                                                                          GNURadio::BaseTypes::STRING);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_complex_f> reg_complex(rpcpmtconverter::To_PMT::instance,
+                                                                           GNURadio::BaseTypes::COMPLEX);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f32vect_f> reg_f32v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::F32VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f64vect_f> reg_f64v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::F64VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s64vect_f> reg_s64v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::S64VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s32vect_f> reg_s32v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::S32VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s16vect_f> reg_s16v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::S16VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s8vect_f>  reg_s8v(rpcpmtconverter::To_PMT::instance,
+                                                                       GNURadio::BaseTypes::S8VECTOR);
+rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_c32vect_f> reg_c32v(rpcpmtconverter::To_PMT::instance,
+                                                                        GNURadio::BaseTypes::C32VECTOR);
+
+template<typename TO_PMT_F>
+rpcpmtconverter::to_pmt_reg<TO_PMT_F>::to_pmt_reg(To_PMT& instance,
+                                                  const GNURadio::BaseTypes::type type)
+{
+  boost::assign::ptr_map_insert<TO_PMT_F>(instance.to_pmt_map)(type);
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt_f::operator()(const GNURadio::Knob& knob)
+{
+  std::cerr << "Error: Don't know how to handle Knob Type: " << knob.type << std::endl;
+  assert(0);
+  return pmt::pmt_t();
+}
+
+pmt::pmt_t
+rpcpmtconverter::To_PMT::operator()(const GNURadio::Knob& knob)
+{
+  return to_pmt_map[knob.type](knob);
+}