Span.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Span.h                                                      (C) 2000-2025 */
/*                                                                           */
/* Vues sur des tableaux C.                                                  */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_BASE_SPAN_H
#define ARCCORE_BASE_SPAN_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/ArrayView.h"
 
#include <type_traits>
#include <optional>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Impl
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Pour indiquer que Span<T>::view() retourne un ArrayView
// et Span<const T>::view() retourne un ConstArrayView.
template <typename T>
class ViewTypeT
{
 public:
 
  using view_type = ArrayView<T>;
};
template <typename T>
class ViewTypeT<const T>
{
 public:
 
  using view_type = ConstArrayView<T>;
};
 
//! Pour avoir le type (SmallSpan ou Span) en fonction de la taille (Int32 ou Int64)
template <typename T, typename SizeType>
class SpanTypeFromSize;
 
template <typename T>
class SpanTypeFromSize<T, Int32>
{
 public:
 
  using SpanType = SmallSpan<T>;
};
 
template <typename T>
class SpanTypeFromSize<T, Int64>
{
 public:
 
  using SpanType = Span<T>;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Classe pour conserver la taille d'un SpanImpl.
 *
 * Si Extent != DynExtent, alors il n'est pas nécessaire d'avoir
 * de conserver le nombre d'éléments dans un champ de l'instance.
 */
template <typename SizeType>
class DynamicExtentStorage
{
  template <typename T, typename SpanSizeType, SpanSizeType SpanExtent>
  friend class ::Arcane::SpanImpl;
 
 public:
 
  explicit constexpr DynamicExtentStorage(SizeType s) noexcept
  : m_size(s)
  {}
 
 public:
 
  constexpr SizeType size() const noexcept { return m_size; }
 
 private:
 
  SizeType m_size;
};
 
class ARCCORE_BASE_EXPORT ExtentStorageBase
{
 public:
 
  static void _throwBadSize [[noreturn]] (Int64 wanted_size, Int64 expected_size);
};
 
//! Spécialisation pour le nombre d'éléments connu à la compilation
template <typename SizeType, SizeType FixedExtent>
class ExtentStorage
{
  template <typename T, typename SpanSizeType, SpanSizeType SpanExtent>
  friend class ::Arcane::SpanImpl;
 
 public:
 
  explicit constexpr ExtentStorage([[maybe_unused]] SizeType s) noexcept
  {
#if defined(ARCCORE_CHECK) && !defined(ARCCORE_DEVICE_CODE)
    if (s != FixedExtent)
      ExtentStorageBase::_throwBadSize(s, FixedExtent);
#endif
  }
  ExtentStorage() = default;
 
 public:
 
  constexpr SizeType size() const noexcept { return FixedExtent; }
 
 private:
 
