From 4d6ae6a8d39e97a7dba53dfd4150ba93ddb470fa Mon Sep 17 00:00:00 2001
From: Josh Blum <josh@joshknows.com>
Date: Fri, 11 Feb 2011 12:35:48 -0800
Subject: 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.
---
 host/include/uhd/types/ref_vector.hpp | 40 ++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 8 deletions(-)

(limited to 'host/include')

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;
 };
 
-- 
cgit v1.2.3