uhd: replaced templated ranges with one range thing using doubles only to avoid trouble with compiler portability

5 files changed, 25 insertions, 226 deletions

diff --git a/host/include/uhd/config.hpp b/host/include/uhd/config.hpp
index 62c2504e1..f7ccb62e5 100644
--- a/host/include/uhd/config.hpp
+++ b/host/include/uhd/config.hpp
@@ -89,14 +89,4 @@ typedef ptrdiff_t ssize_t;
     #define UHD_PLATFORM_BSD
 #endif
 
-//On macos platform, explicit templates must be:
-// - defined with extern in the header file
-// - defined as a symbol in the source file
-#if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
-    #define UHD_EXIM_TMPL extern
-    #define UHD_USE_EXIM_TMPL
-#else
-    #define UHD_EXIM_TMPL
-#endif
-
 #endif /* INCLUDED_UHD_CONFIG_HPP */
diff --git a/host/include/uhd/types/CMakeLists.txt b/host/include/uhd/types/CMakeLists.txt
index 1d2c0c41c..a96976b5e 100644
--- a/host/include/uhd/types/CMakeLists.txt
+++ b/host/include/uhd/types/CMakeLists.txt
@@ -25,7 +25,6 @@ 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/ranges.hpp b/host/include/uhd/types/ranges.hpp
index 366efb1f3..5bb74f976 100644
--- a/host/include/uhd/types/ranges.hpp
+++ b/host/include/uhd/types/ranges.hpp
@@ -30,14 +30,15 @@ namespace uhd{
      * 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
      */
-    template <typename T> class range_t{
+    class UHD_API 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));
+        range_t(double value = 0);
 
         /*!
          * Create a range from a full set of values.
@@ -46,28 +47,27 @@ namespace uhd{
          * \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));
+        range_t(double start, double stop, double step = 0);
 
         //! Get the start value for this range.
-        const T start(void) const;
+        double start(void) const;
 
         //! Get the stop value for this range.
-        const T stop(void) const;
+        double stop(void) const;
 
         //! Get the step value for this range.
-        const T step(void) const;
+        double step(void) const;
 
         //! Convert this range to a printable string
         const std::string to_pp_string(void) const;
 
-    private: 
-        UHD_PIMPL_DECL(impl) _impl;
+    private: UHD_PIMPL_DECL(impl) _impl;
     };
 
     /*!
      * A meta-range object holds a list of individual ranges.
      */