  static constexpr SizeType m_size = FixedExtent;
};
 
//! Spécialisation pour le nombre d'éléments dynamique
template <>
class ExtentStorage<Int32, DynExtent>
: public DynamicExtentStorage<Int32>
{
  using BaseClass = DynamicExtentStorage<Int32>;
 
 public:
 
  explicit constexpr ExtentStorage(Int32 s) noexcept
  : BaseClass(s)
  {}
};
 
//! Spécialisation pour le nombre d'éléments dynamique
template <>
class ExtentStorage<Int64, DynExtent>
: public DynamicExtentStorage<Int64>
{
  using BaseClass = DynamicExtentStorage<Int64>;
 
 public:
 
  explicit constexpr ExtentStorage(Int64 s) noexcept
  : BaseClass(s)
  {}
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \ingroup Collection
 * \brief Vue d'un tableau d'éléments de type \a T.
 *
 * Cette classe ne doit pas être utilisée directement. Il faut utiliser
 * Span ou SmallSpan à la place.
 *
 * La vue est non modifiable si l'argument template est de type 'const T'.
 * Cette classe permet d'accéder et d'utiliser un tableau d'éléments du
 * type \a T de la même manière qu'un tableau C standard. \a SizeType est le
 * type utilisé pour conserver le nombre d'éléments du tableau. Cela peut
 * être 'Int32' ou 'Int64'.
 *
 * Si \a Extent est différent de DynExtent (le défaut), la taille est
 * variable, sinon elle est fixe et a pour valeur \a Extent.
 */
template <typename T, typename SizeType, SizeType Extent>
class SpanImpl
{
  using ExtentStorageType = Impl::ExtentStorage<SizeType, Extent>;
 
 public:
 
  using ThatClass = SpanImpl<T, SizeType, Extent>;
  using SubSpanType = SpanImpl<T, SizeType, DynExtent>;
  using size_type = SizeType;
  using ElementType = T;
  using element_type = ElementType;
  using value_type = typename std::remove_cv_t<ElementType>;
  using const_value_type = typename std::add_const_t<value_type>;
  using index_type = SizeType;
  using difference_type = SizeType;
  using pointer = ElementType*;
  using const_pointer = const ElementType*;
  using reference = ElementType&;
  using const_reference = const ElementType&;
  using iterator = ArrayIterator<pointer>;
  using const_iterator = ArrayIterator<const_pointer>;
  using view_type = typename Impl::ViewTypeT<ElementType>::view_type;
  using reverse_iterator = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  //! Indique si on peut convertir un 'X' ou 'const X' en un 'T'
  template <typename X>
  using is_same_const_type = std::enable_if_t<std::is_same_v<X, T> || std::is_same_v<std::add_const_t<X>, T>>;
 
  static constexpr bool IsDynamic = (Extent == DynExtent);
 
 public:
 
  //! Construit une vue vide.
  constexpr ARCCORE_HOST_DEVICE SpanImpl() noexcept
  : m_ptr(nullptr)
  , m_size(0)
  {}
 
  //! Constructeur de recopie depuis une autre vue
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template <typename X, SizeType XExtent, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<X, SizeType, XExtent>& from) noexcept
  : m_ptr(from.data())
  , m_size(from.size())
  {}
 
  template <SizeType XExtent>
  constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<T, SizeType, XExtent>& from) noexcept
  : m_ptr(from.data())
  , m_size(from.size())
  {}
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et contenant \a asize éléments.
  constexpr ARCCORE_HOST_DEVICE SpanImpl(pointer ptr, SizeType asize) noexcept
  : m_ptr(ptr)
  , m_size(asize)
  {}
 
  //! Construit une vue depuis un std::array
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE SpanImpl(std::array<X, N>& from)
  : m_ptr(from.data())
  , m_size(ArraySizeChecker<SizeType>::check(from.size()))
  {}
 
  //! Construit une vue depuis un pointeur avec une taille fixe
  explicit constexpr ARCCORE_HOST_DEVICE SpanImpl(T* ptr) requires(!IsDynamic)
  : m_ptr(ptr)
  {}
 
  //! Opérateur de recopie
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE ThatClass& operator=(std::array<X, N>& from)
  {
    m_ptr = from.data();
    m_size = ExtentStorageType(ArraySizeChecker<SizeType>::check(from.size()));
    return (*this);
  }
 
