FixedArray.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* FixedArray.h                                                (C) 2000-2025 */
/*                                                                           */
/* Tableau 1D de taille fixe.                                                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_FIXEDARRAY_H
#define ARCANE_UTILS_FIXEDARRAY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArrayView.h"
 
#include <array>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename T, Int32 NbElement>
class FixedArray final
{
  static_assert(NbElement >= 0, "NbElement has to positive");
 
 public:
 
  using value_type = T;
  using size_type = Int32;
  using difference_type = std::ptrdiff_t;
  using reference = value_type&;
  using const_reference = const value_type&;
  using pointer = value_type*;
  using const_pointer = const value_type*;
 
  using iterator = typename std::array<T, NbElement>::iterator;
  using const_iterator = typename std::array<T, NbElement>::const_iterator;
 
 public:
 
  constexpr FixedArray()
  : m_value({})
  {}
  constexpr FixedArray(std::array<T, NbElement> x)
  : m_value(std::move(x))
  {}
  constexpr FixedArray<T,NbElement>& operator=(std::array<T, NbElement> x)
  {
    m_value = std::move(x);
    return *this;
  }
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE T& operator[](Int32 index)
  {
    ARCANE_CHECK_AT(index, NbElement);
    return m_value[index];
  }
  constexpr ARCCORE_HOST_DEVICE const T& operator[](Int32 index) const
  {
    ARCANE_CHECK_AT(index, NbElement);
    return m_value[index];
  }
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, NbElement> span() { return { m_value.data(), NbElement }; }
  constexpr ARCCORE_HOST_DEVICE SmallSpan<const T, NbElement> span() const { return { m_value.data(), NbElement }; }
  constexpr ARCCORE_HOST_DEVICE ArrayView<T> view() { return { NbElement, m_value.data() }; }
  constexpr ARCCORE_HOST_DEVICE ConstArrayView<T> view() const { return { NbElement, m_value.data() }; }
  constexpr ARCCORE_HOST_DEVICE const T* data() const { return m_value.data(); }
  constexpr ARCCORE_HOST_DEVICE T* data() { return m_value.data(); }
 
  static constexpr Int32 size() { return NbElement; }
 
 public:
 
  constexpr iterator begin() { return m_value.begin(); }
  constexpr iterator end() { return m_value.end(); }
  constexpr const_iterator begin() const { return m_value.begin(); }
  constexpr const_iterator end() const { return m_value.end(); }
 
 private:
 
  std::array<T, NbElement> m_value;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif