Added gain handler class to manage wildcard gain settings.

Gets overall gains and sets overall gains when used.
Wild card gain will be a gain with an empty string name.

4 files changed, 142 insertions, 6 deletions

diff --git a/include/usrp_uhd/Makefile.am b/include/usrp_uhd/Makefile.am
index fdb881498..0a19bfe56 100644
--- a/include/usrp_uhd/Makefile.am
+++ b/include/usrp_uhd/Makefile.am
@@ -10,6 +10,7 @@ this_includedir = $(includedir)/usrp_uhd
 this_include_HEADERS = \
 	device.hpp \
 	device_addr.hpp \
+	gain_handler.hpp \
 	props.hpp \
 	utils.hpp \
 	wax.hpp
diff --git a/include/usrp_uhd/gain_handler.hpp b/include/usrp_uhd/gain_handler.hpp
new file mode 100644
index 000000000..c2f3d0884
--- /dev/null
+++ b/include/usrp_uhd/gain_handler.hpp
@@ -0,0 +1,88 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+
+#include <boost/shared_ptr.hpp>
+#include <usrp_uhd/wax.hpp>
+#include <usrp_uhd/props.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+#ifndef INCLUDED_USRP_UHD_GAIN_HANDLER_HPP
+#define INCLUDED_USRP_UHD_GAIN_HANDLER_HPP
+
+namespace usrp_uhd{
+
+class gain_handler{
+public:
+    typedef boost::shared_ptr<gain_handler> sptr;
+
+    template <class T> gain_handler(
+        wax::obj::ptr wax_obj_ptr, const T &gain_prop,
+        const T &gain_min_prop, const T &gain_max_prop,
+        const T &gain_step_prop, const T &gain_names_prop
+    ){
+        _wax_obj_ptr = wax_obj_ptr;
+        _gain_prop = gain_prop;
+        _gain_min_prop = gain_min_prop;
+        _gain_max_prop = gain_max_prop;
+        _gain_step_prop = gain_step_prop;
+        _gain_names_prop = gain_names_prop;
+        _is_equal = boost::bind(&gain_handler::is_equal<T>, _1, _2);
+    }
+
+    ~gain_handler(void);
+
+    /*!
+     * Intercept gets for overall gain, min, max, step.
+     * Ensures that the gain name is valid.
+     * \return true for handled, false to pass on
+     */
+    bool intercept_get(const wax::type &key, wax::type &val);
+
+    /*!
+     * Intercept sets for overall gain.
+     * Ensures that the gain name is valid.
+     * Ensures that the new gain is within range.
+     * \return true for handled, false to pass on
+     */
+    bool intercept_set(const wax::type &key, const wax::type &val);
+
+private:
+
+    wax::obj::ptr  _wax_obj_ptr;
+    wax::type      _gain_prop;
+    wax::type      _gain_min_prop;
+    wax::type      _gain_max_prop;
+    wax::type      _gain_step_prop;
+    wax::type      _gain_names_prop;
+
+    /*!
+     * Verify that the key is valid:
+     * If its a named prop for gain, ensure that name is valid.
+     * If the name if not valid, throw a std::invalid_argument.
+     * The name can only be valid if its in the list of gain names.
+     */
+    void _check_key(const wax::type &key);
+
+    /*
+     * Private interface to test if two wax types are equal:
+     * The constructor will bind an instance of this for a specific type.
+     * This bound equals functions allows the intercept methods to be non-templated.
+     */
+    template <class T> static bool is_equal(const wax::type &a, const wax::type &b){
+        try{
+            return wax::cast<T>(a) == wax::cast<T>(b);
+        }
+        catch(const wax::bad_cast &){
+            return false;
+        }
+    }
+    boost::function<bool(const wax::type &, const wax::type &)> _is_equal;
+
+};
+
+} //namespace usrp_uhd
+
+#endif /* INCLUDED_USRP_UHD_GAIN_HANDLER_HPP */
+
diff --git a/include/usrp_uhd/props.hpp b/include/usrp_uhd/props.hpp
index 426554a53..b74493961 100644
--- a/include/usrp_uhd/props.hpp
+++ b/include/usrp_uhd/props.hpp
@@ -62,6 +62,18 @@ namespace usrp_uhd{
     typedef boost::tuple<wax::type, std::string> named_prop_t;
 
     /*!
+     * Utility function to separate a named property into its components.
+     * \param key a reference to the prop object
+     * \param name a reference to the name object
+     */
+    inline named_prop_t extract_named_prop(const wax::type &key, const std::string &name = ""){
+        if (key.type() == typeid(named_prop_t)){
+            return wax::cast<named_prop_t>(key);
+        }
+        return named_prop_t(key, name);
+    }
+
+    /*!
     * Possible device properties:
     *   In general, a device will have a single mboard.
     *   In certain mimo applications, multiple boards
diff --git a/include/usrp_uhd/utils.hpp b/include/usrp_uhd/utils.hpp
index a45473ab4..c1b2bad5c 100644
--- a/include/usrp_uhd/utils.hpp
+++ b/include/usrp_uhd/utils.hpp
@@ -3,15 +3,19 @@
 //
 
 #include <boost/foreach.hpp>
-#include <map>
+#include <boost/format.hpp>
+#include <boost/function.hpp>
+#include <stdexcept>
+#include <algorithm>
 #include <vector>
+#include <map>
 
 #ifndef INCLUDED_USRP_UHD_UTILS_HPP
 #define INCLUDED_USRP_UHD_UTILS_HPP
 
 namespace usrp_uhd{
 
-template <class Key, class T>
+template <class Key, class T> //TODO template this better
 std::vector<Key> get_map_keys(const std::map<Key, T> &m){
     std::vector<Key> v;
     std::pair<Key, T> p;
@@ -21,12 +25,43 @@ std::vector<Key> get_map_keys(const std::map<Key, T> &m){
     return v;
 }
 
-//TODO implement a set and get gains that takes a wx obj ptr, and gain properties
+} //namespace usrp_uhd
+
+/*!
+ * Useful templated functions and classes that I like to pretend are part of stl
+ */
+namespace std{
 
-//TODO check name in vector of names
+    class assert_error : public std::logic_error{
+    public:
+        explicit assert_error(const string& what_arg) : logic_error(what_arg){
+            /* NOP */
+        }
+    };
 
-//TODO optionally extract a name from the named_prop_t
+    #define ASSERT_THROW(_x) if (not (_x)) { \
+        throw std::assert_error("Assertion Failed: " + std::string(#_x)); \
+    }
 
-} //namespace usrp_uhd
+    template<class T, class InputIterator, class Function>
+    T reduce(InputIterator first, InputIterator last, Function fcn, T init = 0){
+        T tmp = init;
+        for ( ; first != last; ++first ){
+            tmp = fcn(tmp, *first);
+        }
+        return tmp;
+    }
+
+    template<class T, class InputIterator>
+    bool has(InputIterator first, InputIterator last, const T &elem){
+        return last != std::find(first, last, elem);
+    }
+
+    template <class T>
+    T sum(const T &a, const T &b){
+        return a + b;
+    }
+
+}//namespace std
 
 #endif /* INCLUDED_USRP_UHD_UTILS_HPP */