Added operator() and toSlice to SortedArrayView.

Author: corbett5

src/SortedArray.hpp

@@ -168,6 +168,8 @@ class SortedArray : protected SortedArrayView< T, INDEX_TYPE, BUFFER_TYPE >
     return ParentClass::toViewConst();
   }
 
+  using ParentClass::toSlice;
+
   ///@}
 
   /**
@@ -198,6 +200,7 @@ class SortedArray : protected SortedArrayView< T, INDEX_TYPE, BUFFER_TYPE >
   ///@{
 
   using ParentClass::operator[];
+  using ParentClass::operator();
 
   /**
    * @copydoc SortedArrayView::data

src/SortedArrayView.hpp

@@ -13,6 +13,7 @@
 #pragma once
 
 // Source includes
+#include "ArraySlice.hpp"
 #include "bufferManipulation.hpp"
 #include "sortedArrayManipulation.hpp"
 
@@ -129,7 +130,7 @@ class SortedArrayView
   ///@}
 
   /**
-   * @name SortedArrayView creation methods
+   * @name SortedArrayView and ArraySlice creation methods
    */
   ///@{
 
@@ -149,6 +150,27 @@ class SortedArrayView
   toViewConst() const
   { return toView(); }
 
+  /**
+   * @return Return an ArraySlice representing this SortedArrayView.
+   */
+  LVARRAY_HOST_DEVICE constexpr inline
+  ArraySlice< T const, 1, 0, INDEX_TYPE > toSlice() const &
+  { return ArraySlice< T const, 1, 0, INDEX_TYPE >( data(), &m_size, nullptr ); }
+
+  /**
+   * @brief Overload for rvalues that raises a compilation error when used.
+   * @return A null ArraySlice.
+   * @note This cannot be called on a rvalue since the @c ArraySlice would
+   *   contain pointers to the size of the current @c SortedArrayView that is
+   *   about to be destroyed. This overload prevents that from happening.
+   */
+  LVARRAY_HOST_DEVICE constexpr inline
+  ArraySlice< T const, 1, 0, INDEX_TYPE > toSlice() const &&
+  {
+    static_assert( typeManipulation::always_true< T >, "Cannot call toSlice on an rvalue." );
+    return ArraySlice< T const, 1, 0, INDEX_TYPE >( nullptr, nullptr, nullptr );
+  }
+
   ///@}
 
   /**
@@ -205,6 +227,17 @@ class SortedArrayView
     return data()[ i ];
   }
 
+  /**
+   * @return Return the value at position @p i .
+   * @param i the index of the value to access.
+   */
+  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
+  T const & operator()( INDEX_TYPE const i ) const
+  {
+    SORTEDARRAY_CHECK_BOUNDS( i );
+    return data()[ i ];
+  }
+
   /**
    * @return Return a pointer to the values.
    */

unitTests/testSortedArray.cpp

@@ -39,22 +39,34 @@ class SortedArrayTest : public ::testing::Test
    */
   void compareToReference() const
   {
-    ASSERT_EQ( m_set.size(), m_ref.size() );
-    ASSERT_EQ( m_set.empty(), m_ref.empty() );
+    EXPECT_EQ( m_set.size(), m_ref.size() );
+    EXPECT_EQ( m_set.empty(), m_ref.empty() );
     if( m_set.empty() )
     {
-      ASSERT_EQ( m_set.size(), 0 );
+      EXPECT_EQ( m_set.size(), 0 );
       return;
     }
 
     T const * ptr = m_set.data();
+    ArraySlice< T const, 1, 0, INDEX_TYPE > const slice = m_set.toSlice();
     typename std::set< T >::const_iterator it = m_ref.begin();
     for( int i = 0; i < m_set.size(); ++i )
     {
-      ASSERT_EQ( m_set[ i ], *it );
-      ASSERT_EQ( ptr[ i ], *it );
+      EXPECT_EQ( m_set[ i ], *it );
+      EXPECT_EQ( m_set( i ), *it );
+      EXPECT_EQ( ptr[ i ], *it );
+      EXPECT_EQ( slice[ i ], *it );
       ++it;
     }
+
+    it = m_ref.begin();
+    for( T const & val : m_set )
+    {
+      EXPECT_EQ( val, *it );
+      ++it;
+    }
+
+    EXPECT_EQ( it, m_ref.end() );
   }
 
   #define COMPARE_TO_REFERENCE { SCOPED_TRACE( "" ); compareToReference(); \