Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemFamily.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/* ItemFamily.h (C) 2000-2025 */
9/* */
10/* Famille d'entités. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_MESH_ITEMFAMILY_H
13#define ARCANE_MESH_ITEMFAMILY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/List.h"
18#include "arcane/utils/String.h"
19#include "arcane/utils/TraceAccessor.h"
20
21#include "arcane/core/IItemFamily.h"
22#include "arcane/core/ItemPairGroup.h"
23#include "arcane/core/ObserverPool.h"
24#include "arcane/core/IItemConnectivity.h"
25#include "arcane/core/IIncrementalItemConnectivity.h"
26#include "arcane/core/ItemSharedInfo.h"
27#include "arcane/core/ItemGroup.h"
28
29#include <map>
30#include <set>
31
32/*---------------------------------------------------------------------------*/
33/*---------------------------------------------------------------------------*/
34
35namespace Arcane
36{
37class Timer;
39class Properties;
43class IMeshCompacter;
45class ItemDataList;
46template <typename T> class ItemScalarProperty;
47}
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52namespace Arcane::mesh
53{
54class ItemInternalMap;
59
60/*---------------------------------------------------------------------------*/
61/*---------------------------------------------------------------------------*/
73class ARCANE_MESH_EXPORT ItemFamily
74: public TraceAccessor
75, public IItemFamily
76{
77 private:
78
79 class Variables;
80 class InternalApi;
81 class AdjacencyInfo
82 {
83 public:
84
85 AdjacencyInfo(const ItemGroup& item_group, const ItemGroup& sub_item_group,
86 eItemKind link_kind, Integer nb_layer)
87 : m_item_group(item_group), m_sub_item_group(sub_item_group),
88 m_link_kind(link_kind), m_nb_layer(nb_layer)
89 {
90 }
91 public:
92 ItemGroup m_item_group;
93 ItemGroup m_sub_item_group;
94 eItemKind m_link_kind;
95 Integer m_nb_layer;
96 public:
97
98 bool operator<(const AdjacencyInfo& rhs) const
99 {
100 if (m_item_group != rhs.m_item_group)
101 return m_item_group < rhs.m_item_group;
102 if (m_sub_item_group != rhs.m_sub_item_group)
103 return m_sub_item_group < rhs.m_sub_item_group;
104 if (m_link_kind != rhs.m_link_kind)
105 return m_link_kind < rhs.m_link_kind;
106 return m_nb_layer < rhs.m_nb_layer;
107 }
108
109 };
110 using AdjacencyGroupMap = std::map<AdjacencyInfo, ItemPairGroup>;
111 // Garde la version avec faute d'ortographe pour des raisons de compatibilité
112 // TODO: à enlever mi 2025
113 using AdjencyGroupMap = AdjacencyGroupMap;
114
115 public:
116
117 using ItemInternalMap = ::Arcane::mesh::ItemInternalMap;
118
119 public:
120
121 ItemFamily(IMesh* mesh,eItemKind ik,const String& name);
122 ~ItemFamily() override; //<! Libère les ressources
123
124 public:
125
126 void build() override;
127
128 public:
129
130 String name() const override { return m_name; }
131 String fullName() const override { return m_full_name; }
132 eItemKind itemKind() const override;
133 Integer nbItem() const override;
134 Int32 maxLocalId() const override;
135 ItemInternalList itemsInternal() override;
136 ItemInfoListView itemInfoListView() override;
137 VariableItemInt32& itemsNewOwner() override;
138 IItemFamily * parentFamily() const override;
139 void setParentFamily(IItemFamily * parent) override;
140 Integer parentFamilyDepth() const override;
141 void addChildFamily(IItemFamily * family) override;
142 IItemFamilyCollection childFamilies() override;
143
144 void checkValid() override;
145 void checkValidConnectivity() override;
146 void checkUniqueIds(Int64ConstArrayView unique_ids) override;
147
148 public:
149
150 ItemInternalMap& itemsMap();
151
152 public:
153
154 void endUpdate() override;
155 void partialEndUpdate() override;
156 void partialEndUpdateGroup(const ItemGroup& group) override;
157 void partialEndUpdateVariable(IVariable* variable) override;
158
159 public:
160
161 void itemsUniqueIdToLocalId(ArrayView<Int64> ids,bool do_fatal=true) const;
162 void itemsUniqueIdToLocalId(Int32ArrayView local_ids,
163 Int64ConstArrayView unique_ids,
164 bool do_fatal) const override;
165 void itemsUniqueIdToLocalId(Int32ArrayView local_ids,
167 bool do_fatal) const override;
168
169 public:
170
171 ISubDomain* subDomain() const override;
172 ITraceMng* traceMng() const override;
173 IMesh* mesh() const override;
174 IParallelMng* parallelMng() const override;
175
176 public:
177
178 IItemConnectivityInfo* localConnectivityInfos() const override;
179 IItemConnectivityInfo* globalConnectivityInfos() const override;
180
181 public:
182
183 void internalRemoveItems(Int32ConstArrayView local_ids,bool keep_ghost =false) override;
184 void removeItems2(ItemDataList& item_data_list) override; // Remove items based on family dependencies (ItemFamilyNetwork)
185 void removeNeedRemoveMarkedItems() override;
186
187 ItemVectorView view(Int32ConstArrayView local_ids) override;
188 ItemVectorView view() override;
189
190 ItemInternal* findOneItem(Int64 uid) override;
191
192 public:
193
194 ItemGroup allItems() const override;
195
196 public:
197
198 void notifyItemsOwnerChanged() override;
199 ItemGroup findGroup(const String& name) const override;
200 ItemGroup findGroup(const String& name,bool create_if_needed) override;
201 ItemGroup createGroup(const String& name,Int32ConstArrayView elements,bool do_override=false) override;
202 ItemGroup createGroup(const String& name) override;
203 ItemGroup createGroup(const String& name,const ItemGroup& parent,bool do_override=false) override;
204 ItemGroupCollection groups() const override;
205 void notifyItemsUniqueIdChanged() override;
206 void destroyGroups() override;
207
208 public:
209
210 IVariable* findVariable(const String& name,bool throw_exception) override;
211 void usedVariables(VariableCollection collection) override;
212
213 public:
214
215 void prepareForDump() override;
216 void readFromDump() override;
217 void copyItemsValues(Int32ConstArrayView source,Int32ConstArrayView destination) override;
218 void copyItemsMeanValues(Int32ConstArrayView first_source,
219 Int32ConstArrayView second_source,
220 Int32ConstArrayView destination) override;
221 void compactItems(bool do_sort) override;
222 void clearItems() override;
223
224 Int64ArrayView* uniqueIds();
225
226 ItemSharedInfo* commonItemSharedInfo() { return m_common_item_shared_info; }
227
228 public:
229
230 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. Use _infos() instead.")
231 const DynamicMeshKindInfos& infos() const;
232
233 public:
234
235 void setHasUniqueIdMap(bool v) override;
236 bool hasUniqueIdMap() const override;
237
238 public:
239
240 void computeSynchronizeInfos() override;
241 void getCommunicatingSubDomains(Int32Array& sub_domains) const override;
242 void synchronize(VariableCollection variables) override;
243 void synchronize(VariableCollection variables, Int32ConstArrayView local_ids) override;
244 IVariableSynchronizer* allItemsSynchronizer() override;
245
246 void reduceFromGhostItems(IVariable* v,IDataOperation* operation) override;
247 void reduceFromGhostItems(IVariable* v,Parallel::eReduceType operation) override;
248
249 public:
250
251 ARCANE_DEPRECATED_REASON("Y2024: use findAdjacencyItems() instead")
252 ItemPairGroup findAdjencyItems(const ItemGroup& group,
253 const ItemGroup& sub_group,eItemKind link_kind,
254 Integer layer) override;
255 ItemPairGroup findAdjacencyItems(const ItemGroup& group,
256 const ItemGroup& sub_group, eItemKind link_kind,
257 Integer layer) override;
258 IParticleFamily* toParticleFamily() override { return nullptr; }
259 void setItemSortFunction(IItemInternalSortFunction* sort_function) override;
260 IItemInternalSortFunction* itemSortFunction() const override;
261
262 public:
263
264 void addSourceConnectivity(IItemConnectivity* connectivity) override;
265 void addTargetConnectivity(IItemConnectivity* connectivity) override;
266 void removeSourceConnectivity(IItemConnectivity* connectivity) override;
267 void removeTargetConnectivity(IItemConnectivity* connectivity) override;
268 void setConnectivityMng(IItemConnectivityMng* connectivity_mng) override;
269
270 void addGhostItems(Int64ConstArrayView unique_ids, Int32ArrayView items, Int32ConstArrayView owners) override;
272 void experimentalChangeUniqueId(ItemLocalId local_id,ItemUniqueId unique_id) override;
273
274 IItemFamilyPolicyMng* policyMng() override { return m_policy_mng; }
275 Properties* properties() override { return m_properties; }
276 IItemFamilyInternal* _internalApi() override;
277
278 public:
279
280 //NOTE: Cette méthode doit être virtuelle pour que PolyhedralMesh puisse positionner la politique.
281 virtual void setPolicyMng(IItemFamilyPolicyMng* policy_mng);
282
283 public:
284
285 void beginCompactItems(ItemFamilyCompactInfos& compact_infos);
288 void compactVariablesAndGroups(const ItemFamilyCompactInfos& compact_infos);
289 void finishCompactItems(ItemFamilyCompactInfos& compact_infos);
290 void removeItem(Item item)
291 {
292 _removeOne(item);
293 }
299
300 protected:
301
302 void _removeOne(Item item);
303 void _detachOne(Item item);
304 ItemInternalList _itemsInternal();
305 ItemInternal* _itemInternal(Int32 local_id);
306 ItemInternal* _allocOne(Int64 unique_id);
307 ItemInternal* _allocOne(Int64 unique_id, bool& need_alloc);
308 ItemInternal* _findOrAllocOne(Int64 uid, bool& is_alloc);
309 void _setHasUniqueIdMap(bool v);
310 void _removeMany(Int32ConstArrayView local_ids);
311 void _removeDetachedOne(Item item);
312 const DynamicMeshKindInfos& _infos() const;
313
314 void _detachCells2(Int32ConstArrayView local_ids);
315
316 virtual void _endAllocate();
317 virtual void _notifyEndUpdateFromMesh();
318
319 protected:
320
321 String m_name;
322 String m_full_name;
323 IMesh* m_mesh = nullptr;
324 InternalApi* m_internal_api = nullptr;
325 ISubDomain* m_sub_domain = nullptr;
326 IItemFamily* m_parent_family = nullptr;
327 Integer m_parent_family_depth = 0;
328
329 private:
330
331 std::unique_ptr<DynamicMeshKindInfos> m_infos;
332
333 protected:
334
335 ItemGroupList m_item_groups;
336 bool m_need_prepare_dump = true;
337 MeshItemInternalList* m_item_internal_list = nullptr;
338
339 private:
340
341 ItemSharedInfo* m_common_item_shared_info = nullptr;
342
343 protected:
344
345 ItemSharedInfoList* m_item_shared_infos = nullptr;
346 ObserverPool m_observers;
347 Ref<IVariableSynchronizer> m_variable_synchronizer;
348 Integer m_current_variable_item_size = 0;
349 IItemInternalSortFunction* m_item_sort_function = nullptr;
350 std::set<IVariable*> m_used_variables;
351 UniqueArray<ItemFamily*> m_child_families;
352 ItemConnectivityInfo* m_local_connectivity_info = nullptr;
353 ItemConnectivityInfo* m_global_connectivity_info = nullptr;
354 Properties* m_properties = nullptr;
355 typedef std::set<IItemConnectivity*> ItemConnectivitySet;
356 ItemConnectivitySet m_source_item_connectivities;
357 ItemConnectivitySet m_target_item_connectivities;
359
360 private:
361
362 UniqueArray<Ref<IIncrementalItemSourceConnectivity>> m_source_incremental_item_connectivities;
363 UniqueArray<Ref<IIncrementalItemTargetConnectivity>> m_target_incremental_item_connectivities;
364
365 protected:
366
367 IItemFamilyPolicyMng* m_policy_mng = nullptr;
368
369 protected:
370
371 void _checkNeedEndUpdate() const;
372 void _updateSharedInfo();
373
374 void _allocateInfos(ItemInternal* item,Int64 uid,ItemSharedInfoWithType* isi);
375 void _allocateInfos(ItemInternal* item,Int64 uid,ItemTypeInfo* type);
376 void _endUpdate(bool need_check_remove);
377 bool _partialEndUpdate();
378 void _updateGroup(ItemGroup group,bool need_check_remove);
379 void _updateVariable(IVariable* var);
380
381 void _addConnectivitySelector(ItemConnectivitySelector* selector);
382 void _buildConnectivitySelectors();
383 void _preAllocate(Int32 nb_item,bool pre_alloc_connectivity);
384 ItemInternalConnectivityList* _unstructuredItemInternalConnectivityList()
385 {
387 }
388
389 public:
390
391 IItemFamilyTopologyModifier* _topologyModifier() override { return m_topology_modifier; }
392 void resizeVariables(bool force_resize) override { _resizeVariables(force_resize); }
393
394 private:
395
396 Int64Array* m_items_unique_id = nullptr;
397 Int32Array* m_items_owner = nullptr;
398 Int32Array* m_items_flags = nullptr;
399 Int16Array* m_items_type_id = nullptr;
400 Int32Array* m_items_nb_parent = nullptr;
401 // TODO: a supprimer car redondant avec le champ correspondant de ItemSharedInfo
402 Int64ArrayView m_items_unique_id_view;
403 Variables* m_internal_variables = nullptr;
404 Int32 m_default_sub_domain_owner = A_NULL_RANK;
405
406 protected:
407
408 Int32 m_sub_domain_id = A_NULL_RANK;
409
410 private:
411
412 bool m_is_parallel = false;
413
425
426 bool m_item_need_prepare_dump = false;
427
428 private:
429
430 Int64 m_nb_allocate_info = 0;
431
432 private:
433
434 AdjacencyGroupMap m_adjacency_groups;
435 UniqueArray<ItemConnectivitySelector*> m_connectivity_selector_list;
436 IItemFamilyTopologyModifier* m_topology_modifier = nullptr;
439
440 UniqueArray<ItemConnectivitySelector*> m_connectivity_selector_list_by_item_kind;
441 bool m_use_legacy_compact_item = false;
442
443 private:
444
445 ItemTypeMng* m_item_type_mng = nullptr;
446 bool m_do_shrink_after_allocate = false;
447
448 protected:
449
450 ItemTypeMng* _itemTypeMng() const { return m_item_type_mng; }
451 virtual IItemInternalSortFunction* _defaultItemSortFunction();
452
453 ARCANE_DEPRECATED_REASON("Y2022: This method is a now a no-operation")
454 void _reserveInfosMemory(Integer memory);
455 ARCANE_DEPRECATED_REASON("Y2022: This method is a now a no-operation")
456 void _resizeInfos(Integer memory);
457
458 ItemSharedInfoWithType* _findSharedInfo(ItemTypeInfo* type);
459
460 ARCANE_DEPRECATED_REASON("Y2022: This method always return 0")
461 Integer _allocMany(Integer memory);
462 void _setSharedInfosPtr(Integer* ptr);
463 void _checkValid();
464 void _checkValidConnectivity();
465 void _notifyDataIndexChanged();
466 void _processNewGroup(ItemGroup group);
467 String _variableName(const String& base_name) const;
468 template<class Type> void
469 _synchronizeVariable(IVariable* var,Type* var_value,Integer nb_elem);
470 void _updateGroups(bool check_need_remove);
471 void _compactFromParentFamily(const ItemFamilyCompactInfos& compact_infos);
472 void _checkComputeSynchronizeInfos(Int32 changed);
473 void _readGroups();
474 void _invalidateComputedGroups();
475 void _compactItems(bool do_sort);
476 void _compactOnlyItems(bool do_sort);
477 void _applyCheckNeedUpdateOnGroups();
478 void _setTopologyModifier(IItemFamilyTopologyModifier* tm);
479
480 private:
481
482 void _updateItemsSharedFlag();
483
484 protected:
485
486 void _checkValidItem(ItemInternal* item)
487 {
488#ifdef ARCANE_CHECK
489 arcaneThrowIfNull(item,"item","Invalid null item");
490#else
491 ARCANE_UNUSED(item);
492#endif
493 }
494 void _checkValidSourceTargetItems(ItemInternal* source,ItemInternal* target)
495 {
496#ifdef ARCANE_CHECK
497 arcaneThrowIfNull(source,"source","Invalid null source item");
498 arcaneThrowIfNull(target,"target","Invalid null target item");
499#else
500 ARCANE_UNUSED(source);
501 ARCANE_UNUSED(target);
502#endif
503 }
504 void _checkValidItem(Item item) { _checkValidItem(ItemCompatibility::_itemInternal(item)); }
505 void _checkValidSourceTargetItems(Item source,Item target)
506 {
507 _checkValidItem(ItemCompatibility::_itemInternal(source));
508 _checkValidItem(ItemCompatibility::_itemInternal(target));
509 }
510
511 private:
512
513 void _getConnectedItems(IIncrementalItemConnectivity* parent_connectivity,ItemVector& target_family_connected_items);
514 void _fillHasExtraParentProperty(ItemScalarProperty<bool>& child_families_has_extra_parent,ItemVectorView connected_items);
515 void _computeConnectivityInfo(ItemConnectivityInfo* ici);
516 void _updateItemViews();
517 void _resizeItemVariables(Int32 new_size,bool force_resize);
518 void _handleOldCheckpoint();
519
520 void _addSourceConnectivity(IIncrementalItemSourceConnectivity* c);
521 void _addTargetConnectivity(IIncrementalItemTargetConnectivity* c);
522 void _addVariable(IVariable* var);
523 void _removeVariable(IVariable* var);
524 void _resizeVariables(bool force_resize);
525 void _shrinkConnectivityAndPrintInfos();
526 void _addOnSizeChangedObservable(VariableRef& var_ref);
527};
528
529/*---------------------------------------------------------------------------*/
530/*---------------------------------------------------------------------------*/
531
532} // End namespace ARcane::mesh
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
537#endif
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
Classe gérant les observateurs associés à un évènement.
Definition Event.h:248
Interface d'une opération sur une donnée.
Interface pour gérer une connectivité incrémentale.
Interface des informations sur la connectivité par type d'entité.
Interface pour gérer une connectivité.
Partie interne de IItemFamily.
Interface des politiques d'une famille d'entités.
Interface de modification de la topologie des entités d'une famille.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Interface d'une fonction de tri des entités.
Gestion d'un compactage de familles du maillage.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Interface d'une famille de particules.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Interface du gestionnaire de traces.
Interface d'un service de synchronisation de variable.
Interface d'une variable.
Definition IVariable.h:56
Informations pour gérer le compactage des entités d'une famille.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Vue sur une liste pour obtenir des informations sur les entités.
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Structure interne d'une entité de maillage.
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Tableau de listes d'entités.
Structure interne partagée d'une entité de maillage.
Infos sur un type d'entité du maillage.
Gestionnaire des types d'entités de maillage.
Definition ItemTypeMng.h:66
Identifiant unique d'une entité.
Vue sur un vecteur d'entités.
Classe de base d'un élément de maillage.
Definition Item.h:83
Tableaux d'indirection sur les entités d'un maillage.
Liste d'observateurs.
Liste de propriétés.
Definition Properties.h:64
Référence à une instance.
Chaîne de caractères unicode.
Gestion d'un timer.
Definition Timer.h:62
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
Vecteur 1D de données avec sémantique par valeur (style STL).
Collection de variables.
Infos de maillage pour un genre donné d'entité.
Informations sur la connectivité par type d'entité.
Sélection entre les connectivités historiques et à la demande.
IMesh * mesh() const override
Maillage associé
String fullName() const override
Nom complet de la famille (avec celui du maillage)
Definition ItemFamily.h:131
ItemInternalConnectivityList m_item_connectivity_list
Accesseur pour les connectivités via Item et ItemInternal.
Definition ItemFamily.h:438
IParticleFamily * toParticleFamily() override
Retourne l'interface de la famille de particule de cette famille.
Definition ItemFamily.h:258
Integer m_current_id
Identifiant de la famille.
Definition ItemFamily.h:424
ItemInternalConnectivityList * itemInternalConnectivityList()
Accesseur pour les connectivités via Item et ItemInternal.
Definition ItemFamily.h:295
IItemFamilyTopologyModifier * _topologyModifier() override
Interface du modificateur de topologie.
Definition ItemFamily.h:391
ItemConnectivitySet m_target_item_connectivities
connectivite ou ItemFamily == SourceFamily
Definition ItemFamily.h:357
IItemConnectivityMng * m_connectivity_mng
connectivite ou ItemFamily == TargetFamily
Definition ItemFamily.h:358
Properties * properties() override
Propriétés associées à cette famille.
Definition ItemFamily.h:275
void resizeVariables(bool force_resize) override
Redimensionne les variables de cette famille.
Definition ItemFamily.h:392
String name() const override
Nom de la famille.
Definition ItemFamily.h:130
IItemFamilyPolicyMng * policyMng() override
Interface des comportements/politiques associées à cette famille.
Definition ItemFamily.h:274
Tableau associatif de ItemInternal.
Infos de maillage pour un genre donné d'entité.
Classe temporaire pour conserver un ItemSharedInfo et un type d'entité.
ItemVariableScalarRefT< Int32 > VariableItemInt32
Grandeur de type entier 32 bits.
eReduceType
Types des réductions supportées.
Implémentation de la concurrence.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Array< Int64 > Int64Array
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:212
ArrayView< Int64 > Int64ArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:538
Collection< ItemGroup > ItemGroupCollection
Collection de groupes d'éléments du maillage.
std::int64_t Int64
Type entier signé sur 64 bits.
Array< Int16 > Int16Array
Tableau dynamique à une dimension d'entiers 16 bits.
Definition UtilsTypes.h:216
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
List< ItemGroup > ItemGroupList
Tableau de groupes d'éléments du maillage.
ConstArrayView< ItemInternal * > ItemInternalList
Type de la liste interne des entités.
Definition ItemTypes.h:466
Collection< IItemFamily * > IItemFamilyCollection
Collection de familles d'entités.
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:567
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:540
eItemKind
Genre d'entité de maillage.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
std::int32_t Int32
Type entier signé sur 32 bits.
Type
Type of JSON value.
Definition rapidjson.h:665