uhd: third iteration of the reference vector

Hope we get it right this time.
Reference vector now has its own pointer for the pointer/size 1 constuction case.
In this case, the memory is initialized to the value of its own pointer.
The previous two iterations were functionally wrong because it takes two pointers and size to accomplish this.

1 files changed, 32 insertions, 8 deletions

diff --git a/host/include/uhd/types/ref_vector.hpp b/host/include/uhd/types/ref_vector.hpp
index efd4b8f89..0ae301647 100644
--- a/host/include/uhd/types/ref_vector.hpp
+++ b/host/include/uhd/types/ref_vector.hpp
@@ -29,30 +29,54 @@ namespace uhd{
  */
 template <typename T> class ref_vector{
 public:
-    //! Create a reference vector from a pointer and size
-    template <typename Ptr> ref_vector(Ptr *ptr, size_t size = 1):
-        _mem(T(ptr)), _size(size)
+    /*!
+     * Create a reference vector of size 1 from a pointer.
+     * Therefore: rv[0] == ptr and rv.size() == 1
+     * \param ptr a pointer to a chunk of memory
+     */
+    template <typename Ptr> ref_vector(Ptr *ptr):
+        _ptr(T(ptr)), _mem(_mem_t(&_ptr)), _size(1)
     {
         /* NOP */
     }
 
-    //! Create a reference vector from a std::vector container
-    template <typename Range> ref_vector(const Range &range):
-        _mem(T(range.front())), _size(range.size())
+    /*!
+     * Create a reference vector from a std::vector container.
+     * Therefore: rv[n] == vec[n] and rv.size() == vec.size()
+     * \param range a const reference to an std::vector
+     */
+    template <typename Vector> ref_vector(const Vector &vec):
+        _ptr(T()), _mem(_mem_t(&vec.front())), _size(vec.size())
     {
         /* NOP */
     }
 
+    /*!
+     * Create a reference vector from a pointer and a length
+     * Therefore: rv[n] == mem[n] and rv.size() == len
+     * \param mem a pointer to an array of pointers
+     * \param len the length of the array of pointers
+     */
+    ref_vector(const T *mem, size_t len):
+        _ptr(T()), _mem(_mem_t(mem)), _size(len)
+    {
+        /* NOP */
+    }
+
+    //! Index operator gets the value of rv[index]
     const T &operator[](size_t index) const{
-        return (&_mem)[index];
+        return _mem[index];
     }
 
+    //! The number of elements in this container
     size_t size(void) const{
         return _size;
     }
 
 private:
-    const T      _mem;
+    const T      _ptr;
+    typedef T*   _mem_t;
+    const _mem_t _mem;
     const size_t _size;
 };