EIC code displayed by LXR master/​include/​corecel/​cont/​Array.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-11-04 09:58:26

 //------------------------------- -*- C++ -*- -------------------------------//
 // Copyright Celeritas contributors: see top-level COPYRIGHT file for details
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
 //! \file corecel/cont/Array.hh
 //---------------------------------------------------------------------------//
 #pragma once
 
 #include <cstddef>
 #include <type_traits>
 #include <utility>
 
 #include "corecel/Macros.hh"
 #include "corecel/Types.hh"
 #include "corecel/data/Ldg.hh"
 
 #if !CELER_DEVICE_COMPILE
 #    include <ostream>
 
 #    include "corecel/io/StreamableContainer.hh"
 #endif
 
 namespace celeritas
 {
 //---------------------------------------------------------------------------//
 template<class T, std::size_t>
 class Span;
 
 //---------------------------------------------------------------------------//
 /*!
  * Fixed-size simple array for storage.
  *
  * The Array class is primarily used for point coordinates (e.g., \c Real3) but
  * is also used for other fixed-size data structures.
  *
  * This is not fully compatible with std::array:
  * - no support for N=0
  * - zero-initialized by default
  * - assume noexcept construction/copying of data
  *
  * \note For supplementary functionality, include:
  * - \c corecel/math/ArrayUtils.hh for real-number vector/matrix applications
  * - \c corecel/math/ArrayOperators.hh for mathematical operators
  * - \c ArrayIO.json.hh for JSON input and output
  */
 template<class T, std::size_t N>
 class Array
 {
     static_assert(N > 0);
 
   public:
     //!@{
     //! \name Type aliases
     using value_type = T;
     using size_type = ::celeritas::size_type;
     using pointer = value_type*;
     using const_pointer = value_type const*;
     using reference = value_type&;
     using const_reference = value_type const&;
     using iterator = pointer;
     using const_iterator = const_pointer;
 
     using CArrayConstRef = T const (&)[N];
     //!@}
 
   public:
     //! Default construction initializes to zero
     CELER_CEF Array() noexcept : d_{T{}} {}
 
     //! Construct from an array for aggregate initialization of daughters
     CELER_CEF Array(CArrayConstRef values) noexcept
     {
         for (size_type i = 0; i < N; ++i)
         {
             d_[i] = values[i];
         }
     }
 
     //! Construct with C-style aggregate initialization
     CELER_CEF Array(T first) noexcept : d_{first} {}
 
     //! Construct with the array's data
     template<class... Us>
     CELER_CEF Array(T first, Us... rest) noexcept
         : d_{first, static_cast<T>(rest)...}
     {
         // Protect against leaving off an entry, e.g. Array<int, 2>(1)
         static_assert(sizeof...(rest) + 1 == N,
                       "All array entries must be explicitly specified");
     }
 
     //// ACCESSORS ////
 
     //!@{
     //! \name Element access
     CELER_CEF const_reference operator[](size_type i) const noexcept
     {
         return d_[i];
     }
     CELER_CEF reference operator[](size_type i) { return d_[i]; }
     CELER_CEF const_reference front() const { return d_[0]; }
     CELER_CEF reference front() { return d_[0]; }
     CELER_CEF const_reference back() const { return d_[N - 1]; }
     CELER_CEF reference back() { return d_[N - 1]; }
     CELER_CEF const_pointer data() const { return d_; }
     CELER_CEF pointer data() { return d_; }
     //!@}
 
     //!@{
     //! Access for structured unpacking
     template<std::size_t I>
     CELER_CEF T& get() noexcept
     {
         static_assert(I < static_cast<std::size_t>(N));
         return d_[I];
     }
     template<std::size_t I>
     CELER_CEF T const& get() const noexcept
     {
         static_assert(I < static_cast<std::size_t>(N));
         return d_[I];
     }
     //!@}
 
     //!@{
     //! \name Iterators
     CELER_CEF iterator begin() noexcept { return d_; }
     CELER_CEF iterator end() noexcept { return d_ + N; }
     CELER_CEF const_iterator begin() const noexcept { return d_; }
     CELER_CEF const_iterator end() const noexcept { return d_ + N; }
     CELER_CEF const_iterator cbegin() const noexcept { return d_; }
     CELER_CEF const_iterator cend() const noexcept { return d_ + N; }
     //!@}
 
     //!@{
     //! \name Capacity
     CELER_CEF bool empty() const noexcept { return N == 0; }
     static CELER_CEF size_type size() noexcept { return N; }
     //!@}
 
     //!@{
     //! \name  Operations
 
     //! Fill the array with a constant value
     CELER_CEF void fill(const_reference value) noexcept
     {
         for (size_type i = 0; i != N; ++i)
         {
             d_[i] = value;
         }
     }
     //!@}
 
     //// FRIENDS ////
 
     //! Test equality of two arrays
     template<class U>
     CELER_CEF friend auto operator==(Array const& lhs,
                                      Array<U, N> const& rhs) noexcept
         -> std::enable_if_t<std::is_convertible_v<U, T>, bool>
     {
         for (size_type i = 0; i != N; ++i)
         {
             if (lhs[i] != rhs[i])
                 return false;
         }
         return true;
     }
 
     //! Test inequality of two arrays
     template<class U>
     CELER_CEF friend auto operator!=(Array const& lhs,
                                      Array<U, N> const& rhs) noexcept
         -> std::enable_if_t<std::is_convertible_v<U, T>, bool>
     {
         return !(lhs == rhs);
     }
 
     //! Allow loading via ldg
     CELER_CEF friend Array ldg(Array const* arr) noexcept
     {
         Array result;
         for (size_type i = 0; i != N; ++i)
         {
             result[i] = ldg(&arr->d_[i]);
         }
         return result;
     }
 
   private:
     T d_[N];  //!< Storage
 };
 
 //---------------------------------------------------------------------------//
 // DEDUCTION GUIDES
 //---------------------------------------------------------------------------//
 
 // Note: this differs from std::array, which deduces from T rather than the
 // common type
 template<class T, class... Us>
 CELER_CTAD_FUNCTION Array(T, Us...)
     -> Array<std::common_type_t<T, Us...>, 1 + sizeof...(Us)>;
 
 //---------------------------------------------------------------------------//
 // INLINE DEFINITIONS
 
 #if !CELER_DEVICE_COMPILE
 //---------------------------------------------------------------------------//
 /*!
  * Write the elements of array \a a to stream \a os.
  */
 template<class T, std::size_t N>
 CELER_FORCEINLINE std::ostream& operator<<(std::ostream& os,
                                            Array<T, N> const& a)
 {
     os << StreamableContainer{a.data(), a.size()};
     return os;
 }
 #endif
 
 //---------------------------------------------------------------------------//
 // FREE FUNCTIONS
 //---------------------------------------------------------------------------//
 /*!
  * Convert a C array from type \c T2 to an Array of \c T1.
  *
  * The standard library version of this function is available since C++20.
  */
 template<class T, std::size_t N>
 CELER_CONSTEXPR_FUNCTION auto to_array(T (&x)[N])
 {
     static_assert(!std::is_array_v<T>,
                   "to_array elements cannot be multidimensional");
     static_assert(std::is_constructible_v<T, T&>,
                   "to_array elements must be copy constructible");
 
     Array<std::remove_cv_t<T>, N> result;
     for (size_type i = 0; i != N; ++i)
     {
         result[i] = x[i];
     }
     return result;
 }
 
 //---------------------------------------------------------------------------//
 //! Construct an array from a fixed-size span
 template<class T, std::size_t N>
 CELER_CONSTEXPR_FUNCTION auto to_array(Span<T, N> s)
 {
     Array<std::remove_cv_t<T>, N> result{};
     for (std::size_t i = 0; i < N; ++i)
     {
         result[i] = s[i];
     }
     return result;
 }
 
 // DEPRECATED: remove in v1.0
 template<class T, std::size_t N>
 [[deprecated("use to_array")]] CELER_CONSTEXPR_FUNCTION auto make_array(
     Span<T, N> s)
 {
     return to_array(s);
 }
 
 //---------------------------------------------------------------------------//
 /*!
  * Convert an array from type \c T2 to \c T1.
  */
 template<class T1, class T2, std::size_t N>
 CELER_CONSTEXPR_FUNCTION Array<T1, N> static_array_cast(Array<T2, N> const& x)
 {
     Array<T1, N> result;
     for (size_type i = 0; i != N; ++i)
     {
         result[i] = static_cast<T1>(x[i]);
     }
     return result;
 }
 
 //---------------------------------------------------------------------------//
 }  // namespace celeritas
 
 //---------------------------------------------------------------------------//
 //! \cond
 namespace std
 {
 //---------------------------------------------------------------------------//
 //! Support structured binding: array size
 template<class T, std::size_t N>
 struct tuple_size<celeritas::Array<T, N>>
 {
     static constexpr std::size_t value = N;
 };
 
 //! Support structured binding: array element type
 template<std::size_t I, class T, std::size_t N>
 struct tuple_element<I, celeritas::Array<T, N>>
 {
     static_assert(I < std::tuple_size<celeritas::Array<T, N>>::value);
     using type = T;
 };
 
 //---------------------------------------------------------------------------//
 }  // namespace std
 //! \endcond

This page was automatically generated by the 2.3.7 LXR engine. The LXR team