-    template <typename T> struct meta_range_t : std::vector<range_t<T> >{
+    struct UHD_API meta_range_t : std::vector<range_t>{
 
         //! A default constructor for an empty meta-range
         meta_range_t(void);
@@ -79,7 +79,8 @@ namespace uhd{
          * \param last the end iterator
          */
         template <typename InputIterator>
-        meta_range_t(InputIterator first, InputIterator last);
+        meta_range_t(InputIterator first, InputIterator last):
+            std::vector<range_t>(first, last){ /* NOP */ }
 
         /*!
          * A convenience constructor for a single range.
@@ -88,16 +89,16 @@ namespace uhd{
          * \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));
+        meta_range_t(double start, double stop, double step = 0);
 
         //! Get the overall start value for this meta-range.
-        const T start(void) const;
+        double start(void) const;
 
         //! Get the overall stop value for this meta-range.
-        const T stop(void) const;
+        double stop(void) const;
 
         //! Get the overall step value for this meta-range.
-        const T step(void) const;
+        double step(void) const;
 
         /*!
          * Clip the target value to a possible range value.
@@ -105,22 +106,16 @@ namespace uhd{
          * \param clip_step if true, clip to steps as well
          * \return a value that is in one of the ranges
          */
-         const T clip(const T &value, bool clip_step = false) const;
+        double clip(double value, bool clip_step = false) const;
 
         //! Convert this meta-range to a printable string
         const std::string to_pp_string(void) const;
 
     };
 
-    //!typedef for a gain meta-range
-    typedef meta_range_t<float> gain_range_t;
-
-    //!typedef for a frequency meta-range
-    typedef meta_range_t<double> freq_range_t;
-
+    typedef meta_range_t gain_range_t;
+    typedef meta_range_t 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
deleted file mode 100644
index 944ada51f..000000000
--- a/host/include/uhd/types/ranges.ipp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// 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 <boost/foreach.hpp>
-#include <algorithm>
-#include <stdexcept>
-#include <sstream>
-
-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;
-    }
-
-    template <typename T> const std::string range_t<T>::to_pp_string(void) const{
-        std::stringstream ss;
-        ss << "(" << this->start();
-        if (this->start() != this->stop()) ss << ", " << this->stop();
-        if (this->step() != T(0)) ss << ", " << this->step();
-        ss << ")";
-        return ss.str();
-    }
-
-    /*******************************************************************
-     * meta_range_t implementation code
-     ******************************************************************/
-
-    namespace /*anon*/{
-        template <typename T> inline
-        void check_meta_range_monotonic(const meta_range_t<T> &mr){
-            if (mr.empty()){
-                throw std::runtime_error("meta-range cannot be empty");
-            }
-            for (size_t i = 1; i < mr.size(); i++){
-                if (mr.at(i).start() < mr.at(i-1).stop()){
-                    throw std::runtime_error("meta-range is not monotonic");
-                }
-            }
-        }
-    } //namespace /*anon*/
-
-
-    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{
-        check_meta_range_monotonic(*this);
-        T min_start = this->front().start();
-        BOOST_FOREACH(const range_t<T> &r, (*this)){
-            min_start = std::min(min_start, r.start());
-        }
-        return min_start;
-    }
-
-    template <typename T> const T meta_range_t<T>::stop(void) const{
-        check_meta_range_monotonic(*this);
-        T max_stop = this->front().stop();
-        BOOST_FOREACH(const range_t<T> &r, (*this)){
-            max_stop = std::max(max_stop, r.stop());
-        }
-        return max_stop;
-    }
-
-    template <typename T> const T meta_range_t<T>::step(void) const{
-        check_meta_range_monotonic(*this);
-        std::vector<T> non_zero_steps;
-        range_t<T> last = this->front();
-        BOOST_FOREACH(const range_t<T> &r, (*this)){
-            //steps at each range
-            if (r.step() > T(0)) non_zero_steps.push_back(r.step());
-            //and steps in-between ranges
-            T ibtw_step = r.start() - last.stop();
-            if (ibtw_step > T(0)) non_zero_steps.push_back(ibtw_step);
-            //store ref to last
-            last = r;
-        }
-        if (non_zero_steps.empty()) return T(0); //all zero steps, its zero...
-        return *std::min_element(non_zero_steps.begin(), non_zero_steps.end());
-    }
-
-    template <typename T> const T meta_range_t<T>::clip(
-        const T &value, bool clip_step
-    ) const{
-        check_meta_range_monotonic(*this);
-        T last_stop = this->front().stop();
-        BOOST_FOREACH(const range_t<T> &r, (*this)){
-            //in-between ranges, clip to nearest
-            if (value < r.start()){
-                return (std::abs(value - r.start()) < std::abs(value - last_stop))?
-                    r.start() : last_stop;
-            }
-            //in this range, clip here
-            if (value <= r.stop()){
-                if (not clip_step or r.step() == T(0)) return value;
-                return boost::math::round((value - r.start())/r.step())*r.step() + r.start();
-            }
-            //continue on to the next range
-            last_stop = r.stop();
-        }
-        return last_stop;
-    }
-
-    template <typename T> const std::string meta_range_t<T>::to_pp_string(void) const{
-        std::stringstream ss;
-        BOOST_FOREACH(const range_t<T> &r, (*this)){
-            ss << r.to_pp_string() << std::endl;
-        }
-        return ss.str();
-    }
-
-    UHD_EXIM_TMPL template struct UHD_API meta_range_t<float>;
-    UHD_EXIM_TMPL template struct UHD_API meta_range_t<double>;
-
-} //namespace uhd
-
-#endif /* INCLUDED_UHD_TYPES_RANGES_IPP */
diff --git a/host/include/uhd/utils/gain_group.hpp b/host/include/uhd/utils/gain_group.hpp
index c863248ce..c4115f224 100644
--- a/host/include/uhd/utils/gain_group.hpp
+++ b/host/include/uhd/utils/gain_group.hpp
@@ -28,13 +28,16 @@
 
 namespace uhd{
 
+//! the data type that represents a gain
+typedef double gain_t;
+
 /*!
  * A set of function to control a gain element.
  */
 struct UHD_API gain_fcns_t{
     boost::function<gain_range_t(void)> get_range;
-    boost::function<float(void)>        get_value;
-    boost::function<void(float)>        set_value;
+    boost::function<gain_t(void)>        get_value;
+    boost::function<void(gain_t)>        set_value;
 };
 
 class UHD_API gain_group : boost::noncopyable{
@@ -56,7 +59,7 @@ public:
      * \param name name of the gain element (optional)
      * \return a gain value of the element or all elements
      */
-    virtual float get_value(const std::string &name = "") = 0;
+    virtual gain_t get_value(const std::string &name = "") = 0;
 
     /*!
      * Set the gain value for the gain element specified by name.
@@ -66,7 +69,7 @@ public:
      * \param gain the gain to set for the lement or across the group
      * \param name name of the gain element (optional)
      */
-    virtual void set_value(float gain, const std::string &name = "") = 0;
+    virtual void set_value(gain_t gain, const std::string &name = "") = 0;
 
     /*!
      * Get a list of names of registered gain elements.