Arcane  v3.16.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ArcaneCaseMeshService_axl.h
1/*---------------------------------------------------------------------------*/
2/*---------------------------------------------------------------------------*/
3// #WARNING#: This file has been generated automatically. Do not edit.
4// Axlstar version 1.0
5/*---------------------------------------------------------------------------*/
6/*---------------------------------------------------------------------------*/
7
8#ifndef ARCANE_CASEOPTION_AXLSTAR_ARCANECASEMESHSERVICE_H
9#define ARCANE_CASEOPTION_AXLSTAR_ARCANECASEMESHSERVICE_H
10
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/String.h"
15
16#include "arcane/CaseOptions.h"
17#include "arcane/CaseOptionsMulti.h"
18#include "arcane/CaseOptionBuildInfo.h"
19#include "arcane/XmlNodeList.h"
20#include "arcane/CaseOptionService.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
26class CaseOptionsArcaneCaseMeshService
27{
28public:
29
30 /*-------------------------------------------------------------------------*/
31 /*--------------------------- Complex Options -----------------------------*/
32 /*-------------------------------------------------------------------------*/
33 // Generation for option 'variable'
34 // Generating multiple arity CaseOption for complex option value 'variable'
35 class CaseOptionInitVariableValue
37 {
38 public:
39
40 typedef CaseOptionInitVariableValue ThatClass;
41
42 CaseOptionInitVariableValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
43 : Arcane::CaseOptionComplexValue(opt,icl,element)
44 , name(Arcane::CaseOptionBuildInfo(_configList(),
45 /* name */ "name", _element(),
46 /* default */ Arcane::String(),
47 /* min-occurs */ 1,
48 /* max-occurs */ 1,
49 /* optional */ false))
50 , value(Arcane::CaseOptionBuildInfo(_configList(),
51 /* name */ "value", _element(),
52 /* default */ Arcane::String(),
53 /* min-occurs */ 1,
54 /* max-occurs */ 1,
55 /* optional */ false))
56 , group(Arcane::CaseOptionBuildInfo(_configList(),
57 /* name */ "group", _element(),
58 /* default */ Arcane::String(),
59 /* min-occurs */ 1,
60 /* max-occurs */ 1,
61 /* optional */ false))
62
63 {
64
65
66 }
67 public:
68 // Interfaces for multi-arity class CaseOptionsInitVariable
69
70 Arcane::String getName() { return name(); }
71 Arcane::ICaseFunction* getNameFunction() { return name.function(); }
72 Arcane::IStandardFunction* getNameStandardFunction() { return name.standardFunction(); }
73 Arcane::String getValue() { return value(); }
74 Arcane::ICaseFunction* getValueFunction() { return value.function(); }
75 Arcane::IStandardFunction* getValueStandardFunction() { return value.standardFunction(); }
76 Arcane::String getGroup() { return group(); }
77 Arcane::ICaseFunction* getGroupFunction() { return group.function(); }
78 Arcane::IStandardFunction* getGroupStandardFunction() { return group.standardFunction(); }
79
80
81
82 // Interfaces for complex options
83
84
85 public:
86
87 const ThatClass* operator->() const { return this; }
88
89 public:
90
91 Arcane::CaseOptionString name;
92 Arcane::CaseOptionString value;
93 Arcane::CaseOptionString group;
94 };
95
96 // Generation for sub-option 'variable'
97 class CaseOptionInitVariable
99 , private Arcane::ArrayView< CaseOptionInitVariableValue * >
100 {
101 public:
102
104
105 typedef CaseOptionInitVariableValue value_type;
106
107 public:
108
109 CaseOptionInitVariable(Arcane::ICaseOptionList* icl,
110 const Arcane::String& s, const Arcane::XmlNode& element)
111 : Arcane::CaseOptionsMulti(icl,s,element,0,-1)
112 {
113 // Generating translations and default values.
114 }
115
116 BaseClass operator()() { return (*this); }
117
118 protected:
119 void multiAllocate(const Arcane::XmlNodeList& elist)
120 {
121 Arcane::Integer s = elist.size();
122 value_type** v = 0;
123 if (s!=0)
124 v = new value_type*[s];
125 _setArray(v,s);
126 v = _ptr();
127 for( Arcane::Integer i=0; i<s; ++i ){
128 v[i] = new value_type(this,configList(),elist[i]);
129 }
130 }
131
132 public:
133
134 ~CaseOptionInitVariable()
135 {
136 Arcane::Integer s = count();
137 if (s==0) return;
138 value_type** v = _ptr();
139 for( Arcane::Integer i=0; i<s; ++i ){
140 delete v[i];
141 }
142 delete[] v;
143 }
144
145 public:
146
147 const value_type& operator[](Arcane::Integer i) const
148 { return *(BaseClass::operator[](i)); }
149 value_type& operator[](Arcane::Integer i)
150 { return *(BaseClass::operator[](i)); }
151 Arcane::Integer count() const
152 { return BaseClass::size(); }
153 Arcane::Integer size() const
154 { return BaseClass::size(); }
155
156 };
157
158 // Generation for option 'initialization'
159 // Generating simple arity CaseOption for option 'initialization'
160 class CaseOptionInit
161 : public Arcane::CaseOptions
162 {
163 public:
164
165 CaseOptionInit(Arcane::ICaseOptionList* icl,
166 const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
167 : Arcane::CaseOptions(icl,s,element,is_optional)
168 , variable(_configList(),
169 /* name */ "variable", _element())
170 {
171
172 }
173
174 const CaseOptionInit& operator()() const { return *this; }
175
176 public:
177 // Interfaces for simple arity CaseOptions
178
179
180
181
182 // Interfaces for complex options
183
184
185 private:
186 // Méthodes pour unifier la construction des options.
187 Arcane::ICaseOptionList* _configList() { return configList(); }
188 Arcane::XmlNode _element() { return Arcane::XmlNode(); }
189
190 public:
191
192 CaseOptionInitVariable variable;
193
194 };
195
196 /*-------------------------------------------------------------------------*/
197 /*--------------------------- Non Complex Options -------------------------*/
198 /*-------------------------------------------------------------------------*/
199
200 CaseOptionsArcaneCaseMeshService(Arcane::ICaseOptions* co)
201 : m_case_options(co)
202 , filename(Arcane::CaseOptionBuildInfo(_configList(),
203 /* name */ "filename", _element(),
204 /* default */ Arcane::String(),
205 /* min-occurs */ 1,
206 /* max-occurs */ 1,
207 /* optional */ true))
208 , partitioner(Arcane::CaseOptionBuildInfo(_configList(),
209 /* name */ "partitioner", _element(),
210 /* default */ "DefaultPartitioner",
211 /* min-occurs */ 1,
212 /* max-occurs */ 1,
213 /* optional */ false))
214 , nbGhostLayer(Arcane::CaseOptionBuildInfo(_configList(),
215 /* name */ "nb-ghost-layer", _element(),
216 /* default */ "1",
217 /* min-occurs */ 1,
218 /* max-occurs */ 1,
219 /* optional */ false))
220 , ghostLayerBuilderVersion(Arcane::CaseOptionBuildInfo(_configList(),
221 /* name */ "ghost-layer-builder-version", _element(),
222 /* default */ "3",
223 /* min-occurs */ 1,
224 /* max-occurs */ 1,
225 /* optional */ false))
226 , faceNumberingVersion(Arcane::CaseOptionBuildInfo(_configList(),
227 /* name */ "face-numbering-version", _element(),
228 /* default */ Arcane::String(),
229 /* min-occurs */ 1,
230 /* max-occurs */ 1,
231 /* optional */ true))
232 , edgeNumberingVersion(Arcane::CaseOptionBuildInfo(_configList(),
233 /* name */ "edge-numbering-version", _element(),
234 /* default */ Arcane::String(),
235 /* min-occurs */ 1,
236 /* max-occurs */ 1,
237 /* optional */ true))
238 , generator(Arcane::CaseOptionBuildInfo(_configList(),
239 /* name */ "generator", _element(),
240 /* default */ Arcane::String(),
241 /* min-occurs */ 1,
242 /* max-occurs */ 1,
243 /* optional */ true),
244 /* allow-null */ false,
245 /* optional */ true)
246 , specificReader(Arcane::CaseOptionBuildInfo(_configList(),
247 /* name */ "specific-reader", _element(),
248 /* default */ Arcane::String(),
249 /* min-occurs */ 1,
250 /* max-occurs */ 1,
251 /* optional */ true),
252 /* allow-null */ false,
253 /* optional */ true)
254 , subdivider(Arcane::CaseOptionBuildInfo(_configList(),
255 /* name */ "subdivider", _element(),
256 /* default */ "ArcaneBasicMeshSubdivider",
257 /* min-occurs */ 1,
258 /* max-occurs */ 1,
259 /* optional */ true),
260 /* allow-null */ false,
261 /* optional */ true)
262 , cellDimensionKind(Arcane::CaseOptionBuildInfo(_configList(),
263 /* name */ "cell-dimension-kind", _element(),
264 /* default */ "mono-dimension",
265 /* min-occurs */ 1,
266 /* max-occurs */ 1,
267 /* optional */ false),
268 /* type */ "Arcane::eMeshCellDimensionKind")
269 , initialization(_configList(),
270 /* name */ "initialization", _element())
271 {
272
273 {
274 auto x = new Arcane::CaseOptionEnumValue(
275 /* enum value name */ Arcane::String("mono-dimension"),
276 /* enum object */ (int)(Arcane::eMeshCellDimensionKind::MonoDimension));
277 cellDimensionKind.addEnumValue(x,false);
278 }
279 {
280 auto x = new Arcane::CaseOptionEnumValue(
281 /* enum value name */ Arcane::String("multi-dimension"),
282 /* enum object */ (int)(Arcane::eMeshCellDimensionKind::MultiDimension));
283 cellDimensionKind.addEnumValue(x,false);
284 }
285 {
286 auto x = new Arcane::CaseOptionEnumValue(
287 /* enum value name */ Arcane::String("non-manifold"),
288 /* enum object */ (int)(Arcane::eMeshCellDimensionKind::NonManifold));
289 cellDimensionKind.addEnumValue(x,false);
290 }
291 }
292
293public:
294 // Interfaces for main CaseOptions
295
296 Arcane::String getFilename() { return filename(); }
297 Arcane::ICaseFunction* getFilenameFunction() { return filename.function(); }
298 Arcane::IStandardFunction* getFilenameStandardFunction() { return filename.standardFunction(); }
299 Arcane::String getPartitioner() { return partitioner(); }
300 Arcane::ICaseFunction* getPartitionerFunction() { return partitioner.function(); }
301 Arcane::IStandardFunction* getPartitionerStandardFunction() { return partitioner.standardFunction(); }
302 Arcane::Int32 getNbGhostLayer() { return nbGhostLayer(); }
303 Arcane::ICaseFunction* getNbGhostLayerFunction() { return nbGhostLayer.function(); }
304 Arcane::IStandardFunction* getNbGhostLayerStandardFunction() { return nbGhostLayer.standardFunction(); }
305 Arcane::Int32 getGhostLayerBuilderVersion() { return ghostLayerBuilderVersion(); }
306 Arcane::ICaseFunction* getGhostLayerBuilderVersionFunction() { return ghostLayerBuilderVersion.function(); }
307 Arcane::IStandardFunction* getGhostLayerBuilderVersionStandardFunction() { return ghostLayerBuilderVersion.standardFunction(); }
308 Arcane::Int32 getFaceNumberingVersion() { return faceNumberingVersion(); }
309 Arcane::ICaseFunction* getFaceNumberingVersionFunction() { return faceNumberingVersion.function(); }
310 Arcane::IStandardFunction* getFaceNumberingVersionStandardFunction() { return faceNumberingVersion.standardFunction(); }
311 Arcane::Int32 getEdgeNumberingVersion() { return edgeNumberingVersion(); }
312 Arcane::ICaseFunction* getEdgeNumberingVersionFunction() { return edgeNumberingVersion.function(); }
313 Arcane::IStandardFunction* getEdgeNumberingVersionStandardFunction() { return edgeNumberingVersion.standardFunction(); }
314
315
316 Arcane::eMeshCellDimensionKind getCellDimensionKind() { return cellDimensionKind(); }
317
318 Arcane::IMeshBuilder* getGenerator() { return generator(); }
319 Arcane::ICaseMeshReader* getSpecificReader() { return specificReader(); }
320 Arcane::IMeshSubdivider* getSubdivider() { return subdivider(); }
321 // Interfaces for complex options
322 bool hasGenerator() const
323 { return generator.isPresent(); }
324 bool hasFilename() const
325 { return filename.isPresent(); }
326 bool hasFaceNumberingVersion() const
327 { return faceNumberingVersion.isPresent(); }
328 bool hasEdgeNumberingVersion() const
329 { return edgeNumberingVersion.isPresent(); }
330 bool hasSpecificReader() const
331 { return specificReader.isPresent(); }
332 bool hasSubdivider() const
333 { return subdivider.isPresent(); }
334
335
336public:
337
338 Arcane::ICaseOptions* caseOptions() const
339 {
340 return m_case_options.get();
341 }
342
343 Arcane::ICaseOptionList* configList() const
344 {
345 return m_case_options->configList();
346 }
347
348 void setCaseModule(Arcane::IModule* m)
349 {
350 m_case_options->setCaseModule(m);
351 }
352
353 void setCaseServiceInfo(Arcane::IServiceInfo* si)
354 {
355 m_case_options->setCaseServiceInfo(si);
356 }
357
358 void addAlternativeNodeName(const Arcane::String& lang,
359 const Arcane::String& name)
360 {
361 m_case_options->addAlternativeNodeName(lang,name);
362 }
363
364private:
365
366 Arcane::ICaseOptionList* _configList() const { return configList(); }
367 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
368
369private:
370
371 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
372
373 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
374
375public:
376
377
378 Arcane::CaseOptionString filename;
379 Arcane::CaseOptionString partitioner;
380 Arcane::CaseOptionInt32 nbGhostLayer;
381 Arcane::CaseOptionInt32 ghostLayerBuilderVersion;
382 Arcane::CaseOptionInt32 faceNumberingVersion;
383 Arcane::CaseOptionInt32 edgeNumberingVersion;
384 Arcane::CaseOptionServiceT< Arcane::IMeshBuilder > generator;
385 Arcane::CaseOptionServiceT< Arcane::ICaseMeshReader > specificReader;
386 Arcane::CaseOptionServiceT< Arcane::IMeshSubdivider > subdivider;
387 Arcane::CaseOptionEnumT< Arcane::eMeshCellDimensionKind > cellDimensionKind;
388 CaseOptionInit initialization;
389};
390
391/*---------------------------------------------------------------------------*/
392/*---------------------------------------------------------------------------*/
393
394#endif
395
396
397
398/*---------------------------------------------------------------------------*/
399/*---------------------------------------------------------------------------*/
400// #WARNING#: This file has been generated automatically. Do not edit.
401// Axlstar version 1.0
402/*---------------------------------------------------------------------------*/
403/*---------------------------------------------------------------------------*/
404
405#ifndef ARCANE_MODULE_AXLSTAR_ARCANECASEMESHSERVICE_H
406#define ARCANE_MODULE_AXLSTAR_ARCANECASEMESHSERVICE_H
407
408/*---------------------------------------------------------------------------*/
409/*---------------------------------------------------------------------------*/
410
411#include "arcane/VariableTypes.h"
412#include "arcane/ServiceInfo.h"
413#include "arcane/ISubDomain.h"
414#include "arcane/ServiceBuildInfo.h"
415#include "arcane/ServiceFactory.h"
416#include "arcane/ServiceRegisterer.h"
417#include "arcane/BasicService.h"
418
419#ifndef ARCANE_HAS_SPECIFIC_BASIC_SERVICE
420// Code pour les versions de Arcane avant la 3.8 qui ne possèdent pas les
421// classes de base spécifiques pour les services
422namespace Arcane
423{
424using BasicCaseOptionService = BasicService;
425using BasicSubDomainService = BasicService;
426using BasicMeshService = BasicService;
427}
428#endif
429
430/*---------------------------------------------------------------------------*/
431/*---------------------------------------------------------------------------*/
432
434
435/*---------------------------------------------------------------------------*/
436/*---------------------------------------------------------------------------*/
437
442{
443public:
444 // NOTE GG: attention code dupliqué avec 'ServiceT4CaseAndStrong'. Bien reporter les modifications
445 template <typename ServiceClassType> static void fillServiceInfo(Arcane::ServiceInfo* si)
446 {
447 si->setCaseOptionsFileName("ArcaneCaseMeshService_arcane_impl");
448 si->setAxlVersion(1.0);
449 si->setDefaultTagName("arcane-case-mesh-service");
450 si->setAxlContent(getAxlContent());
453);
454 }
455
456public:
457
460 : Arcane::AbstractService(sbi)
461 , m_options(nullptr)
462 {
464 if (co) {
466 }
467
468 }
469
472 {
473 delete m_options;
474 }
475
476
477public:
478
481
482private:
483
486
487protected:
488
490private:
492 {
493 const Arcane::Byte* content = (const Arcane::Byte*)"";
494 Arcane::Span<const Arcane::Byte> bytes(content,0);
495 int file_version = 1;
496 return Arcane::FileContent(bytes,file_version,"");
497 }
498};
499
500/*---------------------------------------------------------------------------*/
501/*---------------------------------------------------------------------------*/
502
503#define ARCANE_REGISTER_SERVICE_ARCANECASEMESHSERVICE(service_name,class_name) \
504 ARCANE_REGISTER_AXL_SERVICE(class_name,Arcane::ServiceProperty(#service_name,Arcane::ST_CaseOption,\
505 Arcane::SFP_None ))
506
507/*---------------------------------------------------------------------------*/
508/*---------------------------------------------------------------------------*/
509
510#endif
511
#define ARCANE_SERVICE_INTERFACE(ainterface)
Macro pour déclarer une interface lors de l'enregistrement d'un service.
CaseOptionsArcaneCaseMeshService * options() const
Options du jeu de données du service.
static Arcane::FileContent getAxlContent()
Variables du service.
virtual ~ArcaneArcaneCaseMeshServiceObject()
Destructeur.
ArcaneArcaneCaseMeshServiceObject(const Arcane::ServiceBuildInfo &sbi)
Constructeur.
CaseOptionsArcaneCaseMeshService * m_options
Options du jeu de données du service.
Classe de base d'un service.
AbstractService(const ServiceBuildInfo &)
Constructeur à partir d'un ServiceBuildInfo.
Vue modifiable d'un tableau d'un type T.
Classe de base de service lié à un sous-domaine.
Informations pour construire une option de jeu de données.
Classe de base d'une valeur d'une option complexe.
Nom et valeur d'une énumération du jeu de données.
Classe de base d'un tableau d'options complexes du jeu de données.
Classe de base d'une liste d'options du jeu de données.
Definition CaseOptions.h:57
Description et contenu d'un fichier.
Definition FileContent.h:32
Interface d'une fonction du jeu de données.
Interface du service gérant les maillages du jeu de données.
Interface d'une liste d'options du jeu de données.
Interface d'une liste d'options présente plusieurs fois.
Interface d'une liste d'options du jeu de données.
Interface gérant une fonction standard.
Informations d'un service.
Definition ServiceInfo.h:46
static void registerToServiceInfo(ServiceInfo *si, const Interfaces &... args)
Enregistre dans le service les fabriques pour les interfacs Interfaces.
ICaseOptions * caseOptions() const
Accès au ICaseOptions associé.
Structure contenant les informations pour créer un service.
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Chaîne de caractères unicode.
Liste de noeuds d'un arbre DOM.
Definition XmlNodeList.h:35
Noeud d'un arbre DOM.
Definition XmlNode.h:51
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
eMeshCellDimensionKind
Types de gestion de la dimension du maillage.
Definition MeshKind.h:72
@ MultiDimension
Les mailles ont la même dimension que le maillage ou une dimension inférieure.
Definition MeshKind.h:76
@ NonManifold
Maillage non manifold.
Definition MeshKind.h:84
@ MonoDimension
Les mailles ont la même dimension que le maillage.
Definition MeshKind.h:74
Int32 Integer
Type représentant un entier.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
std::int32_t Int32
Type entier signé sur 32 bits.