 public:
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et
  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr, SizeType asize) noexcept
  {
    return ThatClass(ptr, asize);
  }
 
 public:
 
  /*!
   * \brief i-ème élément du tableau.
   *
   * En mode \a check, vérifie les débordements.
   */
  constexpr ARCCORE_HOST_DEVICE reference operator[](SizeType i) const
  {
    ARCCORE_CHECK_AT(i, m_size.m_size);
    return m_ptr[i];
  }
 
  /*!
   * \brief i-ème élément du tableau.
   *
   * En mode \a check, vérifie les débordements.
   */
  constexpr ARCCORE_HOST_DEVICE reference operator()(SizeType i) const
  {
    ARCCORE_CHECK_AT(i, m_size.m_size);
    return m_ptr[i];
  }
 
  /*!
   * \brief i-ème élément du tableau.
   *
   * En mode \a check, vérifie les débordements.
   */
  constexpr ARCCORE_HOST_DEVICE reference item(SizeType i) const
  {
    ARCCORE_CHECK_AT(i, m_size.m_size);
    return m_ptr[i];
  }
 
  /*!
   * \brief Positionne le i-ème élément du tableau.
   *
   * En mode \a check, vérifie les débordements.
   */
  constexpr ARCCORE_HOST_DEVICE void setItem(SizeType i, const_reference v) noexcept
  {
    ARCCORE_CHECK_AT(i, m_size.m_size);
    m_ptr[i] = v;
  }
 
  //! Retourne la taille du tableau
  constexpr ARCCORE_HOST_DEVICE SizeType size() const noexcept { return m_size.m_size; }
  //! Retourne la taille du tableau en octets
  constexpr ARCCORE_HOST_DEVICE SizeType sizeBytes() const noexcept
  {
    // TODO: retourner toujours un Int64
    return static_cast<SizeType>(m_size.m_size * sizeof(value_type));
  }
  //! Nombre d'éléments du tableau
  constexpr ARCCORE_HOST_DEVICE SizeType length() const noexcept { return m_size.m_size; }
 
  /*!
   * \brief Itérateur sur le premier élément du tableau.
   */
  constexpr ARCCORE_HOST_DEVICE iterator begin() const noexcept { return iterator(m_ptr); }
  /*!
   * \brief Itérateur sur le premier élément après la fin du tableau.
   */
  constexpr ARCCORE_HOST_DEVICE iterator end() const noexcept { return iterator(m_ptr + m_size.m_size); }
  //! Itérateur inverse sur le premier élément du tableau.
  constexpr ARCCORE_HOST_DEVICE reverse_iterator rbegin() const noexcept { return std::make_reverse_iterator(end()); }
  //! Itérateur inverse sur le premier élément après la fin du tableau.
  constexpr ARCCORE_HOST_DEVICE reverse_iterator rend() const noexcept { return std::make_reverse_iterator(begin()); }
 
 public:
 
  //! Intervalle d'itération du premier au dernièr élément.
  ARCCORE_DEPRECATED_REASON("Y2023: Use begin()/end() instead")
  ArrayRange<pointer> range() const
  {
    return ArrayRange<pointer>(m_ptr, m_ptr + m_size.m_size);
  }
 
 public:
 
  //! Adresse du index-ème élément
  constexpr ARCCORE_HOST_DEVICE pointer ptrAt(SizeType index) const
  {
    ARCCORE_CHECK_AT(index, m_size.m_size);
    return m_ptr + index;
  }
 
  // Elément d'indice \a i. Vérifie toujours les débordements
  constexpr ARCCORE_HOST_DEVICE reference at(SizeType i) const
  {
    arccoreCheckAt(i, m_size.m_size);
    return m_ptr[i];
  }
 
  // Positionne l'élément d'indice \a i. Vérifie toujours les débordements
  constexpr ARCCORE_HOST_DEVICE void setAt(SizeType i, const_reference value)
  {
    arccoreCheckAt(i, m_size.m_size);
    m_ptr[i] = value;
  }
 
  //! Remplit le tableau avec la valeur \a o
  ARCCORE_HOST_DEVICE inline void fill(T o)
  {
    for (SizeType i = 0, n = m_size.m_size; i < n; ++i)
      m_ptr[i] = o;
  }
 
  /*!
   * \brief Vue constante sur cette vue.
   */
  constexpr view_type smallView()
  {
    Integer s = arccoreCheckArraySize(m_size.m_size);
    return view_type(s, m_ptr);
  }
 
  /*!
   * \brief Vue constante sur cette vue.
   */
  constexpr ConstArrayView<value_type> constSmallView() const
  {
    Integer s = arccoreCheckArraySize(m_size.m_size);
    return ConstArrayView<value_type>(s, m_ptr);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE SubSpanType subSpan(SizeType abegin, SizeType asize) const
  {
    if (abegin >= m_size.m_size)
      return {};
    asize = _min(asize, m_size.m_size - abegin);
    return { m_ptr + abegin, asize };
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin et contenant \a asize éléments.
   * \sa subSpan()
   */
  constexpr ARCCORE_HOST_DEVICE SubSpanType subPart(SizeType abegin, SizeType asize) const
  {
    return subSpan(abegin, asize);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
  constexpr SubSpanType subView(SizeType abegin, SizeType asize) const
  {
    return subSpan(abegin, asize);
  }
 
  //! Pour compatibilité avec le C++20
  constexpr ARCCORE_HOST_DEVICE SubSpanType subspan(SizeType abegin, SizeType asize) const
  {
    return subSpan(abegin, asize);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  ARCCORE_DEPRECATED_REASON("Y2023: use subSpanInterval() instead")
  constexpr SubSpanType subViewInterval(SizeType index, SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr SubSpanType subSpanInterval(SizeType index, SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr SubSpanType subPartInterval(SizeType index, SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  /*!
   * \brief Recopie le tableau \a copy_array dans l'instance.
   *
   * Comme aucune allocation mémoire n'est effectuée, le
   * nombre d'éléments de \a copy_array doit être inférieur ou égal au
   * nombre d'éléments courant. S'il est inférieur, les éléments du
   * tableau courant situés à la fin du tableau sont inchangés
   */
  template <class U> ARCCORE_HOST_DEVICE void copy(const U& copy_array)
  {
    Int64 n = copy_array.size();
    Int64 size_as_int64 = m_size.m_size;
    arccoreCheckAt(n, size_as_int64 + 1);
    const_pointer copy_begin = copy_array.data();
    pointer to_ptr = m_ptr;
    // On est sur que \a n tient sur un 'SizeType' car il est plus petit
    // que \a m_size
    SizeType n_as_sizetype = static_cast<SizeType>(n);
    for (SizeType i = 0; i < n_as_sizetype; ++i)
      to_ptr[i] = copy_begin[i];
  }
 
  //! Retourne \a true si le tableau est vide (dimension nulle)
  constexpr ARCCORE_HOST_DEVICE bool empty() const noexcept { return m_size.m_size == 0; }
  //! \a true si le tableau contient l'élément de valeur \a v
  ARCCORE_HOST_DEVICE bool contains(const_reference v) const
  {
    for (SizeType i = 0; i < m_size.m_size; ++i) {
      if (m_ptr[i] == v)
        return true;
    }
    return false;
  }
 
  /*!
   * /brief Position du premier élément de valeur \a v
   *
   * /param v La valeur à trouver.
   * /return La position du premier élément de valeur \a v si présent, std::nullopt sinon.
   */
  std::optional<SizeType> findFirst(const_reference v) const
  {
    for (SizeType i = 0; i < m_size.m_size; ++i) {
      if (m_ptr[i] == v)
        return i;
    }
    return std::nullopt;
  }
 
 public:
 
  constexpr ARCCORE_HOST_DEVICE void setArray(const ArrayView<T>& v) noexcept
  {
    m_ptr = v.m_ptr;
    m_size = v.m_size;
  }
  constexpr ARCCORE_HOST_DEVICE void setArray(const Span<T>& v) noexcept
  {
    m_ptr = v.m_ptr;
    m_size = v.m_size;
  }
 
  /*!
   * \brief Pointeur sur le début de la vue.
   *
   * \warning Les accès via le pointeur retourné ne pourront pas être
   * pas vérifiés par Arcane à la différence des accès via
   * operator[](): aucune vérification de dépassement n'est possible,
   * même en mode vérification.
   */
  constexpr ARCCORE_HOST_DEVICE pointer data() const noexcept { return m_ptr; }
 
  //! Opérateur d'égalité (valide si T est const mais pas X)
  template <typename X, SizeType Extent2, typename = std::enable_if_t<std::is_same_v<X, value_type>>> friend bool
  operator==(const SpanImpl<T, SizeType, Extent>& rhs, const SpanImpl<X, SizeType, Extent2>& lhs)
  {
    return impl::areEqual(SpanImpl<T, SizeType>(rhs), SpanImpl<T, SizeType>(lhs));
  }
 
  //! Opérateur d'inégalité (valide si T est const mais pas X)
  template <typename X, SizeType Extent2, typename = std::enable_if_t<std::is_same_v<X, value_type>>> friend bool
  operator!=(const SpanImpl<T, SizeType, Extent>& rhs, const SpanImpl<X, SizeType, Extent2>& lhs)
  {
    return !operator==(rhs, lhs);
  }
 
  //! Opérateur d'égalité
  template <SizeType Extent2> friend bool
  operator==(const SpanImpl<T, SizeType, Extent>& rhs, const SpanImpl<T, SizeType, Extent2>& lhs)
  {
    return impl::areEqual(SpanImpl<T, SizeType>(rhs), SpanImpl<T, SizeType>(lhs));
  }
 
  //! Opérateur d'inégalité
  template <SizeType Extent2> friend bool
  operator!=(const SpanImpl<T, SizeType, Extent>& rhs, const SpanImpl<T, SizeType, Extent2>& lhs)
  {
    return !operator==(rhs, lhs);
  }
 
  friend inline std::ostream& operator<<(std::ostream& o, const ThatClass& val)
  {
    impl::dumpArray(o, Span<const T, DynExtent>(val.data(), val.size()), 500);
    return o;
  }
 
 protected:
 
  /*!
   * \brief Modifie le pointeur et la taille du tableau.
   *
   * C'est à la classe dérivée de vérifier la cohérence entre le pointeur
   * alloué et la dimension donnée.
   */
  constexpr void _setArray(pointer v, SizeType s) noexcept
  {
    m_ptr = v;
    m_size = s;
  }
 
  /*!
   * \brief Modifie le pointeur du début du tableau.
   *
   * C'est à la classe dérivée de vérifier la cohérence entre le pointeur
   * alloué et la dimension donnée.
   */
  constexpr void _setPtr(pointer v) noexcept { m_ptr = v; }
 
  /*!
   * \brief Modifie la taille du tableau.
   *
   * C'est à la classe dérivée de vérifier la cohérence entre le pointeur
   * alloué et la dimension donnée.
   */
  constexpr void _setSize(SizeType s) noexcept { m_size = ExtentStorageType(s); }
 
 private:
 
  pointer m_ptr; //!< Pointeur sur le tableau
  //! Nombre d'éléments du tableau
  ARCCORE_NO_UNIQUE_ADDRESS ExtentStorageType m_size;
 
 private:
 
  static constexpr SizeType _min(SizeType a, SizeType b)
  {
    return ((a < b) ? a : b);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \ingroup Collection
 * \brief Vue d'un tableau d'éléments de type \a T.
 *
 * La vue est non modifiable si l'argument template est de type 'const T'.
 Cette classe permet d'accéder et d'utiliser un tableau d'éléments du
 type \a T de la même manière qu'un tableau C standard. Elle est similaire à
 ArrayView à ceci près que le nombre d'éléments est stocké sur un 'Int64' et
 peut donc dépasser 2Go. Elle est concue pour être similaire à la classe
 std::span du C++20.
*/
template <typename T, Int64 Extent>
class Span
: public SpanImpl<T, Int64, Extent>
{
 public:
 
  using ThatClass = Span<T, Extent>;
  using BaseClass = SpanImpl<T, Int64, Extent>;
  using size_type = Int64;
  using value_type = typename BaseClass::value_type;
  using pointer = typename BaseClass::pointer;
  template <typename X>
  using is_same_const_type = std::enable_if_t<std::is_same_v<X, T> || std::is_same_v<std::add_const_t<X>, T>>;
  static constexpr bool IsDynamic = (Extent == DynExtent);
 
 public:
 
  //! Construit une vue vide.
  Span() = default;
  //! Constructeur de recopie depuis une autre vue
  constexpr ARCCORE_HOST_DEVICE Span(const ArrayView<value_type>& from) noexcept
  : BaseClass(from.m_ptr, from.m_size)
  {}
  // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
  // si T est const.
  template <typename X, typename = std::enable_if_t<std::is_same_v<X, value_type>>>
  constexpr ARCCORE_HOST_DEVICE Span(const ConstArrayView<X>& from) noexcept
  : BaseClass(from.m_ptr, from.m_size)
  {}
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template <typename X, Int64 XExtent, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE Span(const Span<X, XExtent>& from) noexcept
  : BaseClass(from)
  {}
  // Pour un Span<const T>, on a le droit de construire depuis un SmallSpan<T>
  template <typename X, Int32 XExtent, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE Span(const SmallSpan<X, XExtent>& from) noexcept
  : BaseClass(from.data(), from.size())
  {}
  template <Int64 XExtent>
  constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int64, XExtent>& from) noexcept
  : BaseClass(from)
  {}
  template <Int32 XExtent>
  constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int32, XExtent>& from) noexcept
  : BaseClass(from.data(), from.size())
  {}
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et contenant \a asize éléments.
  constexpr ARCCORE_HOST_DEVICE Span(pointer ptr, Int64 asize) noexcept
  : BaseClass(ptr, asize)
  {}
 
  //! Construit une vue à partir d'un std::array.
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE Span(std::array<X, N>& from) noexcept
  : BaseClass(from.data(), from.size())
  {}
 
  //! Construit une vue depuis un pointeur avec une taille fixe
  explicit constexpr ARCCORE_HOST_DEVICE Span(T* ptr) requires(!IsDynamic)
  : BaseClass(ptr)
  {}
 
  //! Opérateur de recopie
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE ThatClass& operator=(std::array<X, N>& from) noexcept
  {
    this->_setPtr(from.data());
    this->_setSize(from.size());
    return (*this);
  }
 
 public:
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et
  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
  {
    return ThatClass(ptr, asize);
  }
 
 public:
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subspan(Int64 abegin, Int64 asize) const
  {
    return BaseClass::subspan(abegin, asize);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subSpan(Int64 abegin, Int64 asize) const
  {
    return BaseClass::subSpan(abegin, asize);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPart(Int64 abegin, Int64 asize) const
  {
    return BaseClass::subPart(abegin, asize);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subSpanInterval(Int64 index, Int64 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPartInterval(Int64 index, Int64 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
  constexpr ARCCORE_HOST_DEVICE Span<T> subView(Int64 abegin, Int64 asize) const
  {
    return subspan(abegin, asize);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  ARCCORE_DEPRECATED_REASON("Y2023: use subSpanInterval() instead")
  constexpr ARCCORE_HOST_DEVICE Span<T> subViewInterval(Int64 index, Int64 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \ingroup Collection
 * \brief Vue d'un tableau d'éléments de type \a T.
 *
 * La vue est non modifiable si l'argument template est de type 'const T'.
 *
 * Cette classe permet d'accéder et d'utiliser un tableau d'éléments du
 * type \a T de la même manière qu'un tableau C standard. Elle est similaire à
 * Span à ceci près que le nombre d'éléments est stocké sur un 'Int32'.
 *
 * \note Pour être valide, il faut aussi que le nombre d'octets associés à la vue
 * (sizeBytes()) puisse tenir dans un \a Int32.
 */
template <typename T, Int32 Extent>
class SmallSpan
: public SpanImpl<T, Int32, Extent>
{
 public:
 
  using ThatClass = SmallSpan<T, Extent>;
  using BaseClass = SpanImpl<T, Int32, Extent>;
  using size_type = Int32;
  using value_type = typename BaseClass::value_type;
  using pointer = typename BaseClass::pointer;
  template <typename X>
  using is_same_const_type = std::enable_if_t<std::is_same_v<X, T> || std::is_same_v<std::add_const_t<X>, T>>;
  static constexpr bool IsDynamic = (Extent == DynExtent);
 
 public:
 
  //! Construit une vue vide.
  SmallSpan() = default;
 
  //! Constructeur de recopie depuis une autre vue
  constexpr ARCCORE_HOST_DEVICE SmallSpan(const ArrayView<value_type>& from) noexcept
  : BaseClass(from.m_ptr, from.m_size)
  {}
 
  // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
  // si T est const.
  template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
  constexpr ARCCORE_HOST_DEVICE SmallSpan(const ConstArrayView<X>& from) noexcept
  : BaseClass(from.m_ptr, from.m_size)
  {}
 
  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
  constexpr ARCCORE_HOST_DEVICE SmallSpan(const SmallSpan<X>& from) noexcept
  : BaseClass(from)
  {}
 
  template <Int32 XExtent>
  constexpr ARCCORE_HOST_DEVICE SmallSpan(const SpanImpl<T, Int32, XExtent>& from) noexcept
  : BaseClass(from)
  {}
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et contenant \a asize éléments.
  constexpr ARCCORE_HOST_DEVICE SmallSpan(pointer ptr, Int32 asize) noexcept
  : BaseClass(ptr, asize)
  {}
 
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE SmallSpan(std::array<X, N>& from)
  : BaseClass(from)
  {}
 
  //! Construit une vue depuis un pointeur avec une taille fixe
  explicit constexpr ARCCORE_HOST_DEVICE SmallSpan(T* ptr) requires(!IsDynamic)
  : BaseClass(ptr)
  {}
 
  //! Opérateur de recopie
  template <std::size_t N, typename X, typename = is_same_const_type<X>>
  constexpr ARCCORE_HOST_DEVICE ThatClass& operator=(std::array<X, N>& from)
  {
    BaseClass::operator=(from);
    return (*this);
  }
 
 public:
 
  //! Construit une vue sur une zone mémoire commencant par \a ptr et
  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
  {
    return ThatClass(ptr, asize);
  }
 
 public:
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subspan(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subspan(abegin, asize);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpan(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subSpan(abegin, asize);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subPart(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subSpan(abegin, asize);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpanInterval(Int32 index, Int32 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  constexpr ARCCORE_HOST_DEVICE ThatClass subPartInterval(Int32 index, Int32 nb_interval) const
  {
    return subSpanInterval(index, nb_interval);
  }
 
  /*!
   * \brief Sous-vue à partir de l'élément \a abegin
   * et contenant \a asize éléments.
   *
   * Si `(abegin+asize)` est supérieur à la taille du tableau,
   * la vue est tronquée à cette taille, retournant éventuellement une vue vide.
   */
  ARCCORE_DEPRECATED_REASON("Y2023: use subPart() instead")
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T> subView(Int32 abegin, Int32 asize) const
  {
    return subspan(abegin, asize);
  }
 
  //! Sous-vue correspondant à l'interval \a index sur \a nb_interval
  ARCCORE_DEPRECATED_REASON("Y2023: use subPartInterval() instead")
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T> subViewInterval(Int32 index, Int32 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Affiche sur le flot \a o les valeurs du tableau \a val.
 *
 * Si \a max_print est positif, alors au plus \a max_print valeurs
 * sont affichées. Si la taille du tableau est supérieure à
 * \a max_print, alors les (max_print/2) premiers et derniers
 * éléments sont affichés.
 */
template <typename T, typename SizeType> inline void
dumpArray(std::ostream& o, SpanImpl<const T, SizeType> val, int max_print)
{
  impl::dumpArray(o, val, max_print);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Extrait un sous-tableau à à partir d'une liste d'index.
 *
 * Remplit \a result avec les valeurs du tableau \a values correspondantes
 * aux indices \a indexes.
 *
 * \pre results.size() >= indexes.size();
 */
template <typename DataType, typename IntegerType, typename SizeType> inline void
_sampleSpan(SpanImpl<const DataType, SizeType> values,
            SpanImpl<const IntegerType, SizeType> indexes,
            SpanImpl<DataType, SizeType> result)
{
  const Int64 result_size = indexes.size();
  [[maybe_unused]] const Int64 my_size = values.size();
  const DataType* ptr = values.data();
  for (Int64 i = 0; i < result_size; ++i) {
    IntegerType index = indexes[i];
    ARCCORE_CHECK_AT(index, my_size);
    result[i] = ptr[index];
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Extrait un sous-tableau à à partir d'une liste d'index.
 *
 * Remplit \a result avec les valeurs du tableau \a values correspondantes
 * aux indices \a indexes.
 *
 * \pre results.size() >= indexes.size();
 */
template <typename DataType> inline void
sampleSpan(Span<const DataType> values, Span<const Int64> indexes, Span<DataType> result)
{
  _sampleSpan<DataType, Int64, Int64>(values, indexes, result);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Extrait un sous-tableau à à partir d'une liste d'index.
 *
 * Le résultat est stocké dans \a result dont la taille doit être au moins
 * égale à celle de \a indexes.
 */
template <typename DataType> inline void
sampleSpan(Span<const DataType> values, Span<const Int32> indexes, Span<DataType> result)
{
  _sampleSpan<DataType, Int32, Int64>(values, indexes, result);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Converti la vue en un tableau d'octets non modifiables.
 */
template <typename DataType, typename SizeType, SizeType Extent>
inline typename Impl::SpanTypeFromSize<const std::byte, SizeType>::SpanType
asBytes(const SpanImpl<DataType, SizeType, Extent>& s)
{
  return { reinterpret_cast<const std::byte*>(s.data()), s.sizeBytes() };
}
 
/*!
 * \brief Converti la vue en un tableau d'octets non modifiables.
 */
template <typename DataType>
inline SmallSpan<const std::byte>
asBytes(const ArrayView<DataType>& s)
{
  return asBytes(SmallSpan<DataType>(s));
}
 
/*!
 * \brief Converti la vue en un tableau d'octets non modifiables.
 */
template <typename DataType>
inline SmallSpan<const std::byte>
asBytes(const ConstArrayView<DataType>& s)
{
  return asBytes(SmallSpan<const DataType>(s));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Converti la vue en un tableau d'octets modifiables.
 *
 * Cette méthode n'est accessible que si \a DataType n'est pas `const`.
 */
template <typename DataType, typename SizeType, SizeType Extent,
          typename std::enable_if_t<!std::is_const<DataType>::value, int> = 0>
inline typename Impl::SpanTypeFromSize<std::byte, SizeType>::SpanType
asWritableBytes(const SpanImpl<DataType, SizeType, Extent>& s)
{
  return { reinterpret_cast<std::byte*>(s.data()), s.sizeBytes() };
}
 
/*!
 * \brief Converti la vue en un tableau d'octets modifiables.
 *
 * Cette méthode n'est accessible que si \a DataType n'est pas `const`.
 */
template <typename DataType> inline SmallSpan<std::byte>
asWritableBytes(const ArrayView<DataType>& s)
{
  return asWritableBytes(SmallSpan<DataType>(s));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace impl
{
 
  template <typename ByteType, typename DataType, Int64 Extent> inline Span<DataType>
  asSpanInternal(Span<ByteType, Extent> bytes)
  {
    Int64 size = bytes.size();
    if (size == 0)
      return {};
    static constexpr Int64 data_type_size = static_cast<Int64>(sizeof(DataType));
    static_assert(data_type_size > 0, "Bad datatype size");
    ARCCORE_ASSERT((size % data_type_size) == 0, ("Size is not a multiple of sizeof(DataType)"));
    auto* ptr = reinterpret_cast<DataType*>(bytes.data());
    return { ptr, size / data_type_size };
  }
 
  template <typename ByteType, typename DataType, Int32 Extent> inline SmallSpan<DataType>
  asSmallSpanInternal(SmallSpan<ByteType, Extent> bytes)
  {
    Int32 size = bytes.size();
    if (size == 0)
      return {};
    static constexpr Int32 data_type_size = static_cast<Int32>(sizeof(DataType));
    static_assert(data_type_size > 0, "Bad datatype size");
    ARCCORE_ASSERT((size % data_type_size) == 0, ("Size is not a multiple of sizeof(DataType)"));
    auto* ptr = reinterpret_cast<DataType*>(bytes.data());
    return { ptr, size / data_type_size };
  }
 
} // namespace impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Converti un Span<std::byte> en un Span<DataType>.
 * \pre bytes.size() % sizeof(DataType) == 0;
 */
template <typename DataType, Int64 Extent> inline Span<DataType>
asSpan(Span<std::byte, Extent> bytes)
{
  return impl::asSpanInternal<std::byte, DataType, Extent>(bytes);
}
/*!
 * \brief Converti un Span<std::byte> en un Span<DataType>.
 * \pre bytes.size() % sizeof(DataType) == 0;
 */
template <typename DataType, Int64 Extent> inline Span<const DataType>
asSpan(Span<const std::byte, Extent> bytes)
{
  return impl::asSpanInternal<const std::byte, const DataType, Extent>(bytes);
}
/*!
 * \brief Converti un SmallSpan<std::byte> en un SmallSpan<DataType>.
 * \pre bytes.size() % sizeof(DataType) == 0;
 */
template <typename DataType, Int32 Extent> inline SmallSpan<DataType>
asSmallSpan(SmallSpan<std::byte, Extent> bytes)
{
  return impl::asSmallSpanInternal<std::byte, DataType, Extent>(bytes);
}
/*!
 * \brief Converti un SmallSpan<const std::byte> en un SmallSpan<const DataType>.
 * \pre bytes.size() % sizeof(DataType) == 0;
 */
template <typename DataType, Int32 Extent> inline SmallSpan<const DataType>
asSmallSpan(SmallSpan<const std::byte, Extent> bytes)
{
  return impl::asSmallSpanInternal<const std::byte, const DataType, Extent>(bytes);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Retourne un Span associé au std::array.
 */
template <typename DataType, size_t SizeType> inline Span<DataType, SizeType>
asSpan(std::array<DataType, SizeType>& s)
{
  Int64 size = static_cast<Int64>(s.size());
  return { s.data(), size };
}
/*!
 * \brief Retourne un Span associé au std::array.
 */
template <typename DataType, size_t SizeType> inline SmallSpan<DataType, SizeType>
asSmallSpan(std::array<DataType, SizeType>& s)
{
  Int32 size = static_cast<Int32>(s.size());
  return { s.data(), size };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Ecrit en binaire le contenu de \a bytes sur le flot \a ostr.
 *
 * Cela revient à faire ostr.write(bytes.data(),bytes.size());
 */
extern "C++" ARCCORE_BASE_EXPORT void
binaryWrite(std::ostream& ostr, const Span<const std::byte>& bytes);
 
/*!
 * \brief Lit en binaire le contenu de \a bytes depuis le flot \a istr.
 *
 * Cela revient à faire ostr.read(bytes.data(),bytes.size());
 */
extern "C++" ARCCORE_BASE_EXPORT void
binaryRead(std::istream& istr, const Span<std::byte>& bytes);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arccore
{
using Arcane::asBytes;
using Arcane::asSmallSpan;
using Arcane::asSpan;
using Arcane::asWritableBytes;
using Arcane::binaryRead;
using Arcane::binaryWrite;
using Arcane::sampleSpan;
} // namespace Arccore
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif