16#include "arcane/utils/NotSupportedException.h"
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/ArgumentException.h"
19#include "arcane/utils/TraceInfo.h"
20#include "arcane/utils/ITraceMng.h"
21#include "arcane/utils/IHashAlgorithm.h"
22#include "arcane/utils/Array.h"
23#include "arcane/utils/ArrayShape.h"
25#include "arcane/core/datatype/DataAllocationInfo.h"
26#include "arcane/core/datatype/DataStorageTypeInfo.h"
27#include "arcane/core/datatype/DataStorageBuildInfo.h"
28#include "arcane/core/datatype/DataTypeTraits.h"
30#include "arcane/impl/SerializedData.h"
31#include "arcane/impl/DataStorageFactory.h"
33#include "arcane/core/ISerializer.h"
34#include "arcane/core/IDataVisitor.h"
36#include "arcane/core/internal/IDataInternal.h"
53 ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS();
60 typedef StringArrayData ThatClass;
64 explicit StringArrayData(
ITraceMng* trace);
66 StringArrayData(
const StringArrayData& rhs);
67 ~StringArrayData()
override;
83 DataInterfaceType*
cloneTrue()
override {
return _cloneTrue(); }
103 visitor->applyVisitor(
this);
131 ThatClass* _cloneTrue()
const {
return new ThatClass(*
this); }
132 ThatClass* _cloneTrueEmpty()
const {
return new ThatClass(m_trace); }
143 using String = DataType;
145 explicit Impl(StringArrayData* p) : m_p(p){}
149 void reserve(
Integer new_capacity)
override { m_p->m_value.reserve(new_capacity); }
152 void shrink()
const override { m_p->m_value.shrink(); }
154 void dispose()
override { m_p->m_value.dispose(); }
157 m_p->computeHash(hash_info);
162 StringArrayData* m_p;
170: m_trace(dsbi.traceMng())
171, m_internal(new Impl(this))
176StringArrayData(ITraceMng* trace)
178, m_internal(new Impl(this))
182StringArrayData(
const StringArrayData& rhs)
184, m_trace(rhs.m_trace)
185, m_internal(new
Impl(this))
186, m_allocation_info(rhs.m_allocation_info)
201DataStorageTypeInfo StringArrayData::
202staticStorageTypeInfo()
205 Int32 nb_basic_type = 0;
208 return DataStorageTypeInfo(bdt,nb_basic_type,
dimension,multi_tag);
217 return staticStorageTypeInfo();
226 ARCANE_UNUSED(use_basic_type);
230 Int64 needed_memory = 0;
233 for (
Integer i = 0; i < nb_element; ++i) {
236 needed_memory += len;
239 Int64 nb_base_element = needed_memory;
241 nb_base_element,
true, dimensions);
242 sd->allocateMemory(needed_memory);
248 for (
Integer i = 0; i < nb_element; ++i) {
252 for (
Int64 z = 0; z < len; ++z)
253 svalues[index + z] = str[z];
288 for (
Integer i = 0; i < nb_element; ++i) {
289 Int64 len = dimensions[i];
304 ARCANE_UNUSED(operation);
307 if (mode == ISerializer::ModeReserve) {
309 sbuf->reserveInteger(1);
310 for (
Integer z = 0; z < size; ++z)
316 for (
Integer z = 0; z < size; ++z)
324 for (
Integer z = 0; z < size; ++z)
343 ARCANE_UNUSED(operation);
365 s->computeHash(algo, output);
374 hash_info.setVersion(2);
386 const auto* true_data =
dynamic_cast<const DataInterfaceType*
>(data);
389 m_value.copy(true_data->view());
398 auto* true_data =
dynamic_cast<ThatClass*
>(data);
401 m_value.swap(true_data->m_value);
419 visitor->applyVisitor(
this);
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Exception lorsqu'un argument est invalide.
Vue modifiable d'un tableau d'un type T.
Tableau d'items de types quelconques.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Informations sur l'allocation d'une donnée.
Informations pour le calcul du hash d'une donnée.
Informations pour construire une instance de 'IData'.
static void registerDataFactory(IDataFactoryMng *dfm)
Enregistre dans dfm une fabrique pour la donnée DataType.
Informations de type pour un conteneur de données.
Interface du pattern visitor pour une donnée tableau 2D.
Interface d'une donnée tableau d'un type T.
Interface d'une donnée tableau d'un type T.
Interface du pattern visitor pour une donnée tableau.
Interface d'une donnée tableau 1D.
Interface du gestionnaire de fabrique d'une donnée.
Interface d'une opération sur une donnée.
Interface du pattern visitor pour une donnée.
Contexte pour calculer un hash de manière incrémentale.
virtual void updateHash(Span< const std::byte > input)=0
Ajoute le tableau input au hash calculé
Interface d'un algorithme de hashage.
Interface du pattern visitor pour une donnée scalaire.
Interface d'une donnée sérialisée.
virtual eDataType baseDataType() const =0
Type de la donnée.
virtual Int64 memorySize() const =0
Indique le nombre d'octets qu'il faut allouer pour stocker ou lire les données.
virtual void allocateMemory(Int64 size)=0
Alloue un tableaux pour contenir les éléments sérialisés.
virtual Int64ConstArrayView extents() const =0
Tableau contenant le nombre d'éléments pour chaque dimension.
virtual Span< const Byte > constBytes() const =0
Valeurs sérialisées.
Interface d'un sérialiseur.
virtual void reserve(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n objets de type dt.
virtual Integer getInteger()=0
Récupère une taille.
eMode
Mode de fonctionnement du sérialiseur.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
virtual void putInteger(Integer value)=0
Ajoute l'entier value.
virtual void put(Span< const Real > values)=0
Ajoute le tableau values.
virtual eReadMode readMode() const =0
Mode de lecture.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
@ ReadReplace
Replace les éléments actuels par ceux lus.
@ ReadAdd
Ajoute aux éléments actuels ceux lus.
virtual void get(ArrayView< Real > values)=0
Récupère le tableau values.
Interface du gestionnaire de traces.
Exception lorsqu'une fonction n'est pas implémentée.
Exception lorsqu'une opération n'est pas supportée.
Référence à une instance.
Implémentation thread-safe d'un compteur de référence.
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Vue d'un tableau d'éléments de type T.
Integer capacity() const override
Capacité allouée par le conteneur.
void dispose() override
Vide le conteneur et libère la mémoire alloué.
void resize(Integer new_size) override
Redimensionne le conteneur.
void reserve(Integer new_capacity) override
Réserve de la mémoire pour new_capacity éléments.
void computeHash(DataHashInfo &hash_info) override
Calcule le hash de la donnée.
void shrink() const override
Libère la mémoire additionnelle éventuellement allouée.
Array< DataType > & _internalDeprecatedValue() override
Conteneur associé à la donnée.
Ref< IData > cloneEmptyRef() override
Clone la donnée mais sans éléments.
void copy(const IData *data) override
Copie la donnée data dans l'instance courante.
ArrayView< DataType > view() override
Vue sur la donnée.
void setName(const String &name) override
Positionne le nom de la donnée (interne)
Ref< ISerializedData > createSerializedDataRef(bool use_basic_type) const override
Sérialise la donnée.
void resize(Integer new_size) override
Redimensionne la donnée.
Ref< IData > cloneRef() override
Clone la donnée.
void setShape(const ArrayShape &) override
Positionne la forme du tableau.
Integer multiTag() const override
Tag multiple. 0 si non multiple, 1 si multiple, 2 si multiple pour les variable MultiArray (obsolète)
void visitArray(IArrayDataVisitor *visitor) override
Applique le visiteur à la donnée.
IArrayDataInternalT< DataType > * _internal() override
void assignSerializedData(const ISerializedData *sdata) override
Assigne à la donnée les valeurs sérialisées sdata.
Ref< DataInterfaceType > cloneTrueRef() override
Clone la donnée.
eDataType dataType() const override
Type de la donnée.
DataStorageTypeInfo storageTypeInfo() const override
Informations sur le type de conteneur de la donnée.
void visitScalar(IScalarDataVisitor *visitor) override
Applique le visiteur à la donnée.
Integer dimension() const override
Dimension. 0 pour un scalaire, 1 pour un tableau mono-dim, 2 pour un tableau bi-dim.
ArrayShape shape() const override
Forme du tableau pour une donnée 1D ou 2D.
Array< DataType > & value() override
Valeur de la donnée.
void computeHash(IHashAlgorithm *algo, ByteArray &output) const override
Calcul une clé de hashage sur cette donnée.
void setAllocationInfo(const DataAllocationInfo &v) override
Positionne les informations sur l'allocation.
void visit(IArrayDataVisitor *visitor) override
Applique le visiteur à la donnée.
IData * cloneEmpty() override
Clone la donnée mais sans éléments. L'instance créée doit être détruite par l'opérateur 'delete'.
void swapValues(IData *data) override
Échange les valeurs de data avec celles de l'instance.
void visit(IDataVisitor *visitor) override
Applique le visiteur à la donnée.
UniqueArray< DataType > m_value
Donnée.
void serialize(ISerializer *sbuf, IDataOperation *operation) override
Sérialise la donnée en appliquant l'opération operation.
DataAllocationInfo allocationInfo() const override
Informations sur l'allocation.
DataInterfaceType * cloneTrueEmpty() override
Clone la donnée mais sans éléments.
DataInterfaceType * cloneTrue() override
Clone la donnée.
void fillDefault() override
Remplit la donnée avec sa valeur par défaut.
Ref< DataInterfaceType > cloneTrueEmptyRef() override
Clone la donnée mais sans éléments.
void allocateBufferForSerializedData(ISerializedData *sdata) override
Alloue la mémoire pour lire les valeurs sérialisées sdata.
IDataInternal * _commonInternal() override
void visitArray2(IArray2DataVisitor *visitor) override
Applique le visiteur à la donnée.
IData * clone() override
Clone la donnée. L'instance créée doit être détruite par l'opérateur 'delete'.
const Array< DataType > & value() const override
Valeur constante de la donnée.
ConstArrayView< DataType > view() const override
Vue constante sur la donnée.
Chaîne de caractères unicode.
Vecteur 1D de données avec sémantique par valeur (style STL).
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Ref< ISerializedData > arcaneCreateSerializedDataRef(eDataType data_type, Int64 memory_size, Integer nb_dim, Int64 nb_element, Int64 nb_base_element, bool is_multi_size, Int64ConstArrayView dimensions)
Créé des données sérialisées.
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
eBasicDataType
Type d'une donnée de base.
@ Byte
Donnée de type octet.
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
eDataType
Type d'une donnée.
@ DT_Byte
Donnée de type octet.
std::int32_t Int32
Type entier signé sur 32 bits.