Arcane  4.2.3.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SerializerExtension.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 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/* SerializerExtension.h (C) 2000-2026 */
9/* */
10/* Extension du sérialiseur avec gestion des tableaux multidimensionnels. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCCORE_SERIALIZE_SERIALIZEREXTENSION_H
13#define ARCCORE_SERIALIZE_SERIALIZEREXTENSION_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arccore/serialize/ISerializer.h"
18
19#include <array>
20
21/*---------------------------------------------------------------------------*/
22/*---------------------------------------------------------------------------*/
23
24namespace Arcane
25{
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
37class ARCCORE_SERIALIZE_EXPORT SerializerExtension
38{
39 public:
40
45 SerializerExtension(ISerializer* serializer)
46 : m_serializer(serializer)
47 {}
48
49 public:
50
52 template <class Type>
53 void reserveSpan(Span2<const Type> values) const;
54
56 template <class Type, class Extents>
57 void reserveSpan(MDSpan<const Type, Extents> values) const
58 requires(Extents::rank() <= 4);
59
61 template <class Type>
62 void reserveArray(Span2<const Type> values) const;
63
65 template <class Type, class Extents>
66 void reserveArray(MDSpan<const Type, Extents> values) const
67 requires(Extents::rank() <= 4);
68
70 void reserveArray(Span<const String> values) const;
71
72 public:
73
75 template <class Type>
76 void putSpan(Span2<const Type> values) const;
77
79 template <class Type, class Extents>
80 void putSpan(MDSpan<const Type, Extents> values) const
81 requires(Extents::rank() <= 4);
82
84 template <class Type>
85 void putArray(Span2<const Type> values) const;
86
88 template <class Type, class Extents>
89 void putArray(MDSpan<const Type, Extents> values) const
90 requires(Extents::rank() <= 4);
91
93 void putArray(Span<const String> values) const;
94
95 public:
96
98 template <class Type>
99 void getSpan(Span2<Type> values) const;
100
102 template <class Type, class Extents>
103 void getSpan(MDSpan<Type, Extents> values) const
104 requires(Extents::rank() <= 4);
105
107 template <class Type>
108 void getArray(Array2<Type>& values) const;
109
111 template <class Type, class Extents>
112 void getArray(NumArray<Type, Extents>& values) const
113 requires(Extents::rank() <= 4);
114
116 void getArray(Array<String>& values) const;
117
118 private:
119
120 ISerializer* m_serializer;
121};
122
123/*---------------------------------------------------------------------------*/
124/*---------------------------------------------------------------------------*/
125
126template <class Type>
127void SerializerExtension::
128reserveSpan(Span2<const Type> values) const
129{
130 Span<const Type> span_1d(values.data(), values.dim1Size() * values.dim2Size());
131 m_serializer->reserveSpan(span_1d);
132}
133
134/*---------------------------------------------------------------------------*/
135/*---------------------------------------------------------------------------*/
136
137template <class Type, class Extents>
138void SerializerExtension::
139reserveSpan(MDSpan<const Type, Extents> values) const
140requires(Extents::rank() <= 4)
141{
142 m_serializer->reserveSpan(values.to1DSpan());
143}
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
148template <class Type>
149void SerializerExtension::
150reserveArray(Span2<const Type> values) const
151{
152 m_serializer->reserveInt64(2);
153 this->reserveSpan(values);
154}
155
156/*---------------------------------------------------------------------------*/
157/*---------------------------------------------------------------------------*/
158
159template <class Type, class Extents>
160void SerializerExtension::
161reserveArray(MDSpan<const Type, Extents> values) const
162requires(Extents::rank() <= 4)
163{
164 constexpr Int32 rank = Extents::rank();
165 m_serializer->reserveInt64(rank);
166 m_serializer->reserveSpan(values.to1DSpan());
167}
168
169/*---------------------------------------------------------------------------*/
170/*---------------------------------------------------------------------------*/
171
172template <class Type>
173void SerializerExtension::
174putSpan(Span2<const Type> values) const
175{
176 Span<const Type> span_1d(values.data(), values.dim1Size() * values.dim2Size());
177 m_serializer->putSpan(span_1d);
178}
179
180/*---------------------------------------------------------------------------*/
181/*---------------------------------------------------------------------------*/
182
183template <class Type, class Extents>
184void SerializerExtension::
185putSpan(MDSpan<const Type, Extents> values) const
186requires(Extents::rank() <= 4)
187{
188 m_serializer->putSpan(values.to1DSpan());
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194template <class Type>
195void SerializerExtension::
196putArray(Span2<const Type> values) const
197{
198 m_serializer->putInt64(values.dim1Size());
199 m_serializer->putInt64(values.dim2Size());
200 this->putSpan(values);
201}
202
203/*---------------------------------------------------------------------------*/
204/*---------------------------------------------------------------------------*/
205
206template <class Type, class Extents>
207void SerializerExtension::
208putArray(MDSpan<const Type, Extents> values) const
209requires(Extents::rank() <= 4)
210{
211 constexpr Int32 rank = Extents::rank();
212 // TODO : Ajouter une méthode dans ArrayExtents pour obtenir un std::array afin de supprimer
213 // tous les 'requires()' de cette classe et simplifier cette méthode.
214 if constexpr (rank >= 1) {
215 m_serializer->putInt64(values.extent0());
216 }
217 if constexpr (rank >= 2) {
218 m_serializer->putInt64(values.extent1());
219 }
220 if constexpr (rank >= 3) {
221 m_serializer->putInt64(values.extent2());
222 }
223 if constexpr (rank >= 4) {
224 m_serializer->putInt64(values.extent3());
225 }
226 m_serializer->putSpan(values.to1DSpan());
227}
228
229/*---------------------------------------------------------------------------*/
230/*---------------------------------------------------------------------------*/
231
232template <class Type>
233void SerializerExtension::
234getSpan(Span2<Type> values) const
235{
236 Span<Type> span_1d(values.data(), values.dim1Size() * values.dim2Size());
237 m_serializer->getSpan(span_1d);
238}
239
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
243template <class Type, class Extents>
244void SerializerExtension::
245getSpan(MDSpan<Type, Extents> values) const
246requires(Extents::rank() <= 4)
247{
248 Span<Type> values_1d = values.to1DSpan();
249 m_serializer->getSpan(values_1d);
250}
251
252/*---------------------------------------------------------------------------*/
253/*---------------------------------------------------------------------------*/
254
255template <class Type>
256void SerializerExtension::
257getArray(Array2<Type>& values) const
258{
259 Int64 size1 = m_serializer->getInt64();
260 Int64 size2 = m_serializer->getInt64();
261
262 values.resize(size1, size2);
263 m_serializer->getSpan(values.to1DSpan());
264}
265
266/*---------------------------------------------------------------------------*/
267/*---------------------------------------------------------------------------*/
268
269template <class Type, class Extents>
270void SerializerExtension::
271getArray(NumArray<Type, Extents>& values) const
272requires(Extents::rank() <= 4)
273{
274 using IndexType = Extents::ExtentIndexType;
275
276 {
277 constexpr Int32 rank = Extents::rank();
278 std::array<IndexType, rank> size{};
279 for (Int32 i = 0; i < rank; ++i) {
280 size[i] = static_cast<IndexType>(m_serializer->getInt64());
281 }
282 MDIndex<rank, IndexType> mdi(size);
283 values.resizeDestructive(mdi);
284 }
285
286 m_serializer->getSpan(values.to1DSpan());
287}
288
289/*---------------------------------------------------------------------------*/
290/*---------------------------------------------------------------------------*/
291
292} // namespace Arcane
293
294/*---------------------------------------------------------------------------*/
295/*---------------------------------------------------------------------------*/
296
297#endif
Arcane::Array2
Tableau 2D d'items de types quelconques.
Definition AnyItemArray2.h:55
Arcane::Array2::to1DSpan
Span< DataType > to1DSpan()
Vue du tableau sous forme de tableau 1D.
Definition arccore/src/collections/arccore/collections/Array2.h:259
Arcane::Array2::resize
void resize(Integer size)
Redimensionnement de la deuxième dimension du tableau.
Definition AnyItemArray2.h:71
Arcane::Array
Tableau d'items de types quelconques.
Definition AnyItemArray.h:53
Arcane::MDSpan
Classe de base des vues multi-dimensionnelles.
Definition arccore/src/base/arccore/base/MDSpan.h:44
Arcane::NumArray
Tableaux multi-dimensionnels pour les types numériques accessibles sur accélérateurs.
Definition arccore/src/common/arccore/common/NumArray.h:57
Arcane::SerializerExtension::getSpan
void getSpan(Span2< Type > values) const
Récupère le tableau values.
Definition SerializerExtension.h:234
Arcane::SerializerExtension::reserveArray
void reserveArray(Span2< const Type > values) const
Réserve pour sauver le nombre d'éléments et les values éléments.
Definition SerializerExtension.h:150
Arcane::SerializerExtension::SerializerExtension
SerializerExtension(ISerializer *serializer)
Constructeur.
Definition SerializerExtension.h:45
Arcane::SerializerExtension::putArray
void putArray(Span2< const Type > values) const
Sauve le nombre d'éléments et les values éléments.
Definition SerializerExtension.h:196
Arcane::SerializerExtension::reserveSpan
void reserveSpan(Span2< const Type > values) const
Réserve pour une vue de values éléments.
Definition SerializerExtension.h:128
Arcane::SerializerExtension::getArray
void getArray(Array2< Type > &values) const
Redimensionne et remplit values.
Definition SerializerExtension.h:257
Arcane::SerializerExtension::putSpan
void putSpan(Span2< const Type > values) const
Ajoute le tableau values.
Definition SerializerExtension.h:174
Arcane::Span2Impl::data
constexpr __host__ __device__ ElementType * data()
Pointeur sur la mémoire allouée.
Definition Span2.h:193
Arcane::Span2Impl::dim2Size
constexpr __host__ __device__ SizeType dim2Size() const
Nombre d'éléments de la deuxième dimension.
Definition Span2.h:119
Arcane::Span2Impl::dim1Size
constexpr __host__ __device__ SizeType dim1Size() const
Nombre d'éléments de la première dimension.
Definition Span2.h:117
Arcane::Span2
Vue pour un tableau 2D dont la taille est un 'Int64'.
Definition Span2.h:321
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:633
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:235
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:233