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>;
  };

  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>;
  };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename T,typename SizeType,SizeType Extent,SizeType MinValue>
class SpanImpl
{
 public:
 
  using ThatClass = SpanImpl<T,SizeType,Extent,MinValue>;
  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>;

  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>>;
 
 public:

  constexpr ARCCORE_HOST_DEVICE SpanImpl() noexcept : m_ptr(nullptr), m_size(0) {}

  // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
  template <typename X, SizeType XExtent, SizeType XMinValue, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<X, SizeType, XExtent, XMinValue>& from) noexcept
  : m_ptr(from.data())
  , m_size(from.size())
  {}
 
  template <SizeType XExtent, SizeType XMinValue>
  constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<T, SizeType, XExtent, XMinValue>& from) noexcept
  : m_ptr(from.data())
  , m_size(from.size())
  {}

  constexpr ARCCORE_HOST_DEVICE SpanImpl(pointer ptr, SizeType asize) noexcept
  : m_ptr(ptr)
  , m_size(asize)
  {}

  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())) {}

  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 = ArraySizeChecker<SizeType>::check(from.size());
    return (*this);
  }
 
 public:

  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr,SizeType asize) noexcept
  {
    return ThatClass(ptr,asize);
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE reference operator[](SizeType i) const
  {
    ARCCORE_CHECK_RANGE(i, MinValue, m_size);
    return m_ptr[i];
  }

  constexpr ARCCORE_HOST_DEVICE reference operator()(SizeType i) const
  {
    ARCCORE_CHECK_RANGE(i, MinValue, m_size);
    return m_ptr[i];
  }

  constexpr ARCCORE_HOST_DEVICE reference item(SizeType i) const
  {
    ARCCORE_CHECK_RANGE(i, MinValue, m_size);
    return m_ptr[i];
  }

  constexpr ARCCORE_HOST_DEVICE void setItem(SizeType i, const_reference v) noexcept
  {
    ARCCORE_CHECK_RANGE(i, MinValue, m_size);
    m_ptr[i] = v;
  }

  constexpr ARCCORE_HOST_DEVICE SizeType size() const noexcept { return m_size; }
  constexpr ARCCORE_HOST_DEVICE SizeType sizeBytes() const noexcept { return static_cast<SizeType>(m_size * sizeof(value_type)); }
  constexpr ARCCORE_HOST_DEVICE SizeType length() const noexcept { return m_size; }

  constexpr ARCCORE_HOST_DEVICE iterator begin() const noexcept { return iterator(m_ptr); }
  constexpr ARCCORE_HOST_DEVICE iterator end() const noexcept { return iterator(m_ptr+m_size); }
  constexpr ARCCORE_HOST_DEVICE reverse_iterator rbegin() const noexcept { return std::make_reverse_iterator(end()); }
  constexpr ARCCORE_HOST_DEVICE reverse_iterator rend() const noexcept { return std::make_reverse_iterator(begin()); }
 
 public:

  ARCCORE_DEPRECATED_REASON("Y2023: Use begin()/end() instead")
  ArrayRange<pointer> range() const
  {
    return ArrayRange<pointer>(m_ptr,m_ptr+m_size);
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE pointer ptrAt(SizeType index) const
  {
    ARCCORE_CHECK_AT(index,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);
    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_ptr[i] = value;
  }

  ARCCORE_HOST_DEVICE inline void fill(T o)
  {
    for( SizeType i=0, n=m_size; i<n; ++i )
      m_ptr[i] = o;
  }

  constexpr view_type smallView()
  {
    Integer s = arccoreCheckArraySize(m_size);
    return view_type(s,m_ptr);
  }

  constexpr ConstArrayView<value_type> constSmallView() const
  {
    Integer s = arccoreCheckArraySize(m_size);
    return ConstArrayView<value_type>(s,m_ptr);
  }

  constexpr ARCCORE_HOST_DEVICE ThatClass subSpan(SizeType abegin,SizeType asize) const
  {
    if (abegin>=m_size)
      return {};
    asize = _min(asize,m_size-abegin);
    return {m_ptr+abegin,asize};
  }

  constexpr ARCCORE_HOST_DEVICE ThatClass subPart(SizeType abegin,SizeType asize) const
  {
    return subSpan(abegin,asize);
 
  }

  ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
  constexpr ThatClass subView(SizeType abegin,SizeType asize) const
  {
    return subSpan(abegin,asize);
  }

  constexpr ARCCORE_HOST_DEVICE ThatClass subspan(SizeType abegin,SizeType asize) const
  {
    return subSpan(abegin,asize);
  }

  ARCCORE_DEPRECATED_REASON("Y2023: use subSpanInterval() instead")
  constexpr ThatClass subViewInterval(SizeType index,SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this,index,nb_interval);
  }

  constexpr ThatClass subSpanInterval(SizeType index,SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this,index,nb_interval);
  }

  constexpr ThatClass subPartInterval(SizeType index,SizeType nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this,index,nb_interval);
  }

  template<class U> ARCCORE_HOST_DEVICE
  void copy(const U& copy_array)
  {
    Int64 n = copy_array.size();
    Int64 size_as_int64 = 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];
  }

  constexpr ARCCORE_HOST_DEVICE bool empty() const noexcept { return m_size==0; }
  ARCCORE_HOST_DEVICE bool contains(const_reference v) const
  {
    for( SizeType i=0; i<m_size; ++i ){
      if (m_ptr[i]==v)
        return true;
    }
    return false;
  }

  std::optional<SizeType> findFirst(const_reference v) const
  {
    for( SizeType i=0; i<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;
  }

  constexpr ARCCORE_HOST_DEVICE pointer data() const noexcept { return m_ptr; }

  template<typename X,SizeType Extent2,SizeType MinValue2, typename = std::enable_if_t<std::is_same_v<X,value_type>>> friend bool
  operator==(const SpanImpl<T,SizeType,Extent,MinValue>& rhs, const SpanImpl<X,SizeType,Extent2,MinValue2>& lhs)
  {
    return impl::areEqual(SpanImpl<T,SizeType>(rhs),SpanImpl<T,SizeType>(lhs));
  }

  template<typename X,SizeType Extent2,SizeType MinValue2,typename = std::enable_if_t<std::is_same_v<X,value_type>>> friend bool
  operator!=(const SpanImpl<T,SizeType,Extent,MinValue>& rhs, const SpanImpl<X,SizeType,Extent2,MinValue2>& lhs)
  {
    return !operator==(rhs,lhs);
  }

  template<SizeType Extent2,SizeType MinValue2> friend bool
  operator==(const SpanImpl<T,SizeType,Extent,MinValue>& rhs, const SpanImpl<T,SizeType,Extent2,MinValue2>& lhs)
  {
    return impl::areEqual(SpanImpl<T,SizeType>(rhs),SpanImpl<T,SizeType>(lhs));
  }

  template<SizeType Extent2,SizeType MinValue2> friend bool
  operator!=(const SpanImpl<T,SizeType,Extent,MinValue>& rhs, const SpanImpl<T,SizeType,Extent2,MinValue2>& 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:
  
  constexpr void _setArray(pointer v,SizeType s) noexcept { m_ptr = v; m_size = s; }

  constexpr void _setPtr(pointer v) noexcept { m_ptr = v; }

  constexpr void _setSize(SizeType s) noexcept { m_size = s; }
 
 private:
 
  pointer m_ptr;  
  SizeType m_size; 
 
 private:
 
  static constexpr SizeType _min(SizeType a,SizeType b)
  {
    return ( (a<b) ? a : b );
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename T, Int64 Extent, Int64 MinValue>
class Span
: public SpanImpl<T, Int64, Extent, MinValue>
{
 public:
 
  using ThatClass = Span<T, Extent, MinValue>;
  using BaseClass = SpanImpl<T, Int64, Extent, MinValue>;
  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>>;
 
 public:

  Span() = default;
  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, Int64 XMinValue, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE Span(const Span<X, XExtent, XMinValue>& from) noexcept
  : BaseClass(from)
  {}
  // Pour un Span<const T>, on a le droit de construire depuis un SmallSpan<T>
  template <typename X, Int32 XExtent, Int32 XMinValue, typename = std::enable_if_t<std::is_same_v<const X, T>>>
  constexpr ARCCORE_HOST_DEVICE Span(const SmallSpan<X, XExtent, XMinValue>& from) noexcept
  : BaseClass(from.data(), from.size())
  {}
  template <Int64 XExtent, Int64 XMinValue>
  constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int64, XExtent, XMinValue>& from) noexcept
  : BaseClass(from)
  {}
  template <Int32 XExtent, Int32 XMinValue>
  constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int32, XExtent, XMinValue>& from) noexcept
  : BaseClass(from.data(), from.size())
  {}

  constexpr ARCCORE_HOST_DEVICE Span(pointer ptr, Int64 asize) noexcept
  : BaseClass(ptr, asize)
  {}

  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()) {}

  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:

  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr,size_type asize) noexcept
  {
    return ThatClass(ptr,asize);
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE Span<T,DynExtent> subspan(Int64 abegin,Int64 asize) const
  {
    return BaseClass::subspan(abegin,asize);
  }

  constexpr ARCCORE_HOST_DEVICE Span<T,DynExtent> subSpan(Int64 abegin,Int64 asize) const
  {
    return BaseClass::subSpan(abegin,asize);
  }

  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPart(Int64 abegin, Int64 asize) const
  {
    return BaseClass::subPart(abegin, asize);
  }

  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subSpanInterval(Int64 index, Int64 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }

  constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPartInterval(Int64 index, Int64 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
  }

  ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
  constexpr ARCCORE_HOST_DEVICE Span<T> subView(Int64 abegin, Int64 asize) const
  {
    return subspan(abegin, asize);
  }

  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);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename T, Int32 Extent, Int32 MinValue>
