uhd: created a meta range that is a range of ranges for gains and freqs

created a templated range that that holds a start, stop, and step

created a meta-range template that is a vector of ranges
meta-range can calculate the overall start, stop, step
or be indexed to get at components

replaced instances of range.min, max, step with the functions
start() stop() and step()

the xcvr frequency range is now expressed in as two ranges
(have to fix its clip function though)

5 files changed, 211 insertions, 18 deletions

diff --git a/host/include/uhd/types/CMakeLists.txt b/host/include/uhd/types/CMakeLists.txt
index a96976b5e..1d2c0c41c 100644
--- a/host/include/uhd/types/CMakeLists.txt
+++ b/host/include/uhd/types/CMakeLists.txt
@@ -25,6 +25,7 @@ INSTALL(FILES
     mac_addr.hpp
     metadata.hpp
     otw_type.hpp
+    ranges.ipp
     ranges.hpp
     serial.hpp
     stream_cmd.hpp
diff --git a/host/include/uhd/types/dict.ipp b/host/include/uhd/types/dict.ipp
index ba05d5272..f037d7988 100644
--- a/host/include/uhd/types/dict.ipp
+++ b/host/include/uhd/types/dict.ipp
@@ -46,12 +46,11 @@ namespace uhd{
         /* NOP */
     }
 
-    template <typename Key, typename Val>
-    template <typename InputIterator>
-    dict<Key, Val>::dict(InputIterator first, InputIterator last){
-        for(InputIterator it = first; it != last; it++){
-            _map.push_back(*it);
-        }
+    template <typename Key, typename Val> template <typename InputIterator>
+    dict<Key, Val>::dict(InputIterator first, InputIterator last):
+        _map(first, last)
+    {
+        /* NOP */
     }
 
     template <typename Key, typename Val>
diff --git a/host/include/uhd/types/ranges.hpp b/host/include/uhd/types/ranges.hpp
index a2057d1c8..0811fc4c8 100644
--- a/host/include/uhd/types/ranges.hpp
+++ b/host/include/uhd/types/ranges.hpp
@@ -19,28 +19,87 @@
 #define INCLUDED_UHD_TYPES_RANGES_HPP
 
 #include <uhd/config.hpp>
+#include <uhd/utils/pimpl.hpp>
+#include <vector>
 
 namespace uhd{
 
     /*!
-     * The gain range struct describes possible gain settings.
-     * The mimumum gain, maximum gain, and step size are in dB.
+     * A range object describes a set of discrete values of the form:
+     * y = start + step*n, where n is an integer between 0 and (stop - start)/step
      */
-    struct UHD_API gain_range_t{
-        float min, max, step;
-        gain_range_t(float min = 0.0, float max = 0.0, float step = 0.0);
+    template <typename T> class range_t{
+    public:
+        /*!
+         * Create a range from a single value.
+         * The step size will be taken as zero.
+         * \param value the only possible value in this range
+         */
+        range_t(const T &value = T(0));
+
+        /*!
+         * Create a range from a full set of values.
+         * A step size of zero implies infinite precision.
+         * \param start the minimum value for this range
+         * \param stop the maximum value for this range
+         * \param step the step size for this range
+         */
+        range_t(const T &start, const T &stop, const T &step = T(0));
+
+        //! Get the start value for this range.
+        const T start(void) const;
+
+        //! Get the stop value for this range.
+        const T stop(void) const;
+
+        //! Get the step value for this range.
+        const T step(void) const;
+
+    private: UHD_PIMPL_DECL(impl) _impl;
     };
 
     /*!
-     * The frequency range struct describes possible frequency settings.
-     * Because tuning is very granular (sub-Hz), step size is not listed.
-     * The mimumum frequency and maximum frequency are in Hz.
+     * A meta-range object holds a list of individual ranges.
      */
-    struct UHD_API freq_range_t{
-        double min, max;
-        freq_range_t(double min = 0.0, double max = 0.0);
+    template <typename T> struct meta_range_t : std::vector<range_t<T> >{
+
+        //! A default constructor for an empty meta-range
+        meta_range_t(void);
+
+        /*!
+         * Input iterator constructor:
+         * Makes boost::assign::list_of work.
+         * \param first the begin iterator
+         * \param last the end iterator
+         */
+        template <typename InputIterator>
+        meta_range_t(InputIterator first, InputIterator last);
+
+        /*!
+         * A convenience constructor for a single range.
+         * A step size of zero implies infinite precision.
+         * \param start the minimum value for this range
+         * \param stop the maximum value for this range
+         * \param step the step size for this range
+         */
+        meta_range_t(const T &start, const T &stop, const T &step = T(0));
+
+        //! Get the overall start value for this meta-range.
+        const T start(void) const;
+
+        //! Get the overall stop value for this meta-range.
+        const T stop(void) const;
+
+        //! Get the overall step value for this meta-range.
+        const T step(void) const;
+
     };
 
+    typedef meta_range_t<float> gain_range_t;
+    typedef meta_range_t<double> freq_range_t;
+
 } //namespace uhd
 
+#include <uhd/types/ranges.ipp>
+
 #endif /* INCLUDED_UHD_TYPES_RANGES_HPP */
diff --git a/host/include/uhd/types/ranges.ipp b/host/include/uhd/types/ranges.ipp
new file mode 100644
index 000000000..cb1628c53
--- /dev/null
+++ b/host/include/uhd/types/ranges.ipp
@@ -0,0 +1,134 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program 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 of the License, or
+// (at your option) any later version.
+//
+// This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_TYPES_RANGES_IPP
+#define INCLUDED_UHD_TYPES_RANGES_IPP
+
+#include <boost/math/special_functions/round.hpp>
+#include <algorithm>
+#include <stdexcept>
+#include <iostream>
+
+namespace uhd{
+
+    /*******************************************************************
+     * range_t implementation code
+     ******************************************************************/
+    template <typename T> struct range_t<T>::impl{
+        impl(const T &start, const T &stop, const T &step):
+            start(start), stop(stop), step(step)
+        {
+            /* NOP */
+        }
+        const T start, stop, step;
+    };
+
+    template <typename T> range_t<T>::range_t(const T &value):
+        _impl(UHD_PIMPL_MAKE(impl, (value, value, T(0))))
+    {
+        /* NOP */
+    }
+
+    template <typename T> range_t<T>::range_t(
+        const T &start, const T &stop, const T &step
+    ):
+        _impl(UHD_PIMPL_MAKE(impl, (start, stop, step)))
+    {
+        if (stop < start){
+            throw std::invalid_argument("cannot make range where stop < start");
+        }
+    }
+
+    template <typename T> const T range_t<T>::start(void) const{
+        return _impl->start;
+    }
+
+    template <typename T> const T range_t<T>::stop(void) const{
+        return _impl->stop;
+    }
+
+    template <typename T> const T range_t<T>::step(void) const{
+        return _impl->step;
+    }
+
+    /*******************************************************************
+     * meta_range_t implementation code
+     ******************************************************************/
+
+    template <typename T> meta_range_t<T>::meta_range_t(void){
+        /* NOP */
+    }
+
+    template <typename T> template <typename InputIterator>
+    meta_range_t<T>::meta_range_t(
+        InputIterator first, InputIterator last
+    ):
+        std::vector<range_t<T> >(first, last)
+    {
+        /* NOP */
+    }
+
+    template <typename T> meta_range_t<T>::meta_range_t(
+        const T &start, const T &stop, const T &step
+    ):
+        std::vector<range_t<T> > (1, range_t<T>(start, stop, step))
+    {
+        /* NOP */
+    }
+
+    template <typename T> const T meta_range_t<T>::start(void) const{
+        if (this->empty()){
+            throw std::runtime_error("cannot calculate overall start on empty meta-range");
+        }
+        T min_start = this->at(0).start();
+        for (size_t i = 1; i < this->size(); i++){
+            min_start = std::min(min_start, this->at(i).start());
+        }
+        return min_start;
+    }
+
+    template <typename T> const T meta_range_t<T>::stop(void) const{
+        if (this->empty()){
+            throw std::runtime_error("cannot calculate overall stop on empty meta-range");
+        }
+        T max_stop = this->at(0).stop();
+        for (size_t i = 1; i < this->size(); i++){
+            max_stop = std::max(max_stop, this->at(i).stop());
+        }
+        return max_stop;
+    }
+
+    template <typename T> const T meta_range_t<T>::step(void) const{
+        if (this->empty()){
+            throw std::runtime_error("cannot calculate overall step on empty meta-range");
+        }
+        T min_step  = this->at(0).step();
+        for (size_t i = 1; i < this->size(); i++){
+            if (this->at(i).start() < this->at(i-1).stop()){
+                throw std::runtime_error("cannot calculate overall range when start(n) < stop(n-1) ");
+            }
+            if (this->at(i).start() != this->at(i).stop()){
+                min_step = std::min(min_step, this->at(i).step());
+            }
+            min_step = std::min(min_step, this->at(i).start() - this->at(i-1).stop());
+        }
+        return min_step;
+    }
+
+} //namespace uhd
+
+#endif /* INCLUDED_UHD_TYPES_RANGES_IPP */
diff --git a/host/include/uhd/usrp/mimo_usrp.hpp b/host/include/uhd/usrp/mimo_usrp.hpp
index a2092f04f..977559b0b 100644
--- a/host/include/uhd/usrp/mimo_usrp.hpp
+++ b/host/include/uhd/usrp/mimo_usrp.hpp
@@ -200,7 +200,7 @@ namespace uhd{ namespace usrp{ namespace /*anon*/{
 
 static inline freq_range_t add_dsp_shift(const freq_range_t &range, wax::obj dsp){
     double codec_rate = dsp[DSP_PROP_CODEC_RATE].as<double>();
-    return freq_range_t(range.min - codec_rate/2.0, range.max + codec_rate/2.0);
+    return freq_range_t(range.start() - codec_rate/2.0, range.stop() + codec_rate/2.0);
 }
 
 /***********************************************************************