Arcane  v4.1.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Span.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* Span.h (C) 2000-2025 */
9/* */
10/* Vues sur des tableaux C. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCCORE_BASE_SPAN_H
13#define ARCCORE_BASE_SPAN_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arccore/base/ArrayView.h"
18
19#include <type_traits>
20#include <optional>
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::Impl
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30
31// Pour indiquer que Span<T>::view() retourne un ArrayView
32// et Span<const T>::view() retourne un ConstArrayView.
33template <typename T>
35{
36 public:
37
38 using view_type = ArrayView<T>;
39};
40template <typename T>
41class ViewTypeT<const T>
42{
43 public:
44
45 using view_type = ConstArrayView<T>;
46};
47
49template <typename T, typename SizeType>
51
52template <typename T>
54{
55 public:
56
57 using SpanType = SmallSpan<T>;
58};
59
60template <typename T>
62{
63 public:
64
65 using SpanType = Span<T>;
66};
67
68/*---------------------------------------------------------------------------*/
69/*---------------------------------------------------------------------------*/
76template <typename SizeType>
77class DynamicExtentStorage
78{
79 template <typename T, typename SpanSizeType, SpanSizeType SpanExtent, SpanSizeType MinValue>
80 friend class ::Arcane::SpanImpl;
81
82 public:
83
84 explicit constexpr DynamicExtentStorage(SizeType s) noexcept
85 : m_size(s)
86 {}
87
88 public:
89
90 constexpr SizeType size() const noexcept { return m_size; }
91
92 private:
93
94 SizeType m_size;
95};
96
98template <typename SizeType, SizeType FixedExtent>
99class ExtentStorage
100{
101 template <typename T, typename SpanSizeType, SpanSizeType SpanExtent, SpanSizeType MinValue>
102 friend class ::Arcane::SpanImpl;
103
104 public:
105
106 explicit constexpr ExtentStorage(SizeType) noexcept {}
107
108 public:
109
110 constexpr SizeType size() const noexcept { return FixedExtent; }
111
112 private:
113
114 static constexpr SizeType m_size = FixedExtent;
115};
116
118template <>
119class ExtentStorage<Int32, DynExtent>
120: public DynamicExtentStorage<Int32>
121{
122 using BaseClass = DynamicExtentStorage<Int32>;
123
124 public:
125
126 explicit constexpr ExtentStorage(Int32 s) noexcept
127 : BaseClass(s)
128 {}
129};
130
132template <>
133class ExtentStorage<Int64, DynExtent>
134: public DynamicExtentStorage<Int64>
135{
136 using BaseClass = DynamicExtentStorage<Int64>;
137
138 public:
139
140 explicit constexpr ExtentStorage(Int64 s) noexcept
141 : BaseClass(s)
142 {}
143};
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
148} // namespace Arcane::Impl
149
150/*---------------------------------------------------------------------------*/
151/*---------------------------------------------------------------------------*/
152
153namespace Arcane
154{
155
156/*---------------------------------------------------------------------------*/
157/*---------------------------------------------------------------------------*/
175template <typename T, typename SizeType, SizeType Extent, SizeType MinValue>
177{
178 using ExtentStorageType = Impl::ExtentStorage<SizeType, Extent>;
179
180 public:
181
183 using SubSpanType = SpanImpl<T, SizeType, DynExtent, 0>;
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&;
195 using iterator = ArrayIterator<pointer>;
196 using const_iterator = ArrayIterator<const_pointer>;
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>;
200
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>>;
204
205 public:
206
208 constexpr ARCCORE_HOST_DEVICE SpanImpl() noexcept
209 : m_ptr(nullptr)
210 , m_size(0)
211 {}
212
214 // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
215 template <typename X, SizeType XExtent, SizeType XMinValue, typename = std::enable_if_t<std::is_same_v<const X, T>>>
216 constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<X, SizeType, XExtent, XMinValue>& from) noexcept
217 : m_ptr(from.data())
218 , m_size(from.size())
219 {}
220
221 template <SizeType XExtent, SizeType XMinValue>
222 constexpr ARCCORE_HOST_DEVICE SpanImpl(const SpanImpl<T, SizeType, XExtent, XMinValue>& from) noexcept
223 : m_ptr(from.data())
224 , m_size(from.size())
225 {}
226
228 constexpr ARCCORE_HOST_DEVICE SpanImpl(pointer ptr, SizeType asize) noexcept
229 : m_ptr(ptr)
230 , m_size(asize)
231 {}
232
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)
236 : m_ptr(from.data())
237 , m_size(ArraySizeChecker<SizeType>::check(from.size()))
238 {}
239
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)
243 {
244 m_ptr = from.data();
245 m_size = ExtentStorageType(ArraySizeChecker<SizeType>::check(from.size()));
246 return (*this);
247 }
248
249 public:
250
252 // contenant \a asize éléments.
253 static constexpr ThatClass create(pointer ptr, SizeType asize) noexcept
254 {
255 return ThatClass(ptr, asize);
256 }
257
258 public:
259
265 constexpr ARCCORE_HOST_DEVICE reference operator[](SizeType i) const
266 {
267 ARCCORE_CHECK_RANGE(i, MinValue, m_size.m_size);
268 return m_ptr[i];
269 }
270
276 constexpr ARCCORE_HOST_DEVICE reference operator()(SizeType i) const
277 {
278 ARCCORE_CHECK_RANGE(i, MinValue, m_size.m_size);
279 return m_ptr[i];
280 }
281
287 constexpr ARCCORE_HOST_DEVICE reference item(SizeType i) const
288 {
289 ARCCORE_CHECK_RANGE(i, MinValue, m_size.m_size);
290 return m_ptr[i];
291 }
292
298 constexpr ARCCORE_HOST_DEVICE void setItem(SizeType i, const_reference v) noexcept
299 {
300 ARCCORE_CHECK_RANGE(i, MinValue, m_size.m_size);
301 m_ptr[i] = v;
302 }
303
305 constexpr ARCCORE_HOST_DEVICE SizeType size() const noexcept { return m_size.m_size; }
307 constexpr ARCCORE_HOST_DEVICE SizeType sizeBytes() const noexcept
308 {
309 // TODO: retourner toujours un Int64
310 return static_cast<SizeType>(m_size.m_size * sizeof(value_type));
311 }
312
313 constexpr ARCCORE_HOST_DEVICE SizeType length() const noexcept { return m_size.m_size; }
314
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()); }
327
328 public:
329
331 ARCCORE_DEPRECATED_REASON("Y2023: Use begin()/end() instead")
332 ArrayRange<pointer> range() const
333 {
334 return ArrayRange<pointer>(m_ptr, m_ptr + m_size.m_size);
335 }
336
337 public:
338
340 constexpr ARCCORE_HOST_DEVICE pointer ptrAt(SizeType index) const
341 {
342 ARCCORE_CHECK_AT(index, m_size.m_size);
343 return m_ptr + index;
344 }
345
346 // Elément d'indice \a i. Vérifie toujours les débordements
347 constexpr ARCCORE_HOST_DEVICE reference at(SizeType i) const
348 {
349 arccoreCheckAt(i, m_size.m_size);
350 return m_ptr[i];
351 }
352
353 // Positionne l'élément d'indice \a i. Vérifie toujours les débordements
354 constexpr ARCCORE_HOST_DEVICE void setAt(SizeType i, const_reference value)
355 {
356 arccoreCheckAt(i, m_size.m_size);
357 m_ptr[i] = value;
358 }
359
361 ARCCORE_HOST_DEVICE inline void fill(T o)
362 {
363 for (SizeType i = 0, n = m_size.m_size; i < n; ++i)
364 m_ptr[i] = o;
365 }
366
370 constexpr view_type smallView()
371 {
373 return view_type(s, m_ptr);
374 }
375
384
392 constexpr ARCCORE_HOST_DEVICE SubSpanType subSpan(SizeType abegin, SizeType asize) const
393 {
394 if (abegin >= m_size.m_size)
395 return {};
396 asize = _min(asize, m_size.m_size - abegin);
397 return { m_ptr + abegin, asize };
398 }
399
404 constexpr ARCCORE_HOST_DEVICE SubSpanType subPart(SizeType abegin, SizeType asize) const
405 {
406 return subSpan(abegin, asize);
407 }
408
416 ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
417 constexpr SubSpanType subView(SizeType abegin, SizeType asize) const
418 {
419 return subSpan(abegin, asize);
420 }
421
423 constexpr ARCCORE_HOST_DEVICE SubSpanType subspan(SizeType abegin, SizeType asize) const
424 {
425 return subSpan(abegin, asize);
426 }
427
429 ARCCORE_DEPRECATED_REASON("Y2023: use subSpanInterval() instead")
430 constexpr SubSpanType subViewInterval(SizeType index, SizeType nb_interval) const
431 {
432 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
433 }
434
436 constexpr SubSpanType subSpanInterval(SizeType index, SizeType nb_interval) const
437 {
438 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
439 }
440
442 constexpr SubSpanType subPartInterval(SizeType index, SizeType nb_interval) const
443 {
444 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
445 }
446
455 template <class U> ARCCORE_HOST_DEVICE void copy(const U& copy_array)
456 {
457 Int64 n = copy_array.size();
458 Int64 size_as_int64 = m_size.m_size;
459 arccoreCheckAt(n, size_as_int64 + 1);
460 const_pointer copy_begin = copy_array.data();
461 pointer to_ptr = m_ptr;
462 // On est sur que \a n tient sur un 'SizeType' car il est plus petit
463 // que \a m_size
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];
467 }
468
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
473 {
474 for (SizeType i = 0; i < m_size.m_size; ++i) {
475 if (m_ptr[i] == v)
476 return true;
477 }
478 return false;
479 }
480
487 std::optional<SizeType> findFirst(const_reference v) const
488 {
489 for (SizeType i = 0; i < m_size.m_size; ++i) {
490 if (m_ptr[i] == v)
491 return i;
492 }
493 return std::nullopt;
494 }
495
496 public:
497
498 constexpr ARCCORE_HOST_DEVICE void setArray(const ArrayView<T>& v) noexcept
499 {
500 m_ptr = v.m_ptr;
501 m_size = v.m_size;
502 }
503 constexpr ARCCORE_HOST_DEVICE void setArray(const Span<T>& v) noexcept
504 {
505 m_ptr = v.m_ptr;
506 m_size = v.m_size;
507 }
508
517 constexpr ARCCORE_HOST_DEVICE pointer data() const noexcept { return m_ptr; }
518
520 template <typename X, SizeType Extent2, SizeType MinValue2, typename = std::enable_if_t<std::is_same_v<X, value_type>>> friend bool
525
527 template <typename X, SizeType Extent2, SizeType MinValue2, typename = std::enable_if_t<std::is_same_v<X, value_type>>> friend bool
532
534 template <SizeType Extent2, SizeType MinValue2> friend bool
539
541 template <SizeType Extent2, SizeType MinValue2> friend bool
546
547 friend inline std::ostream& operator<<(std::ostream& o, const ThatClass& val)
548 {
549 impl::dumpArray(o, Span<const T, DynExtent>(val.data(), val.size()), 500);
550 return o;
551 }
552
553 protected:
554
561 constexpr void _setArray(pointer v, SizeType s) noexcept
562 {
563 m_ptr = v;
564 m_size = s;
565 }
566
573 constexpr void _setPtr(pointer v) noexcept { m_ptr = v; }
574
581 constexpr void _setSize(SizeType s) noexcept { m_size = ExtentStorageType(s); }
582
583 private:
584
585 pointer m_ptr;
587 [[no_unique_address]] ExtentStorageType m_size;
588
589 private:
590
591 static constexpr SizeType _min(SizeType a, SizeType b)
592 {
593 return ((a < b) ? a : b);
594 }
595};
596
597/*---------------------------------------------------------------------------*/
598/*---------------------------------------------------------------------------*/
610template <typename T, Int64 Extent, Int64 MinValue>
611class Span
612: public SpanImpl<T, Int64, Extent, MinValue>
613{
614 public:
615
616 using ThatClass = Span<T, Extent, MinValue>;
617 using BaseClass = 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>>;
623
624 public:
625
627 Span() = default;
629 constexpr ARCCORE_HOST_DEVICE Span(const ArrayView<value_type>& from) noexcept
630 : BaseClass(from.m_ptr, from.m_size)
631 {}
632 // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
633 // si T est const.
634 template <typename X, typename = std::enable_if_t<std::is_same_v<X, value_type>>>
635 constexpr ARCCORE_HOST_DEVICE Span(const ConstArrayView<X>& from) noexcept
636 : BaseClass(from.m_ptr, from.m_size)
637 {}
638 // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
639 template <typename X, Int64 XExtent, Int64 XMinValue, typename = std::enable_if_t<std::is_same_v<const X, T>>>
640 constexpr ARCCORE_HOST_DEVICE Span(const Span<X, XExtent, XMinValue>& from) noexcept
641 : BaseClass(from)
642 {}
643 // Pour un Span<const T>, on a le droit de construire depuis un SmallSpan<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())
647 {}
648 template <Int64 XExtent, Int64 XMinValue>
649 constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int64, XExtent, XMinValue>& from) noexcept
650 : BaseClass(from)
651 {}
652 template <Int32 XExtent, Int32 XMinValue>
653 constexpr ARCCORE_HOST_DEVICE Span(const SpanImpl<T, Int32, XExtent, XMinValue>& from) noexcept
654 : BaseClass(from.data(), from.size())
655 {}
656
658 constexpr ARCCORE_HOST_DEVICE Span(pointer ptr, Int64 asize) noexcept
659 : BaseClass(ptr, asize)
660 {}
661
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())
666 {}
667
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
671 {
672 this->_setPtr(from.data());
673 this->_setSize(from.size());
674 return (*this);
675 }
676
677 public:
678
680 // contenant \a asize éléments.
681 static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
682 {
683 return ThatClass(ptr, asize);
684 }
685
686 public:
687
695 constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subspan(Int64 abegin, Int64 asize) const
696 {
697 return BaseClass::subspan(abegin, asize);
698 }
699
707 constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subSpan(Int64 abegin, Int64 asize) const
708 {
709 return BaseClass::subSpan(abegin, asize);
710 }
711
719 constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPart(Int64 abegin, Int64 asize) const
720 {
721 return BaseClass::subPart(abegin, asize);
722 }
723
725 constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subSpanInterval(Int64 index, Int64 nb_interval) const
726 {
727 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
728 }
729
731 constexpr ARCCORE_HOST_DEVICE Span<T, DynExtent> subPartInterval(Int64 index, Int64 nb_interval) const
732 {
733 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
734 }
735
743 ARCCORE_DEPRECATED_REASON("Y2023: use subSpan() instead")
744 constexpr ARCCORE_HOST_DEVICE Span<T> subView(Int64 abegin, Int64 asize) const
745 {
746 return subspan(abegin, asize);
747 }
748
750 ARCCORE_DEPRECATED_REASON("Y2023: use subSpanInterval() instead")
751 constexpr ARCCORE_HOST_DEVICE Span<T> subViewInterval(Int64 index, Int64 nb_interval) const
752 {
753 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
754 }
755};
756
757/*---------------------------------------------------------------------------*/
758/*---------------------------------------------------------------------------*/
772template <typename T, Int32 Extent, Int32 MinValue>
774: public SpanImpl<T, Int32, Extent, MinValue>
775{
776 public:
777
778 using ThatClass = SmallSpan<T, Extent, MinValue>;
779 using BaseClass = 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>>;
785
786 public:
787
789 SmallSpan() = default;
790
792 constexpr ARCCORE_HOST_DEVICE SmallSpan(const ArrayView<value_type>& from) noexcept
793 : BaseClass(from.m_ptr, from.m_size)
794 {}
795
796 // Constructeur à partir d'un ConstArrayView. Cela n'est autorisé que
797 // si T est const.
798 template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
799 constexpr ARCCORE_HOST_DEVICE SmallSpan(const ConstArrayView<X>& from) noexcept
800 : BaseClass(from.m_ptr, from.m_size)
801 {}
802
803 // Pour un Span<const T>, on a le droit de construire depuis un Span<T>
804 template <typename X, typename = std::enable_if_t<std::is_same<X, value_type>::value>>
805 constexpr ARCCORE_HOST_DEVICE SmallSpan(const SmallSpan<X>& from) noexcept
806 : BaseClass(from)
807 {}
808
809 template <Int32 XExtent, Int32 XMinValue>
810 constexpr ARCCORE_HOST_DEVICE SmallSpan(const SpanImpl<T, Int32, XExtent, XMinValue>& from) noexcept
811 : BaseClass(from)
812 {}
813
815 constexpr ARCCORE_HOST_DEVICE SmallSpan(pointer ptr, Int32 asize) noexcept
816 : BaseClass(ptr, asize)
817 {}
818
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)
821 : BaseClass(from)
822 {}
823
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)
827 {
829 return (*this);
830 }
831
832 public:
833
835 // contenant \a asize éléments.
836 static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
837 {
838 return ThatClass(ptr, asize);
839 }
840
841 public:
842
850 constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subspan(Int32 abegin, Int32 asize) const
851 {
852 return BaseClass::subspan(abegin, asize);
853 }
854
862 constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpan(Int32 abegin, Int32 asize) const
863 {
864 return BaseClass::subSpan(abegin, asize);
865 }
866
874 constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subPart(Int32 abegin, Int32 asize) const
875 {
876 return BaseClass::subSpan(abegin, asize);
877 }
878
880 constexpr ARCCORE_HOST_DEVICE SmallSpan<T, DynExtent> subSpanInterval(Int32 index, Int32 nb_interval) const
881 {
882 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
883 }
884
886 constexpr ARCCORE_HOST_DEVICE ThatClass subPartInterval(Int32 index, Int32 nb_interval) const
887 {
888 return subSpanInterval(index, nb_interval);
889 }
890
898 ARCCORE_DEPRECATED_REASON("Y2023: use subPart() instead")
899 constexpr ARCCORE_HOST_DEVICE SmallSpan<T> subView(Int32 abegin, Int32 asize) const
900 {
901 return subspan(abegin, asize);
902 }
903
905 ARCCORE_DEPRECATED_REASON("Y2023: use subPartInterval() instead")
906 constexpr ARCCORE_HOST_DEVICE SmallSpan<T> subViewInterval(Int32 index, Int32 nb_interval) const
907 {
908 return impl::subViewInterval<ThatClass>(*this, index, nb_interval);
909 }
910};
911
912/*---------------------------------------------------------------------------*/
913/*---------------------------------------------------------------------------*/
922template <typename T, typename SizeType> inline void
923dumpArray(std::ostream& o, SpanImpl<const T, SizeType> val, int max_print)
924{
925 impl::dumpArray(o, val, max_print);
926}
927
928/*---------------------------------------------------------------------------*/
929/*---------------------------------------------------------------------------*/
938template <typename DataType, typename IntegerType, typename SizeType> inline void
942{
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];
950 }
951}
952
953/*---------------------------------------------------------------------------*/
954/*---------------------------------------------------------------------------*/
963template <typename DataType> inline void
965{
966 _sampleSpan<DataType, Int64, Int64>(values, indexes, result);
967}
968
969/*---------------------------------------------------------------------------*/
970/*---------------------------------------------------------------------------*/
977template <typename DataType> inline void
979{
980 _sampleSpan<DataType, Int32, Int64>(values, indexes, result);
981}
982
983/*---------------------------------------------------------------------------*/
984/*---------------------------------------------------------------------------*/
988template <typename DataType, typename SizeType, SizeType Extent>
989inline typename Impl::SpanTypeFromSize<const std::byte, SizeType>::SpanType
991{
992 return { reinterpret_cast<const std::byte*>(s.data()), s.sizeBytes() };
993}
994
998template <typename DataType>
999inline SmallSpan<const std::byte>
1001{
1002 return asBytes(SmallSpan<DataType>(s));
1003}
1004
1008template <typename DataType>
1009inline SmallSpan<const std::byte>
1014
1015/*---------------------------------------------------------------------------*/
1016/*---------------------------------------------------------------------------*/
1022template <typename DataType, typename SizeType, SizeType Extent,
1023 typename std::enable_if_t<!std::is_const<DataType>::value, int> = 0>
1024inline typename Impl::SpanTypeFromSize<std::byte, SizeType>::SpanType
1026{
1027 return { reinterpret_cast<std::byte*>(s.data()), s.sizeBytes() };
1028}
1029
1035template <typename DataType> inline SmallSpan<std::byte>
1040
1041/*---------------------------------------------------------------------------*/
1042/*---------------------------------------------------------------------------*/
1043
1044namespace impl
1045{
1046
1047 template <typename ByteType, typename DataType, Int64 Extent> inline Span<DataType>
1048 asSpanInternal(Span<ByteType, Extent> bytes)
1049 {
1050 Int64 size = bytes.size();
1051 if (size == 0)
1052 return {};
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 };
1058 }
1059
1060 template <typename ByteType, typename DataType, Int32 Extent> inline SmallSpan<DataType>
1061 asSmallSpanInternal(SmallSpan<ByteType, Extent> bytes)
1062 {
1063 Int32 size = bytes.size();
1064 if (size == 0)
1065 return {};
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 };
1071 }
1072
1073} // namespace impl
1074
1075/*---------------------------------------------------------------------------*/
1076/*---------------------------------------------------------------------------*/
1081template <typename DataType, Int64 Extent> inline Span<DataType>
1083{
1084 return impl::asSpanInternal<std::byte, DataType, Extent>(bytes);
1085}
1086
1090template <typename DataType, Int64 Extent> inline Span<const DataType>
1092{
1093 return impl::asSpanInternal<const std::byte, const DataType, Extent>(bytes);
1094}
1095
1099template <typename DataType, Int32 Extent> inline SmallSpan<DataType>
1101{
1102 return impl::asSmallSpanInternal<std::byte, DataType, Extent>(bytes);
1103}
1104
1108template <typename DataType, Int32 Extent> inline SmallSpan<const DataType>
1110{
1111 return impl::asSmallSpanInternal<const std::byte, const DataType, Extent>(bytes);
1112}
1113
1114/*---------------------------------------------------------------------------*/
1115/*---------------------------------------------------------------------------*/
1119template <typename DataType, size_t SizeType> inline Span<DataType, SizeType>
1120asSpan(std::array<DataType, SizeType>& s)
1121{
1122 Int64 size = static_cast<Int64>(s.size());
1123 return { s.data(), size };
1124}
1125
1128template <typename DataType, size_t SizeType> inline SmallSpan<DataType, SizeType>
1129asSmallSpan(std::array<DataType, SizeType>& s)
1130{
1131 Int32 size = static_cast<Int32>(s.size());
1132 return { s.data(), size };
1133}
1134
1135/*---------------------------------------------------------------------------*/
1136/*---------------------------------------------------------------------------*/
1142extern "C++" ARCCORE_BASE_EXPORT void
1143binaryWrite(std::ostream& ostr, const Span<const std::byte>& bytes);
1144
1150extern "C++" ARCCORE_BASE_EXPORT void
1151binaryRead(std::istream& istr, const Span<std::byte>& bytes);
1152
1153/*---------------------------------------------------------------------------*/
1154/*---------------------------------------------------------------------------*/
1155
1156} // namespace Arcane
1157
1158/*---------------------------------------------------------------------------*/
1159/*---------------------------------------------------------------------------*/
1160
1161namespace Arccore
1162{
1163using Arcane::asBytes;
1165using Arcane::asSpan;
1167using Arcane::binaryRead;
1169using Arcane::sampleSpan;
1170} // namespace Arccore
1171
1172/*---------------------------------------------------------------------------*/
1173/*---------------------------------------------------------------------------*/
1174
1175#endif
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.
Definition Span.h:100
Pour avoir le type (SmallSpan ou Span) en fonction de la taille (Int32 ou Int64)
Definition Span.h:50
Vue d'un tableau d'éléments de type T.
Definition Span.h:775
static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
Definition Span.h:836
constexpr __host__ __device__ SmallSpan< T, DynExtent > subSpanInterval(Int32 index, Int32 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
Definition Span.h:880
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.
Definition Span.h:815
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.
Definition Span.h:862
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.
Definition Span.h:850
SmallSpan()=default
Construit une vue vide.
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from)
Opérateur de recopie.
Definition Span.h:826
constexpr __host__ __device__ ThatClass subPartInterval(Int32 index, Int32 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
Definition Span.h:886
constexpr __host__ __device__ SmallSpan< DataType > subViewInterval(Int32 index, Int32 nb_interval) const
Definition Span.h:906
constexpr __host__ __device__ SmallSpan< DataType > subView(Int32 abegin, Int32 asize) const
Definition Span.h:899
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.
Definition Span.h:874
constexpr __host__ __device__ SmallSpan(const ArrayView< value_type > &from) noexcept
Constructeur de recopie depuis une autre vue.
Definition Span.h:792
Vue d'un tableau d'éléments de type T.
Definition Span.h:177
constexpr __host__ __device__ iterator begin() const noexcept
Itérateur sur le premier élément du tableau.
Definition Span.h:318
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)
Definition Span.h:521
constexpr view_type smallView()
Vue constante sur cette vue.
Definition Span.h:370
constexpr SubSpanType subViewInterval(SizeType index, SizeType nb_interval) const
Definition Span.h:430
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from)
Opérateur de recopie.
Definition Span.h:242
__host__ __device__ bool contains(const_reference v) const
true si le tableau contient l'élément de valeur v
Definition Span.h:472
constexpr void _setSize(SizeType s) noexcept
Modifie la taille du tableau.
Definition Span.h:581
std::optional< SizeType > findFirst(const_reference v) const
Definition Span.h:487
constexpr __host__ __device__ SubSpanType subPart(SizeType abegin, SizeType asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Definition Span.h:404
__host__ __device__ void copy(const U &copy_array)
Recopie le tableau copy_array dans l'instance.
Definition Span.h:455
constexpr __host__ __device__ SpanImpl() noexcept
Construit une vue vide.
Definition Span.h:208
constexpr __host__ __device__ void setItem(SizeType i, const_reference v) noexcept
Positionne le i-ème élément du tableau.
Definition Span.h:298
constexpr __host__ __device__ pointer ptrAt(SizeType index) const
Adresse du index-ème élément.
Definition Span.h:340
constexpr SubSpanType subPartInterval(SizeType index, SizeType nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
Definition Span.h:442
constexpr __host__ __device__ reference operator()(SizeType i) const
i-ème élément du tableau.
Definition Span.h:276
constexpr ConstArrayView< value_type > constSmallView() const
Vue constante sur cette vue.
Definition Span.h:379
constexpr __host__ __device__ SpanImpl(std::array< X, N > &from)
Construit une vue depuis un std::array.
Definition Span.h:235
constexpr __host__ __device__ iterator end() const noexcept
Itérateur sur le premier élément après la fin du tableau.
Definition Span.h:322
static constexpr ThatClass create(pointer ptr, SizeType asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
Definition Span.h:253
constexpr __host__ __device__ reverse_iterator rend() const noexcept
Itérateur inverse sur le premier élément après la fin du tableau.
Definition Span.h:326
ArrayRange< pointer > range() const
Definition Span.h:332
constexpr SubSpanType subSpanInterval(SizeType index, SizeType nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
Definition Span.h:436
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.
Definition Span.h:228
constexpr __host__ __device__ SpanImpl(const SpanImpl< X, SizeType, XExtent, XMinValue > &from) noexcept
Constructeur de recopie depuis une autre vue.
Definition Span.h:216
std::enable_if_t< std::is_same_v< X, T >||std::is_same_v< std::add_const_t< X >, T > > is_same_const_type
Definition Span.h:203
constexpr void _setPtr(pointer v) noexcept
Modifie le pointeur du début du tableau.
Definition Span.h:573
constexpr void _setArray(pointer v, SizeType s) noexcept
Modifie le pointeur et la taille du tableau.
Definition Span.h:561
constexpr SubSpanType subView(SizeType abegin, SizeType asize) const
Definition Span.h:417
constexpr __host__ __device__ bool empty() const noexcept
Retourne true si le tableau est vide (dimension nulle)
Definition Span.h:470
constexpr __host__ __device__ SizeType sizeBytes() const noexcept
Retourne la taille du tableau en octets.
Definition Span.h:307
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)
Definition Span.h:528
constexpr __host__ __device__ SizeType size() const noexcept
Definition Span.h:305
constexpr __host__ __device__ reference operator[](SizeType i) const
i-ème élément du tableau.
Definition Span.h:265
friend bool operator==(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< T, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'égalité
Definition Span.h:535
constexpr __host__ __device__ pointer data() const noexcept
Definition Span.h:517
constexpr __host__ __device__ reference item(SizeType i) const
i-ème élément du tableau.
Definition Span.h:287
friend bool operator!=(const SpanImpl< T, SizeType, Extent, MinValue > &rhs, const SpanImpl< T, SizeType, Extent2, MinValue2 > &lhs)
Opérateur d'inégalité
Definition Span.h:542
constexpr __host__ __device__ SizeType length() const noexcept
Nombre d'éléments du tableau.
Definition Span.h:313
constexpr __host__ __device__ SubSpanType subspan(SizeType abegin, SizeType asize) const
Pour compatibilité avec le C++20.
Definition Span.h:423
__host__ __device__ void fill(T o)
Remplit le tableau avec la valeur o.
Definition Span.h:361
constexpr __host__ __device__ reverse_iterator rbegin() const noexcept
Itérateur inverse sur le premier élément du tableau.
Definition Span.h:324
constexpr __host__ __device__ SubSpanType subSpan(SizeType abegin, SizeType asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Definition Span.h:392
Vue d'un tableau d'éléments de type T.
Definition Span.h:613
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.
Definition Span.h:707
constexpr __host__ __device__ Span(std::array< X, N > &from) noexcept
Construit une vue à partir d'un std::array.
Definition Span.h:664
constexpr __host__ __device__ ThatClass & operator=(std::array< X, N > &from) noexcept
Opérateur de recopie.
Definition Span.h:670
constexpr __host__ __device__ Span< DataType > subViewInterval(Int64 index, Int64 nb_interval) const
Definition Span.h:751
static constexpr ThatClass create(pointer ptr, size_type asize) noexcept
Construit une vue sur une zone mémoire commencant par ptr et.
Definition Span.h:681
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.
Definition Span.h:658
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.
Definition Span.h:695
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.
Definition Span.h:719
constexpr __host__ __device__ Span< T, DynExtent > subSpanInterval(Int64 index, Int64 nb_interval) const
Sous-vue correspondant à l'interval index sur nb_interval.
Definition Span.h:725
constexpr __host__ __device__ Span(const ArrayView< value_type > &from) noexcept
Constructeur de recopie depuis une autre vue.
Definition Span.h:629
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.
Definition Span.h:731
constexpr __host__ __device__ Span< DataType > subView(Int64 abegin, Int64 asize) const
Definition Span.h:744
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.
Definition BaseTypes.h:54
__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.
Definition Span.h:964
SmallSpan< DataType > asSmallSpan(SmallSpan< std::byte, Extent > bytes)
Converti un SmallSpan<std::byte> en un SmallSpan<DataType>.
Definition Span.h:1100
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
Definition Span.h:1082
void binaryRead(std::istream &istr, const Span< std::byte > &bytes)
Lit en binaire le contenu de bytes depuis le flot istr.
Definition ArrayView.cc:70
Impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Definition Span.h:990
Impl::SpanTypeFromSize< std::byte, SizeType >::SpanType asWritableBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets modifiables.
Definition Span.h:1025
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.
Definition Span.h:939
void binaryWrite(std::ostream &ostr, const Span< const std::byte > &bytes)
Ecrit en binaire le contenu de bytes sur le flot ostr.
Definition ArrayView.cc:60
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.)
Definition rapidjson.h:416