class SmallSpan
: public SpanImpl<T, Int32, Extent, MinValue>
{
 public:
 
  using ThatClass = SmallSpan<T, Extent, MinValue>;
  using BaseClass = SpanImpl<T, Int32, Extent, MinValue>;
  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>>;
 
 public:

  SmallSpan() = default;

  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, Int32 XMinValue>
  constexpr ARCCORE_HOST_DEVICE SmallSpan(const SpanImpl<T, Int32, XExtent, XMinValue>& from) noexcept
  : BaseClass(from)
  {}

  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) {}

  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:

  // contenant \a asize éléments.
  static constexpr ThatClass create(pointer ptr,size_type asize) noexcept
  {
    return ThatClass(ptr,asize);
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subspan(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subspan(abegin,asize);
  }

  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpan(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subSpan(abegin,asize);
  }

  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subPart(Int32 abegin, Int32 asize) const
  {
    return BaseClass::subSpan(abegin, asize);
  }

  constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpanInterval(Int32 index, Int32 nb_interval) const
  {
    return impl::subViewInterval<ThatClass>(*this,index,nb_interval);
  }

  constexpr ARCCORE_HOST_DEVICE ThatClass subPartInterval(Int32 index,Int32 nb_interval) const
  {
    return subSpanInterval(index,nb_interval);
  }

  ARCCORE_DEPRECATED_REASON("Y2023: use subPart() instead")
  constexpr ARCCORE_HOST_DEVICE SmallSpan<T> subView(Int32 abegin,Int32 asize) const
  {
    return subspan(abegin,asize);
  }

  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);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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];
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType> inline void
sampleSpan(Span<const DataType> values,Span<const Int64> indexes,Span<DataType> result)
{
  _sampleSpan<DataType,Int64,Int64>(values,indexes,result);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType> inline void
sampleSpan(Span<const DataType> values,Span<const Int32> indexes,Span<DataType> result)
{
  _sampleSpan<DataType,Int32,Int64>(values,indexes,result);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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()};
}

