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