runtime: converting runtime core to gr namespace, gnuradio include dir.

author: Tom Rondeau <trondeau@vt.edu> 2013-04-17 13:43:52 -0400
committer: Tom Rondeau <trondeau@vt.edu> 2013-04-29 14:52:56 -0400
commit: f3e2e07201c50033bf6c9d0c6a6f068557b4f17f (patch)
tree: 140b3c2d20a951ffd4abd564c3378ee2e2f9fc7c /gnuradio-runtime/lib/controlport
parent: 35303ae975a5b1bdecc2492bc96e2b8e89b62a3d (diff)
12 files changed, 1015 insertions, 0 deletions
diff --git a/gnuradio-runtime/lib/controlport/CMakeLists.txt b/gnuradio-runtime/lib/controlport/CMakeLists.txt
new file mode 100644
index 0000000000..c05a82bf4f
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/CMakeLists.txt
@@ -0,0 +1,62 @@
+# Copyright 2013 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.
+
+if(ENABLE_GR_CTRLPORT)
+
+include_directories(${ICE_INCLUDE_DIR})
+
+# Add definition so we can compile in ControlPort to the blocks.
+ADD_DEFINITIONS(-DGR_CTRLPORT)
+
+########################################################################
+# Run ICE To compile Slice files
+########################################################################
+EXECUTE_PROCESS(
+   COMMAND "${ICE_SLICE2CPP}" "-I${CMAKE_CURRENT_SOURCE_DIR}"
+       "--output-dir=${CMAKE_CURRENT_BINARY_DIR}/"
+       "${CMAKE_CURRENT_SOURCE_DIR}/gnuradio.ice"
+   )
+
+list(APPEND gnuradio_runtime_sources
+  ${CMAKE_CURRENT_SOURCE_DIR}/ice_application_base.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcmanager.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcpmtconverters_ice.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcserver_aggregator.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcserver_booter_aggregator.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcserver_booter_ice.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcserver_ice.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/rpcserver_selector.cc
+)
+
+# Append generated file in build directory
+list(APPEND gnuradio_runtime_sources 
+    ${CMAKE_CURRENT_BINARY_DIR}/gnuradio.cpp
+)
+
+########################################################################
+# Add controlport stuff to gnuradio-runtime
+########################################################################
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+list(APPEND gnuradio_runtime_libs
+  ${ICE_LIBRARIES}
+)
+
+endif(ENABLE_GR_CTRLPORT)
diff --git a/gnuradio-runtime/lib/controlport/ICE_LICENSE b/gnuradio-runtime/lib/controlport/ICE_LICENSE
new file mode 100644
index 0000000000..43ea7572d9
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/ICE_LICENSE
@@ -0,0 +1,54 @@
+Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
+
+This copy of Ice is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 2 as
+published by the Free Software Foundation.
+
+Ice 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 version
+2 along with this program; if not, see http://www.gnu.org/licenses.
+
+Linking Ice statically or dynamically with other software (such as a 
+library, module or application) is making a combined work based on Ice. 
+Thus, the terms and conditions of the GNU General Public License version
+2 cover this combined work.
+
+If such software can only be used together with Ice, then not only the 
+combined work but the software itself is a work derived from Ice and as
+such shall be licensed under the terms of the GNU General Public License 
+version 2. This includes the situation where Ice is only being used 
+through an abstraction layer.
+
+As a special exception to the above, ZeroC grants to the contributors for
+the following projects the permission to license their Ice-based software 
+under the terms of the GNU Lesser General Public License (LGPL) version 
+2.1 or of the BSD license:
+
+ - Orca Robotics (http://orca-robotics.sourceforge.net)
+ 
+ - Mumble (http://mumble.sourceforge.net)
+
+This exception does not extend to the parts of Ice used by these 
+projects, or to any other derived work: as a whole, any work based on Ice
+shall be licensed under the terms and conditions of the GNU General
+Public License version 2.
+
+You may also combine Ice with any software not derived from Ice, provided
+the license of such software is compatible with the GNU General Public 
+License version 2. In addition, as a special exception, ZeroC grants you
+permission to combine Ice with:
+ 
+ - the OpenSSL library, or with a modified version of the OpenSSL library
+   that uses the same license as OpenSSL
+
+ - any library not derived from Ice and licensed under the terms of
+   the Apache License, version 2.0 
+   (http://www.apache.org/licenses/LICENSE-2.0.html) 
+
+If you modify this copy of Ice, you may extend any of the exceptions 
+provided above to your version of Ice, but you are not obligated to 
+do so.
diff --git a/gnuradio-runtime/lib/controlport/frontend.ice b/gnuradio-runtime/lib/controlport/frontend.ice
new file mode 100644
index 0000000000..b7474f37bf
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/frontend.ice
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2013 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 <gnuradio.ice>
+
+[["python:package:gnuradio.ctrlport"]]
+module GNURadio {
+    module Frontend {
+
+        // primitive types
+		dictionary<string, string>	StrStrDict;
+        dictionary<string, string>  TunerArgs;
+		struct F32Range 
+        {
+          float min; 
+          float max; 
+        };
+
+        // exception types
+        exception NotSupported {};
+        exception InvalidSetting { string msg; };
+        exception ReceiverFailure { string msg; };
+		exception NotExist {};
+
+
+        // Status Types
+        struct TunerStatus {
+            float freq;
+            float rate;
+            int   a2dbits;
+            float gain;
+            F32Range gainrange;
+            bool  isInverted;
+			StrStrDict info;
+        };
+
+        struct StreamInfo {
+			string uri;
+			StrStrDict info;
+        };
+
+        struct ReceiverInfo {
+            string uid;
+            string name;
+			StrStrDict info;
+        };
+
+        struct ChannelStatus {
+	    	string uid;
+            string name;
+            bool active;
+            float freq;
+            float bandwidth;
+            bool  isComplex;
+			StrStrDict info;
+        };
+
+        struct ChannelizerStatus {
+		    string uid;
+            string name;
+			StrStrDict info;
+        };
+
+        // Interfaces
+        interface Component {
+            void setName(string newName);
+        };
+
+        interface AbstractReceiver extends Component {
+            idempotent ReceiverInfo   getReceiverInfo();
+        };
+
+        interface Tuner extends Component {
+            TunerStatus configureTuner(TunerArgs args) throws ReceiverFailure, InvalidSetting;
+            idempotent TunerStatus status();
+            idempotent float setGain(float gain) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent bool  setInversion(bool inverted) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent float setCenterFreq(float freq) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent float setBandwidth(float bw) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent void  setInfo(string k, string v) throws ReceiverFailure, NotSupported, InvalidSetting;
+        };
+
+        interface Channel {
+            void start();
+            void stop();
+            void destroyChannel() throws NotSupported;
+            idempotent bool  active();
+            idempotent ChannelStatus status();
+            idempotent StreamInfo    stream();
+            idempotent bool setComplex(bool complex) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent void setInfo(string k, string v) throws ReceiverFailure, NotSupported, InvalidSetting;
+            idempotent void setStreamInfo(string k, string v) throws ReceiverFailure, NotSupported, InvalidSetting;
+        };
+
+        sequence<Tuner*>   TunerSeq;
+        sequence<Channel*> ChannelSeq;
+    
+        interface Channelizer extends AbstractReceiver {
+            idempotent ChannelizerStatus status();
+            idempotent Tuner*       getTuner();
+            idempotent ChannelSeq   getChannels();
+            idempotent ChannelSeq   getActiveChannels();
+            idempotent ChannelSeq   getInactiveChannels();
+            Channel* createChannel(float freq, float bw, StrStrDict args) throws NotSupported;
+        };
+
+        sequence<Channelizer*>  ChannelizerSeq;
+
+        interface Receiver extends AbstractReceiver {
+            idempotent ChannelizerSeq getInputs();
+            idempotent Channel* getChannelByID(string id) throws NotExist;
+            idempotent Channelizer* getChannelizerByID(string id) throws NotExist;
+            idempotent void setInfo(string k, string v) throws ReceiverFailure, NotSupported, InvalidSetting;
+        };
+
+    };
+    
+    module Booter {
+        dictionary<string, string>      WaveformArgs;
+        exception WaveformRunningError {
+            string waveformClass;
+            float centerFrequencyHz;
+        };
+        exception SignalSourceError {string msg; };
+        interface WaveformBooter extends Frontend::Receiver, ControlPort {
+            string  launchWaveform(string waveformClass, WaveformArgs       args)
+                    throws WaveformRunningError, SignalSourceError;
+            WaveformArgMap  getDriverEnum();
+            WaveformArgMap  getSourceInfo();
+            idempotent bool     waveformRunning();
+            idempotent string   getWaveformClass();
+        };
+    };
+};
diff --git a/gnuradio-runtime/lib/controlport/gnuradio.ice b/gnuradio-runtime/lib/controlport/gnuradio.ice
new file mode 100644
index 0000000000..731cbea956
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/gnuradio.ice
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2012 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.
+ */
+
+[["python:package:gnuradio.ctrlport"]]
+
+#ifndef GNURADIO_DEBUG
+#define GNURADIO_DEBUG
+
+module GNURadio {
+class Knob {};
+class KnobB extends Knob { bool   value; };
+class KnobC extends Knob { byte   value; };
+class KnobI extends Knob { int 	  value; };
+class KnobF extends Knob { float  value; };
+class KnobD extends Knob { double value; };
+class KnobL extends Knob { long   value; };
+class KnobS extends Knob { string value; };
+
+sequence<bool>   VectorB; sequence<byte>   VectorC; 
+sequence<int>    VectorI; sequence<float>  VectorF;
+sequence<double> VectorD; sequence<string> VectorS;
+sequence<long> 	 VectorL;
+
+class KnobVecB extends Knob { VectorB value; }; 
+class KnobVecC extends Knob { VectorC value; }; 
+class KnobVecI extends Knob { VectorI value; }; 
+class KnobVecF extends Knob { VectorF value; }; 
+class KnobVecD extends Knob { VectorD value; }; 
+class KnobVecL extends Knob { VectorL value; }; 
+class KnobVecS extends Knob { VectorS value; }; 
+
+enum KnobType { KNOBBOOL, 	KNOBCHAR, 	KNOBINT, 	KNOBFLOAT, 
+		KNOBDOUBLE, 	KNOBSTRING, 	KNOBLONG, 	KNOBVECBOOL, 
+		KNOBVECCHAR, 	KNOBVECINT,	KNOBVECFLOAT, 	KNOBVECDOUBLE, 
+		KNOBVECSTRING, 	KNOBVECLONG };
+
+const int DISPNULL = 0x0000;
+const int DISPTIME = 0x0001;
+const int DISPXY   = 0x0002;
+const int DISPPSD  = 0x0004;
+const int DISPSPEC = 0x0008;
+const int DISPRAST = 0x0010;
+const int DISPOPTCPLX    = 0x0100;
+const int DISPOPTLOG     = 0x0200;
+const int DISPOPTSTEM    = 0x0400; 
+const int DISPOPTSTRIP   = 0x0800;
+const int DISPOPTSCATTER = 0x1000;
+
+struct KnobProp {
+	KnobType    type;
+	string      units;
+	string      description;
+        int         display;
+	Knob        min;
+	Knob        max;
+	Knob        defaultvalue;
+};
+
+sequence<string> 		KnobIDList;
+dictionary<string, Knob> 	KnobMap;
+dictionary<string, KnobProp> 	KnobPropMap;
+dictionary<string, string>	WaveformArgMap;
+
+interface StreamReceiver {
+    void 			push(VectorC 	data);
+};
+
+interface ControlPort {
+    void 			set(KnobMap knobs);
+    idempotent  KnobMap 	get(KnobIDList knobs);
+    idempotent  KnobPropMap 	properties(KnobIDList knobs);
+    void 			shutdown();
+};
+
+};
+
+#endif
diff --git a/gnuradio-runtime/lib/controlport/ice_application_base.cc b/gnuradio-runtime/lib/controlport/ice_application_base.cc
new file mode 100644
index 0000000000..b390c77c84
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/ice_application_base.cc
@@ -0,0 +1,43 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/ice_application_base.h>
+
+int ice_application_common::d_reacquire_attributes(0);
+bool ice_application_common::d_main_called(false);
+bool ice_application_common::d_have_ice_config(false);
+boost::shared_ptr<boost::thread> ice_application_common::d_thread;
+std::string ice_application_common::d_endpointStr("");
+
+boost::shared_ptr<ice_application_common>
+ice_application_common::Instance()
+{
+  static boost::shared_ptr<ice_application_common>
+    instance(new ice_application_common());
+  return instance;
+}
+
+int ice_application_common::run(int, char**)
+{
+  communicator()->waitForShutdown();
+  return EXIT_SUCCESS;
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcmanager.cc b/gnuradio-runtime/lib/controlport/rpcmanager.cc
new file mode 100644
index 0000000000..59ec518960
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcmanager.cc
@@ -0,0 +1,72 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/rpcmanager.h>
+#include <iostream>
+#include <stdexcept>
+
+bool rpcmanager::booter_registered(false);
+bool rpcmanager::aggregator_registered(false);
+rpcserver_booter_base* rpcmanager::boot(0);
+std::auto_ptr<rpcserver_booter_aggregator> rpcmanager::aggregator(0);
+
+rpcmanager::rpcmanager() {;}
+
+rpcmanager::~rpcmanager()
+{
+  if(boot)
+    delete boot;
+}
+
+rpcserver_booter_base*
+rpcmanager::get()
+{
+  if(aggregator_registered) {
+    return aggregator.get();
+  } 
+  else if(booter_registered) {
+    return boot;
+  }
+  assert(booter_registered || aggregator_registered);
+  return boot;
+}
+
+void
+rpcmanager::register_booter(rpcserver_booter_base* booter)
+{
+  if(make_aggregator && !aggregator_registered) {
+    aggregator.reset(new rpcserver_booter_aggregator());
+    aggregator_registered = true;
+  }
+
+  if(aggregator_registered) {
+    rpcmanager::rpcserver_booter_base_sptr bootreg(booter);
+    aggregator->agg()->registerServer(bootreg);
+  }
+  else if(!booter_registered) {
+    boot = booter;
+    booter_registered = true;
+  }
+  else {
+    throw std::runtime_error("rpcmanager: Aggregator not in use, and a rpc booter is already registered\n");
+  }
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc b/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc
new file mode 100644
index 0000000000..18b73faeba
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcpmtconverters_ice.cc
@@ -0,0 +1,123 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/rpcpmtconverters_ice.h>
+#include <Ice/Ice.h>
+#include <gnuradio.h>
+
+GNURadio::KnobPtr
+rpcpmtconverter::from_pmt(const pmt::pmt_t& knob, const Ice::Current& c)
+{
+  if(pmt::is_real(knob)) {
+    return new GNURadio::KnobD(Ice::Double(pmt::to_double(knob)));
+  }
+  else if(pmt::is_symbol(knob)) {
+    std::string stuff = pmt::symbol_to_string(knob);
+    return new GNURadio::KnobS(stuff);
+  }
+  else if(pmt::is_integer(knob)) {
+    return new GNURadio::KnobI(pmt::to_long(knob));
+  }
+  else if(pmt::is_bool(knob)) {
+    return new GNURadio::KnobB(pmt::to_bool(knob));
+  }
+  else if(pmt::is_uint64(knob)) {
+    return new GNURadio::KnobL(pmt::to_uint64(knob));
+    //const std::complex<float>  *c32vector_elements(pmt_t v, size_t &len); //< len is in elements
+  }
+  else if(pmt::is_c32vector(knob)) {  // c32 sent as interleaved floats
+    size_t size(pmt::length(knob));
+    const float* start((const float*) pmt::c32vector_elements(knob,size));
+    return new GNURadio::KnobVecF(std::vector<float>(start,start+size*2));
+  } 
+  else if (pmt::is_s32vector(knob)) {
+    size_t size(pmt::length(knob));
+    const int* start((const int*) pmt::s32vector_elements(knob,size));
+    return new GNURadio::KnobVecI(std::vector<int>(start,start+size));
+  }
+  else if(pmt::is_f32vector(knob)) {
+    size_t size(pmt::length(knob));
+    const float* start((const float*) pmt::f32vector_elements(knob,size));
+    return new GNURadio::KnobVecF(std::vector<float>(start,start+size));
+  } 
+  else if (pmt::is_u8vector(knob)) {
+    size_t size(pmt::length(knob));
+    const uint8_t* start((const uint8_t*) pmt::u8vector_elements(knob,size));
+    return new GNURadio::KnobVecC(std::vector<Ice::Byte>(start,start+size));
+  }
+  else {
+    std::cerr << "Error: Don't know how to handle Knob Type (from): " << std::endl; assert(0);}
+  //TODO: VECTORS!!!
+  return new GNURadio::Knob();
+}
+
+pmt::pmt_t
+rpcpmtconverter::to_pmt(const GNURadio::KnobPtr& knob, const Ice::Current& c)
+{
+  std::string id(knob->ice_id(c).substr(12));
+  if(id == "KnobD") {
+    GNURadio::KnobDPtr k(GNURadio::KnobDPtr::dynamicCast(knob));
+    return pmt::mp(k->value);
+  }
+  else if(id == "KnobF") {
+    GNURadio::KnobFPtr k(GNURadio::KnobFPtr::dynamicCast(knob));
+    return pmt::mp(k->value);
+  }
+  else if(id == "KnobI") {
+    GNURadio::KnobIPtr k(GNURadio::KnobIPtr::dynamicCast(knob));
+    return pmt::mp(k->value);
+  }
+  else if(id == "KnobS") {
+    GNURadio::KnobSPtr k(GNURadio::KnobSPtr::dynamicCast(knob));
+    return pmt::string_to_symbol(k->value);
+  }
+  else if(id == "KnobB") {
+    GNURadio::KnobBPtr k(GNURadio::KnobBPtr::dynamicCast(knob));
+    return pmt::mp(k->value);
+  }
+  else if(id == "KnobC") {
+    GNURadio::KnobCPtr k(GNURadio::KnobCPtr::dynamicCast(knob));
+    return pmt::mp(k->value);
+  }
+  else if(id == "KnobL") {
+    GNURadio::KnobLPtr k(GNURadio::KnobLPtr::dynamicCast(knob));
+    return pmt::mp((long)k->value);
+  } 
+  else if(id == "KnobVecC") {
+    GNURadio::KnobVecCPtr k(GNURadio::KnobVecCPtr::dynamicCast(knob));
+    return pmt::init_u8vector(k->value.size(), &k->value[0]);
+  } 
+  else if(id == "KnobVecI") {
+    GNURadio::KnobVecIPtr k(GNURadio::KnobVecIPtr::dynamicCast(knob));
+    return pmt::init_s32vector(k->value.size(), &k->value[0]);
+  }
+  //else if(id == "KnobVecF") {
+  //  GNURadio::KnobVecFPtr k(GNURadio::KnobVecFPtr::dynamicCast(knob));
+  //  return pmt::mp(k->value);
+  //TODO: FLOAT!!!
+  //TODO: VECTORS!!!
+  else {
+    std::cerr << "Error: Don't know how to handle Knob Type: " << id << std::endl; assert(0);
+  }
+
+  return pmt::pmt_t();	
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc b/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc
new file mode 100644
index 0000000000..3ff553af69
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc
@@ -0,0 +1,93 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/rpcserver_aggregator.h>
+#include <gnuradio/rpcserver_booter_base.h>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+
+rpcserver_aggregator::rpcserver_aggregator()
+  : d_type(std::string("aggregator"))
+{;}
+
+rpcserver_aggregator::~rpcserver_aggregator()
+{;}
+
+const std::string&
+rpcserver_aggregator::type()
+{
+  return d_type;
+}
+
+const std::vector<std::string>&
+rpcserver_aggregator::registeredServers()
+{
+  return d_registeredServers;
+}
+
+void
+rpcserver_aggregator::registerConfigureCallback(const std::string &id,
+						const configureCallback_t callback)
+{
+  std::for_each(d_serverlist.begin(), d_serverlist.end(),
+		registerConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, configureCallback_t>(id, callback));
+}
+
+void
+rpcserver_aggregator::unregisterConfigureCallback(const std::string &id)
+{
+  std::for_each(d_serverlist.begin(), d_serverlist.end(),
+		unregisterConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, configureCallback_t>(id));
+}
+
+void
+rpcserver_aggregator::registerQueryCallback(const std::string &id, const queryCallback_t callback)
+{
+  std::for_each(d_serverlist.begin(), d_serverlist.end(),
+		registerQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, queryCallback_t>(id, callback));
+}
+
+void
+rpcserver_aggregator::unregisterQueryCallback(const std::string &id)
+{
+  std::for_each(d_serverlist.begin(), d_serverlist.end(),
+		unregisterQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, queryCallback_t>(id));
+}
+
+void
+rpcserver_aggregator::registerServer(rpcmanager_base::rpcserver_booter_base_sptr server)
+{
+  std::vector<std::string>::iterator it(std::find(d_registeredServers.begin(),
+						  d_registeredServers.end(),
+						  server->type()));
+  if(it != d_registeredServers.end()) {
+    d_serverlist.push_back(server);
+    d_registeredServers.push_back(server->type());
+  }
+  else {
+    std::stringstream s;
+    s << "rpcserver_aggregator::registerServer: server of type "
+      << server->type() << " already registered" << std::endl;
+    throw std::runtime_error(s.str().c_str());
+  }
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc b/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc
new file mode 100644
index 0000000000..e86306910d
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc
@@ -0,0 +1,62 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/rpcserver_booter_aggregator.h>
+
+rpcserver_booter_aggregator::rpcserver_booter_aggregator() :
+  d_type(std::string("aggregator")), server(new rpcserver_aggregator())
+{;}
+ 
+rpcserver_booter_aggregator::~rpcserver_booter_aggregator()
+{;}
+
+rpcserver_base*
+rpcserver_booter_aggregator::i()
+{
+  return &(*server);
+}
+
+const std::string&
+rpcserver_booter_aggregator::type()
+{
+  return d_type;
+}
+
+const std::vector<std::string>
+rpcserver_booter_aggregator::endpoints()
+{
+  std::vector<std::string> ep;
+  ep.push_back(std::string("TODO"));
+  return ep;
+}
+
+const std::vector<std::string>&
+rpcserver_booter_aggregator::registeredServers()
+{
+  return server->registeredServers();
+}
+
+rpcserver_aggregator*
+rpcserver_booter_aggregator::agg()
+{
+  return &(*server);
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcserver_booter_ice.cc b/gnuradio-runtime/lib/controlport/rpcserver_booter_ice.cc
new file mode 100644
index 0000000000..cffa268a6d
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcserver_booter_ice.cc
@@ -0,0 +1,54 @@
+/* -*- c++ -*- */
+/* 
+ * Copyright 2012 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 <gnuradio/rpcserver_ice.h>
+#include <gnuradio/rpcserver_booter_ice.h>
+
+namespace {
+  static const char* const CONTROL_PORT_CLASS("ice");
+  static const char* const CONTROL_PORT_NAME("ControlPort");
+  static const char* const ENDPOINT_NAME("gnuradio");
+};
+
+rpcserver_booter_ice::rpcserver_booter_ice() :
+  ice_server_template<rpcserver_base, rpcserver_ice,
+		      rpcserver_booter_ice, GNURadio::ControlPortPtr>
+  (this, std::string(CONTROL_PORT_NAME), std::string(ENDPOINT_NAME)),
+  d_type(std::string(CONTROL_PORT_CLASS))
+{;}
+
+rpcserver_booter_ice::~rpcserver_booter_ice()
+{;}
+
+rpcserver_base*
+rpcserver_booter_ice::i()
+{
+  return ice_server_template<rpcserver_base, rpcserver_ice,
+			     rpcserver_booter_ice, GNURadio::ControlPortPtr>::i();
+}
+
+const std::vector<std::string>
+rpcserver_booter_ice::endpoints()
+{
+  return ice_server_template<rpcserver_base, rpcserver_ice,
+			     rpcserver_booter_ice, GNURadio::ControlPortPtr>::endpoints();
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcserver_ice.cc b/gnuradio-runtime/lib/controlport/rpcserver_ice.cc
new file mode 100644
index 0000000000..045d7ba4f1
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcserver_ice.cc
@@ -0,0 +1,165 @@
+/* -*- c++ -*- */
+/* 
+ * Copyright 2012 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 <gnuradio/rpcserver_ice.h>
+#include <IceUtil/IceUtil.h>
+#include <Ice/Ice.h>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <pmt/pmt.h>
+
+#define DEBUG 0
+
+using namespace rpcpmtconverter;
+
+rpcserver_ice::rpcserver_ice()
+{}
+
+rpcserver_ice::~rpcserver_ice()
+{}
+
+void
+rpcserver_ice::registerConfigureCallback(const std::string &id,
+					 const configureCallback_t callback)
+{
+  {
+    ConfigureCallbackMap_t::const_iterator iter(d_setcallbackmap.find(id));
+    if(iter != d_setcallbackmap.end()) {
+      std::stringstream s;
+      s << "rpcserver_ice:: rpcserver_ice ERROR registering set, already registered: "
+	<< id << std::endl;
+      throw std::runtime_error(s.str().c_str());
+    }
+  }
+
+  if(DEBUG)
+    std::cout << "rpcserver_ice registering set: " << id << std::endl;
+ 
+  d_setcallbackmap.insert(ConfigureCallbackMap_t::value_type(id, callback));
+}
+
+void
+rpcserver_ice::unregisterConfigureCallback(const std::string &id)
+{
+  ConfigureCallbackMap_t::iterator iter(d_setcallbackmap.find(id));
+  if(iter == d_setcallbackmap.end()) {
+    std::stringstream s;
+    s << "rpcserver_ice:: rpcserver_ice ERROR unregistering set, not registered: "
+      << id << std::endl;
+    throw std::runtime_error(s.str().c_str());
+  }
+
+  if(DEBUG)
+    std::cout << "rpcserver_ice unregistering set: " << id << std::endl;
+
+  d_setcallbackmap.erase(iter);
+}
+
+void
+rpcserver_ice::registerQueryCallback(const std::string &id,
+				     const queryCallback_t callback)
+{
+  {
+    QueryCallbackMap_t::const_iterator iter(d_getcallbackmap.find(id));
+    if(iter != d_getcallbackmap.end()) {
+      std::stringstream s;
+      s << "rpcserver_ice:: rpcserver_ice ERROR registering get, already registered: "
+	<< id << std::endl;
+      throw std::runtime_error(s.str().c_str());
+    }
+  }
+
+  if(DEBUG)
+    std::cout << "rpcserver_ice registering get: " << id << std::endl;
+
+  d_getcallbackmap.insert(QueryCallbackMap_t::value_type(id, callback));
+}
+
+void
+rpcserver_ice::unregisterQueryCallback(const std::string &id)
+{
+  QueryCallbackMap_t::iterator iter(d_getcallbackmap.find(id));
+  if(iter == d_getcallbackmap.end()) {
+    std::stringstream s;
+    s << "rpcserver_ice:: rpcserver_ice ERROR unregistering get,  registered: "
+      << id << std::endl;
+    throw std::runtime_error(s.str().c_str());
+  }
+
+  if(DEBUG)
+    std::cout << "rpcserver_ice unregistering get: " << id << std::endl;
+
+  d_getcallbackmap.erase(iter);
+}
+
+void
+rpcserver_ice::set(const GNURadio::KnobMap& knobs, const Ice::Current& c)
+{
+  std::for_each(knobs.begin(), knobs.end(),
+		set_f<GNURadio::KnobMap::value_type,ConfigureCallbackMap_t>
+		(c, d_setcallbackmap, cur_priv));
+}
+
+GNURadio::KnobMap
+rpcserver_ice::get(const GNURadio::KnobIDList& knobs, const Ice::Current& c)
+{
+  GNURadio::KnobMap outknobs;
+
+  if(knobs.size() == 0) {
+    std::for_each(d_getcallbackmap.begin(), d_getcallbackmap.end(),
+		  get_all_f<QueryCallbackMap_t::value_type, QueryCallbackMap_t, GNURadio::KnobMap>
+		  (c, d_getcallbackmap, cur_priv, outknobs));
+  }
+  else {
+    std::for_each(knobs.begin(), knobs.end(),
+		  get_f<GNURadio::KnobIDList::value_type, QueryCallbackMap_t>
+		  (c, d_getcallbackmap, cur_priv, outknobs));
+  }
+  return outknobs;
+}
+
+GNURadio::KnobPropMap
+rpcserver_ice::properties(const GNURadio::KnobIDList& knobs, const Ice::Current& c)
+{
+  GNURadio::KnobPropMap outknobs;
+
+  if(knobs.size() == 0) {
+    std::for_each(d_getcallbackmap.begin(), d_getcallbackmap.end(),
+		  properties_all_f<QueryCallbackMap_t::value_type,
+		  QueryCallbackMap_t,GNURadio::KnobPropMap>(c, d_getcallbackmap, cur_priv, outknobs));
+  }
+  else {
+    std::for_each(knobs.begin(), knobs.end(),
+		  properties_f<GNURadio::KnobIDList::value_type,
+		  QueryCallbackMap_t, GNURadio::KnobPropMap>(c, d_getcallbackmap, cur_priv, outknobs));
+  }
+  return outknobs;
+}
+
+void
+rpcserver_ice::shutdown(const Ice::Current& c)
+{
+  if(DEBUG)
+    std::cout << "Shutting down..." << std::endl;
+  c.adapter->getCommunicator()->shutdown();
+}
diff --git a/gnuradio-runtime/lib/controlport/rpcserver_selector.cc b/gnuradio-runtime/lib/controlport/rpcserver_selector.cc
new file mode 100644
index 0000000000..697ec497b1
--- /dev/null
+++ b/gnuradio-runtime/lib/controlport/rpcserver_selector.cc
@@ -0,0 +1,40 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2012 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 <gnuradio/rpcserver_booter_aggregator.h>
+#include <gnuradio/rpcmanager.h>
+#include <gnuradio/rpcserver_selector.h>
+
+bool rpcmanager::make_aggregator(false);
+
+#ifdef RPCSERVER_ICE
+  #include <gnuradio/rpcserver_booter_ice.h>
+  rpcmanager::rpcserver_booter_register_helper<rpcserver_booter_ice> boot_ice;
+#endif
+
+#ifdef RPCSERVER_ERLANG
+  #error TODO ERLANG
+#endif
+
+#ifdef RPCSERVER_XMLRPC
+  #error TODO XMLRPC 
+#endif
author	Tom Rondeau <trondeau@vt.edu>	2013-04-17 13:43:52 -0400
committer	Tom Rondeau <trondeau@vt.edu>	2013-04-29 14:52:56 -0400
commit	f3e2e07201c50033bf6c9d0c6a6f068557b4f17f (patch)
tree	140b3c2d20a951ffd4abd564c3378ee2e2f9fc7c /gnuradio-runtime/lib/controlport
parent	35303ae975a5b1bdecc2492bc96e2b8e89b62a3d (diff)