template <typename DataType>
inline SmallSpan<const std::byte>
asBytes(const ArrayView<DataType>& s)
{
  return asBytes(SmallSpan<DataType>(s));
}

template <typename DataType>
inline SmallSpan<const std::byte>
asBytes(const ConstArrayView<DataType>& s)
{
  return asBytes(SmallSpan<const DataType>(s));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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()};
}

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 };
}
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType,Int64 Extent> inline Span<DataType>
asSpan(Span<std::byte,Extent> bytes)
{
  return impl::asSpanInternal<std::byte,DataType,Extent>(bytes);
}

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);
}

template<typename DataType,Int32 Extent> inline SmallSpan<DataType>
asSmallSpan(SmallSpan<std::byte,Extent> bytes)
{
  return impl::asSmallSpanInternal<std::byte,DataType,Extent>(bytes);
}

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);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
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 };
}

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 };
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
extern "C++" ARCCORE_BASE_EXPORT void
binaryWrite(std::ostream& ostr,const Span<const std::byte>& bytes);

extern "C++" ARCCORE_BASE_EXPORT void
binaryRead(std::istream& istr,const Span<std::byte>& bytes);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arccore
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arccore
{
using Arcane::binaryRead;
using Arcane::binaryWrite;
using Arcane::asSmallSpan;
using Arcane::asSpan;
using Arcane::asWritableBytes;
using Arcane::asBytes;
using Arcane::sampleSpan;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif