feat: add stdArray bounds checking (#3873)

Author: arng40

src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp

@@ -70,7 +70,7 @@ TEST( testGeosxTraits, HasMemberFunction_insert )
   static_assert( HasMemberFunction_insert< std::list< stdVector< int > > >, "Should be true." );
 
   static_assert( !HasMemberFunction_insert< int >, "Should be false." );
-  static_assert( !HasMemberFunction_insert< std::array< int, 5 > >, "Should be false." );
+  static_assert( !HasMemberFunction_insert< stdArray< int, 5 > >, "Should be false." );
 }
 
 

src/coreComponents/common/StdContainerWrappers.hpp

@@ -1,6 +1,8 @@
 #ifndef GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP
 #define GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP
 
+#include <array>
+#include <cstddef>
 #include <vector>
 #include <map>
 #include <unordered_map>
@@ -346,6 +348,118 @@ class mapBase< TKEY, TVAL, std::integral_constant< bool, false > > : public std:
 };
 /// @endcond
 
+namespace internal
+{
+
+/**
+ * Wrapper for the underlying std::aray that allows toggling between bounds-checked access
+ * (using at()) and unchecked access (using operator[]).
+ * @tparam T Type of elements in stdArray
+ * @tparam N The number of fixed element in the array
+ * @tparam USE_STD_CONTAINER_BOUNDS_CHECKING A boolean flag to enable or disable bounds checking.
+ */
+template< class T,
+          std::size_t N,
+          bool USE_BOUNDS_CHECKING = false >
+struct StdArrayWrapper : public std::array< T, N >
+{
+public:
+  /// Type alias for the base class (i.e., stdArray)
+  using Base = std::array< T, N >;
+
+  /**
+   * Access element at index with bounds checking if USE_STD_CONTAINER_BOUNDS_CHECKING is true.
+   * Otherwise, uses operator[] for unchecked access.
+   * @param index Index of the element to access.
+   * @return Const reference to the element at the specified index.
+   * @throws std::out_of_range if index is out of bounds.
+   */
+  constexpr T & operator[]( size_t const index )
+  {
+    if constexpr (USE_BOUNDS_CHECKING)
+    {
+      return this->at( index );
+    }
+    else
+    {
+      return Base::operator[]( index );
+    }
+  }
+
+  /**
+   * Access element at index with bounds checking if USE_STD_CONTAINER_BOUNDS_CHECKING is true.
+   * Otherwise, uses operator[] for unchecked access.
+   * @param index Index of the element to access.
+   * @return Const reference to the element at the specified index.
+   * @throws std::out_of_range if index is out of bounds.
+   */
+  constexpr T const & operator[]( size_t const index ) const
+  {
+    if constexpr (USE_BOUNDS_CHECKING)
+    {
+      return this->at( index );
+    }
+    else
+    {
+      return Base::operator[]( index );
+    }
+  }
+
+};
+} //namespace internal
+
+/**
+ * @tparam T Type of elements in the array.
+ * @tparam N The number of fixed element in the array.
+ * @note we use a struct rather than an alias for taking advantage of deduction guide
+ */
+template< class T, std::size_t N >
+struct stdArray : public internal::StdArrayWrapper< T, N, true >
+{};
+
+/**
+ * @brief Deduction guide for stdArray
+ * Allows the element type and array size to be automatically deduced from the initialization list.
+ * @code
+ * stdArray a{1, 2, 3}; // deduces stdArray<int, 3>
+ * @endcode
+ * @tparam _Tp Type of the first element provided.
+ * @tparam _Up Types of the other elements provided.
+ */
+template< typename _Tp, typename ... _Up >
+stdArray( _Tp, _Up ... )
+  ->stdArray< std::enable_if_t< (std::is_same_v< _Tp, _Up > && ...), _Tp >,
+              1 + sizeof...(_Up) >;
+
+/**
+ * @brief Helper function that convert a std::array into a stdArray by expanding its elements
+ * @tparam T The type of the elements
+ * @tparam N The number of fixed element in the array
+ * @tparam Is An integer parameter pack representing the indices
+ * @param arr The input std::array to be converted.
+ * @return A constexpr stdArray< T, N >
+ */
+template< typename T, std::size_t N, std::size_t... Is >
+constexpr stdArray< T, N > to_stdArray_impl( std::array< T, N > const & arr, std::index_sequence< Is... > )
+{
+  return {{arr[Is] ...}};
+}
+
+/**
+ * @brief Convert an std::array to an stdArray.
+ * @tparam T Type of elements in stdArray
+ * @tparam N The number of fixed element in the array
+ * @param arr The std::array to convert
+ * @return A stdArray< T, N >
+   @note we don't want implicitly convert an std::array into a stdArray.
+ */
+template< typename T, std::size_t N >
+constexpr stdArray< T, N > to_stdArray( std::array< T, N > const & arr )
+{
+  return to_stdArray_impl( arr, std::make_index_sequence< N >{} );
+}
+
+
 } // namespace geos
 
 #endif /* GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP */

src/coreComponents/dataRepository/wrapperHelpers.hpp

@@ -425,7 +425,7 @@ pushDataToConduitNode( Array< T, NDIM, PERMUTATION > const & var,
   node[ "__dimensions__" ].set( dimensionType, temp );
 
   // Create a copy of the permutation
-  constexpr std::array< camp::idx_t, NDIM > const perm = RAJA::as_array< PERMUTATION >::get();
+  constexpr std::array< camp::idx_t, NDIM > const perm = to_stdArray( RAJA::as_array< PERMUTATION >::get());
   for( int i = 0; i < NDIM; ++i )
   {
     temp[ i ] = perm[ i ];
@@ -454,7 +454,7 @@ pullDataFromConduitNode( Array< T, NDIM, PERMUTATION > & var,
   conduit::Node const & permutationNode = node.fetch_existing( "__permutation__" );
   GEOS_ERROR_IF_NE( permutationNode.dtype().number_of_elements(), totalNumDimensions );
 
-  constexpr std::array< camp::idx_t, NDIM > const perm = RAJA::as_array< PERMUTATION >::get();
+  constexpr std::array< camp::idx_t, NDIM > const perm = to_stdArray( RAJA::as_array< PERMUTATION >::get());
   camp::idx_t const * const permFromConduit = permutationNode.value();
   for( int i = 0; i < NDIM; ++i )
   {