12#ifndef ARCCORE_BASE_SPAN_H
13#define ARCCORE_BASE_SPAN_H
17#include "arccore/base/ArrayView.h"
49template <
typename T,
typename SizeType>
76template <
typename SizeType>
77class DynamicExtentStorage
79 template <
typename T,
typename SpanSizeType, SpanSizeType SpanExtent, SpanSizeType MinValue>
80 friend class ::Arcane::SpanImpl;
84 explicit constexpr DynamicExtentStorage(SizeType s) noexcept
90 constexpr SizeType size()
const noexcept {
return m_size; }
98template <
typename SizeType, SizeType FixedExtent>
101 template <
typename T,
typename SpanSizeType, SpanSizeType SpanExtent, SpanSizeType MinValue>
102 friend class ::Arcane::SpanImpl;
106 explicit constexpr ExtentStorage(SizeType)
noexcept {}
110 constexpr SizeType size()
const noexcept {
return FixedExtent; }
114 static constexpr SizeType m_size = FixedExtent;
120:
public DynamicExtentStorage<Int32>
122 using BaseClass = DynamicExtentStorage<Int32>;
126 explicit constexpr ExtentStorage(
Int32 s) noexcept
134:
public DynamicExtentStorage<Int64>
136 using BaseClass = DynamicExtentStorage<Int64>;
140 explicit constexpr ExtentStorage(
Int64 s) noexcept
175template <
typename T,
typename SizeType, SizeType Extent, SizeType MinValue>
184 using size_type = SizeType;
185 using ElementType = T;
186 using element_type = ElementType;
187 using value_type =
typename std::remove_cv_t<ElementType>;
188 using const_value_type =
typename std::add_const_t<value_type>;
189 using index_type = SizeType;
190 using difference_type = SizeType;
191 using pointer = ElementType*;
192 using const_pointer =
const ElementType*;
193 using reference = ElementType&;
194 using const_reference =
const ElementType&;
197 using view_type =
typename Impl::ViewTypeT<ElementType>::view_type;
198 using reverse_iterator = std::reverse_iterator<iterator>;
199 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
202 template <
typename X>
203 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>>;
215 template <
typename X, SizeType XExtent, SizeType XMinValue,
typename = std::enable_if_t<std::is_same_v<const X, T>>>
221 template <SizeType XExtent, SizeType XMinValue>
228 constexpr ARCCORE_HOST_DEVICE
SpanImpl(pointer ptr, SizeType asize) noexcept
234 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
235 constexpr ARCCORE_HOST_DEVICE
SpanImpl(std::array<X, N>& from)
241 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
242 constexpr ARCCORE_HOST_DEVICE ThatClass&
operator=(std::array<X, N>& from)
253 static constexpr ThatClass
create(pointer ptr, SizeType asize)
noexcept
255 return ThatClass(ptr, asize);
265 constexpr ARCCORE_HOST_DEVICE reference
operator[](SizeType i)
const
267 ARCCORE_CHECK_RANGE(i, MinValue,
m_size.m_size);
276 constexpr ARCCORE_HOST_DEVICE reference
operator()(SizeType i)
const
278 ARCCORE_CHECK_RANGE(i, MinValue,
m_size.m_size);
287 constexpr ARCCORE_HOST_DEVICE reference
item(SizeType i)
const
289 ARCCORE_CHECK_RANGE(i, MinValue,
m_size.m_size);
298 constexpr ARCCORE_HOST_DEVICE
void setItem(SizeType i, const_reference v)
noexcept
300 ARCCORE_CHECK_RANGE(i, MinValue,
m_size.m_size);
305 constexpr ARCCORE_HOST_DEVICE SizeType
size() const noexcept {
return m_size.m_size; }
307 constexpr ARCCORE_HOST_DEVICE SizeType
sizeBytes() const noexcept
310 return static_cast<SizeType
>(
m_size.m_size *
sizeof(value_type));
313 constexpr ARCCORE_HOST_DEVICE SizeType
length() const noexcept {
return m_size.m_size; }
318 constexpr ARCCORE_HOST_DEVICE iterator
begin() const noexcept {
return iterator(
m_ptr); }
322 constexpr ARCCORE_HOST_DEVICE iterator
end() const noexcept {
return iterator(
m_ptr +
m_size.m_size); }
324 constexpr ARCCORE_HOST_DEVICE reverse_iterator
rbegin() const noexcept {
return std::make_reverse_iterator(
end()); }
326 constexpr ARCCORE_HOST_DEVICE reverse_iterator
rend() const noexcept {
return std::make_reverse_iterator(
begin()); }
331 ARCCORE_DEPRECATED_REASON(
"Y2023: Use begin()/end() instead")
340 constexpr ARCCORE_HOST_DEVICE pointer
ptrAt(SizeType index)
const
342 ARCCORE_CHECK_AT(index,
m_size.m_size);
343 return m_ptr + index;
347 constexpr ARCCORE_HOST_DEVICE
reference at(SizeType i)
const
354 constexpr ARCCORE_HOST_DEVICE
void setAt(
SizeType i, const_reference value)
361 ARCCORE_HOST_DEVICE
inline void fill(T o)
363 for (SizeType i = 0, n =
m_size.m_size; i < n; ++i)
373 return view_type(s,
m_ptr);
392 constexpr ARCCORE_HOST_DEVICE SubSpanType
subSpan(SizeType abegin, SizeType asize)
const
394 if (abegin >=
m_size.m_size)
396 asize = _min(asize,
m_size.m_size - abegin);
397 return {
m_ptr + abegin, asize };
404 constexpr ARCCORE_HOST_DEVICE SubSpanType
subPart(SizeType abegin, SizeType asize)
const
416 ARCCORE_DEPRECATED_REASON(
"Y2023: use subSpan() instead")
417 constexpr SubSpanType
subView(SizeType abegin, SizeType asize)
const
423 constexpr ARCCORE_HOST_DEVICE SubSpanType
subspan(SizeType abegin, SizeType asize)
const
429 ARCCORE_DEPRECATED_REASON(
"Y2023: use subSpanInterval() instead")
432 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
438 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
444 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
455 template <
class U> ARCCORE_HOST_DEVICE
void copy(
const U& copy_array)
457 Int64 n = copy_array.size();
460 const_pointer copy_begin = copy_array.data();
461 pointer to_ptr =
m_ptr;
464 SizeType n_as_sizetype =
static_cast<SizeType
>(n);
465 for (SizeType i = 0; i < n_as_sizetype; ++i)
466 to_ptr[i] = copy_begin[i];
470 constexpr ARCCORE_HOST_DEVICE
bool empty() const noexcept {
return m_size.m_size == 0; }
472 ARCCORE_HOST_DEVICE
bool contains(const_reference v)
const
474 for (SizeType i = 0; i <
m_size.m_size; ++i) {
487 std::optional<SizeType>
findFirst(const_reference v)
const
489 for (SizeType i = 0; i <
m_size.m_size; ++i) {
498 constexpr ARCCORE_HOST_DEVICE
void setArray(
const ArrayView<T>& v)
noexcept
503 constexpr ARCCORE_HOST_DEVICE
void setArray(
const Span<T>& v)
noexcept
517 constexpr ARCCORE_HOST_DEVICE pointer
data() const noexcept {
return m_ptr; }
520 template <
typename X, SizeType Extent2, SizeType MinValue2,
typename = std::enable_if_t<std::is_same_v<X, value_type>>>
friend bool
527 template <
typename X, SizeType Extent2, SizeType MinValue2,
typename = std::enable_if_t<std::is_same_v<X, value_type>>>
friend bool
534 template <SizeType Extent2, SizeType MinValue2>
friend bool
541 template <SizeType Extent2, SizeType MinValue2>
friend bool
547 friend inline std::ostream&
operator<<(std::ostream& o,
const ThatClass& val)
561 constexpr void _setArray(pointer v, SizeType s)
noexcept
587 [[no_unique_address]] ExtentStorageType
m_size;
591 static constexpr SizeType _min(SizeType a, SizeType b)
593 return ((a < b) ? a : b);
610template <
typename T, Int64 Extent, Int64 MinValue>
612:
public SpanImpl<T, Int64, Extent, MinValue>
618 using size_type =
Int64;
619 using value_type =
typename BaseClass::value_type;
620 using pointer =
typename BaseClass::pointer;
621 template <
typename X>
622 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>>;
630 : BaseClass(from.m_ptr, from.m_size)
634 template <
typename X,
typename = std::enable_if_t<std::is_same_v<X, value_type>>>
636 : BaseClass(from.m_ptr, from.m_size)
639 template <
typename X, Int64 XExtent, Int64 XMinValue,
typename = std::enable_if_t<std::is_same_v<const X, T>>>
644 template <
typename X, Int32 XExtent, Int32 XMinValue,
typename = std::enable_if_t<std::is_same_v<const X, T>>>
645 constexpr ARCCORE_HOST_DEVICE
Span(
const SmallSpan<X, XExtent, XMinValue>& from) noexcept
646 : BaseClass(from.data(), from.size())
648 template <Int64 XExtent, Int64 XMinValue>
652 template <Int32 XExtent, Int32 XMinValue>
654 : BaseClass(from.data(), from.size())
658 constexpr ARCCORE_HOST_DEVICE
Span(pointer ptr,
Int64 asize) noexcept
659 : BaseClass(ptr, asize)
663 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
664 constexpr ARCCORE_HOST_DEVICE
Span(std::array<X, N>& from) noexcept
665 : BaseClass(from.data(), from.size())
669 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
670 constexpr ARCCORE_HOST_DEVICE ThatClass&
operator=(std::array<X, N>& from)
noexcept
681 static constexpr ThatClass
create(pointer ptr, size_type asize)
noexcept
683 return ThatClass(ptr, asize);
727 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
733 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
743 ARCCORE_DEPRECATED_REASON(
"Y2023: use subSpan() instead")
750 ARCCORE_DEPRECATED_REASON(
"Y2023: use subSpanInterval() instead")
753 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
772template <
typename T, Int32 Extent, Int32 MinValue>
774:
public SpanImpl<T, Int32, Extent, MinValue>
780 using size_type =
Int32;
781 using value_type =
typename BaseClass::value_type;
782 using pointer =
typename BaseClass::pointer;
783 template <
typename X>
784 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>>;
793 : BaseClass(from.m_ptr, from.m_size)
798 template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
800 : BaseClass(from.m_ptr, from.m_size)
804 template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
809 template <Int32 XExtent, Int32 XMinValue>
816 : BaseClass(ptr, asize)
819 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
820 constexpr ARCCORE_HOST_DEVICE
SmallSpan(std::array<X, N>& from)
825 template <std::
size_t N,
typename X,
typename = is_same_const_type<X>>
826 constexpr ARCCORE_HOST_DEVICE ThatClass&
operator=(std::array<X, N>& from)
836 static constexpr ThatClass
create(pointer ptr, size_type asize)
noexcept
838 return ThatClass(ptr, asize);
882 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
898 ARCCORE_DEPRECATED_REASON(
"Y2023: use subPart() instead")
905 ARCCORE_DEPRECATED_REASON(
"Y2023: use subPartInterval() instead")
908 return impl::subViewInterval<ThatClass>(*
this, index, nb_interval);
922template <
typename T,
typename SizeType>
inline void
925 impl::dumpArray(o, val, max_print);
938template <
typename DataType,
typename IntegerType,
typename SizeType>
inline void
943 const Int64 result_size = indexes.
size();
944 [[maybe_unused]]
const Int64 my_size = values.
size();
945 const DataType* ptr = values.
data();
946 for (
Int64 i = 0; i < result_size; ++i) {
947 IntegerType index = indexes[i];
948 ARCCORE_CHECK_AT(index, my_size);
949 result[i] = ptr[index];
963template <
typename DataType>
inline void
977template <
typename DataType>
inline void
988template <
typename DataType,
typename SizeType, SizeType Extent>
989inline typename Impl::SpanTypeFromSize<const std::byte, SizeType>::SpanType
992 return {
reinterpret_cast<const std::byte*
>(s.
data()), s.
sizeBytes() };
998template <
typename DataType>
999inline SmallSpan<const std::byte>
1008template <
typename DataType>
1009inline SmallSpan<const std::byte>
1023 typename std::enable_if_t<!std::is_const<DataType>::value,
int> = 0>
1024inline typename Impl::SpanTypeFromSize<std::byte, SizeType>::SpanType
1027 return {
reinterpret_cast<std::byte*
>(s.
data()), s.
sizeBytes() };
1035template <
typename DataType>
inline SmallSpan<std::byte>
1047 template <
typename ByteType,
typename DataType, Int64 Extent>
inline Span<DataType>
1048 asSpanInternal(Span<ByteType, Extent> bytes)
1050 Int64 size = bytes.
size();
1053 static constexpr Int64 data_type_size =
static_cast<Int64>(
sizeof(DataType));
1054 static_assert(data_type_size > 0,
"Bad datatype size");
1055 ARCCORE_ASSERT((size % data_type_size) == 0, (
"Size is not a multiple of sizeof(DataType)"));
1056 auto* ptr =
reinterpret_cast<DataType*
>(bytes.data());
1057 return { ptr, size / data_type_size };
1060 template <
typename ByteType,
typename DataType, Int32 Extent>
inline SmallSpan<DataType>
1061 asSmallSpanInternal(SmallSpan<ByteType, Extent> bytes)
1063 Int32 size = bytes.size();
1066 static constexpr Int32 data_type_size =
static_cast<Int32>(
sizeof(DataType));
1067 static_assert(data_type_size > 0,
"Bad datatype size");
1068 ARCCORE_ASSERT((size % data_type_size) == 0, (
"Size is not a multiple of sizeof(DataType)"));
1069 auto* ptr =
reinterpret_cast<DataType*
>(bytes.data());
1070 return { ptr, size / data_type_size };
1084 return impl::asSpanInternal<std::byte, DataType, Extent>(bytes);
1090template <
typename DataType, Int64 Extent>
inline Span<const DataType>
1093 return impl::asSpanInternal<const std::byte, const DataType, Extent>(bytes);
1099template <
typename DataType, Int32 Extent>
inline SmallSpan<DataType>
1102 return impl::asSmallSpanInternal<std::byte, DataType, Extent>(bytes);
1108template <
typename DataType, Int32 Extent>
inline SmallSpan<const DataType>
1111 return impl::asSmallSpanInternal<const std::byte, const DataType, Extent>(bytes);
1119template <
typename DataType,
size_t SizeType>
inline Span<DataType, SizeType>
1123 return { s.data(), size };
1128template <
typename DataType,
size_t SizeType>
inline SmallSpan<DataType, SizeType>
1132 return { s.data(), size };
1142extern "C++" ARCCORE_BASE_EXPORT
void
1143binaryWrite(std::ostream& ostr,
const Span<const std::byte>& bytes);
1150extern "C++" ARCCORE_BASE_EXPORT
void
1151binaryRead(std::istream& istr,
const Span<std::byte>& bytes);
Itérateur sur les classes tableau de Arccore.
Intervalle sur les classes tableau de Arccore.
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
Spécialisation pour le nombre d'éléments connu à la compilation.
Pour avoir le type (SmallSpan ou Span) en fonction de la taille (Int32 ou Int64)
Vue d'un tableau d'éléments de type T.
static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
constexpr __host__ __device__ SmallSpan< T, DynExtent > subSpanInterval(Int32 index, Int32 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ SmallSpan(pointer ptr, Int32 asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et contenant asize éléments.
constexpr __host__ __device__ SmallSpan< T, DynExtent > subSpan(Int32 abegin, Int32 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
constexpr __host__ __device__ SmallSpan< T, DynExtent > subspan(Int32 abegin, Int32 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
SmallSpan()=default
Construit une vue vide.
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from)
Opérateur de recopie.
constexpr __host__ __device__ ThatClass subPartInterval(Int32 index, Int32 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ SmallSpan< DataType > subViewInterval(Int32 index, Int32 nb_interval) const
constexpr __host__ __device__ SmallSpan< DataType > subView(Int32 abegin, Int32 asize) const
constexpr __host__ __device__ SmallSpan< T, DynExtent > subPart(Int32 abegin, Int32 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
constexpr __host__ __device__ SmallSpan(const ArrayView< value_type > &from) noexcept
Constructeur de recopie depuis une autre vue.
Vue d'un tableau d'éléments de type T.
constexpr __host__ __device__ iterator begin() const noexcept
Itérateur sur le premier élément du tableau.
friend bool operator==(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< X, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'égalité (valide si T est const mais pas X)
constexpr view_type smallView()
Vue constante sur cette vue.
constexpr SubSpanType subViewInterval(SizeType index, SizeType nb_interval) const
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from)
Opérateur de recopie.
__host__ __device__ bool contains(const_reference v) const
true si le tableau contient l'élément de valeur v
constexpr void _setSize(SizeType s) noexcept
Modifie la taille du tableau.
std::optional< SizeType > findFirst(const_reference v) const
constexpr __host__ __device__ SubSpanType subPart(SizeType abegin, SizeType asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
__host__ __device__ void copy(const U ©_array)
Recopie le tableau copy_array dans l'instance.
constexpr __host__ __device__ SpanImpl() noexcept
Construit une vue vide.
constexpr __host__ __device__ void setItem(SizeType i, const_reference v) noexcept
Positionne le i-ème élément du tableau.
constexpr __host__ __device__ pointer ptrAt(SizeType index) const
Adresse du index-ème élément.
constexpr SubSpanType subPartInterval(SizeType index, SizeType nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ reference operator()(SizeType i) const
i-ème élément du tableau.
constexpr ConstArrayView< value_type > constSmallView() const
Vue constante sur cette vue.
constexpr __host__ __device__ SpanImpl(std::array< X, N > &from)
Construit une vue depuis un std::array.
constexpr __host__ __device__ iterator end() const noexcept
Itérateur sur le premier élément après la fin du tableau.
static constexpr ThatClass create(pointer ptr, SizeType asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
constexpr __host__ __device__ reverse_iterator rend() const noexcept
Itérateur inverse sur le premier élément après la fin du tableau.
ArrayRange< pointer > range() const
constexpr SubSpanType subSpanInterval(SizeType index, SizeType nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ SpanImpl(pointer ptr, SizeType asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et contenant asize éléments.
constexpr __host__ __device__ SpanImpl(const SpanImpl< X, SizeType, XExtent, XMinValue > &from) noexcept
Constructeur de recopie depuis une autre vue.
std::enable_if_t< std::is_same_v< X, T >||std::is_same_v< std::add_const_t< X >, T > > is_same_const_type
constexpr void _setPtr(pointer v) noexcept
Modifie le pointeur du début du tableau.
constexpr void _setArray(pointer v, SizeType s) noexcept
Modifie le pointeur et la taille du tableau.
constexpr SubSpanType subView(SizeType abegin, SizeType asize) const
constexpr __host__ __device__ bool empty() const noexcept
Retourne true si le tableau est vide (dimension nulle)
constexpr __host__ __device__ SizeType sizeBytes() const noexcept
Retourne la taille du tableau en octets.
friend bool operator!=(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< X, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'inégalité (valide si T est const mais pas X)
constexpr __host__ __device__ SizeType size() const noexcept
constexpr __host__ __device__ reference operator[](SizeType i) const
i-ème élément du tableau.
friend bool operator==(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< T, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'égalité
constexpr __host__ __device__ pointer data() const noexcept
constexpr __host__ __device__ reference item(SizeType i) const
i-ème élément du tableau.
friend bool operator!=(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< T, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'inégalité
constexpr __host__ __device__ SizeType length() const noexcept
Nombre d'éléments du tableau.
constexpr __host__ __device__ SubSpanType subspan(SizeType abegin, SizeType asize) const
Pour compatibilité avec le C++20.
__host__ __device__ void fill(T o)
Remplit le tableau avec la valeur o.
constexpr __host__ __device__ reverse_iterator rbegin() const noexcept
Itérateur inverse sur le premier élément du tableau.
constexpr __host__ __device__ SubSpanType subSpan(SizeType abegin, SizeType asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Vue d'un tableau d'éléments de type T.
constexpr __host__ __device__ Span< T, DynExtent > subSpan(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
constexpr __host__ __device__ Span(std::array< X, N > &from) noexcept
Construit une vue à partir d'un std::array.
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from) noexcept
Opérateur de recopie.
constexpr __host__ __device__ Span< DataType > subViewInterval(Int64 index, Int64 nb_interval) const
static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
constexpr __host__ __device__ Span(pointer ptr, Int64 asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et contenant asize éléments.
constexpr __host__ __device__ Span< T, DynExtent > subspan(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
constexpr __host__ __device__ Span< T, DynExtent > subPart(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
constexpr __host__ __device__ Span< T, DynExtent > subSpanInterval(Int64 index, Int64 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ Span(const ArrayView< value_type > &from) noexcept
Constructeur de recopie depuis une autre vue.
Span()=default
Construit une vue vide.
constexpr __host__ __device__ Span< T, DynExtent > subPartInterval(Int64 index, Int64 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
constexpr __host__ __device__ Span< DataType > subView(Int64 abegin, Int64 asize) const
std::ostream & operator<<(std::ostream &o, eExecutionPolicy exec_policy)
Affiche le nom de la politique d'exécution.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
constexpr __host__ __device__ Integer arccoreCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
constexpr Int32 DynExtent
Constante pour indiquer que la dimension d'un tableau est dynamique.
__host__ __device__ void arccoreCheckAt(Int64 i, Int64 max_size)
Vérifie un éventuel débordement de tableau.
void dumpArray(std::ostream &o, ConstArrayView< T > val, int max_print)
Affiche sur le flot o les valeurs du tableau val.
void sampleSpan(Span< const DataType > values, Span< const Int64 > indexes, Span< DataType > result)
Extrait un sous-tableau à à partir d'une liste d'index.
SmallSpan< DataType > asSmallSpan(SmallSpan< std::byte, Extent > bytes)
Converti un SmallSpan<std::byte> en un SmallSpan<DataType>.
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
void binaryRead(std::istream &istr, const Span< std::byte > &bytes)
Lit en binaire le contenu de bytes depuis le flot istr.
Impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Impl::SpanTypeFromSize< std::byte, SizeType >::SpanType asWritableBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets modifiables.
void _sampleSpan(SpanImpl< const DataType, SizeType > values, SpanImpl< const IntegerType, SizeType > indexes, SpanImpl< DataType, SizeType > result)
Extrait un sous-tableau à à partir d'une liste d'index.
void binaryWrite(std::ostream &ostr, const Span< const std::byte > &bytes)
Ecrit en binaire le contenu de bytes sur le flot ostr.
std::int32_t Int32
Type entier signé sur 32 bits.
Espace de nom de Arccore.
RAPIDJSON_NAMESPACE_BEGIN typedef unsigned SizeType
Size type (for string lengths, array sizes, etc.)