Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Cartesian3DMeshGenerator_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_CARTESIAN3DMESHGENERATOR_H
9#define ARCANE_CASEOPTION_AXLSTAR_CARTESIAN3DMESHGENERATOR_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
21/*---------------------------------------------------------------------------*/
22/*---------------------------------------------------------------------------*/
23
24ARCANE_BEGIN_NAMESPACE
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
30class CaseOptionsCartesian3DMeshGenerator
31{
32public:
33
34 /*-------------------------------------------------------------------------*/
35 /*--------------------------- Complex Options -----------------------------*/
36 /*-------------------------------------------------------------------------*/
37 // Generation for option 'x'
38 // Generating multiple arity CaseOption for complex option value 'x'
39 class CaseOptionPartInfoXValue
40 : public Arcane::CaseOptionComplexValue
41 {
42 public:
43
44 typedef CaseOptionPartInfoXValue ThatClass;
45
46 CaseOptionPartInfoXValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
47 : Arcane::CaseOptionComplexValue(opt,icl,element)
48 , n(Arcane::CaseOptionBuildInfo(_configList(),
49 /* name */ "n", _element(),
50 /* default */ Arcane::String(),
51 /* min-occurs */ 1,
52 /* max-occurs */ 1,
53 /* optional */ false))
54 , length(Arcane::CaseOptionBuildInfo(_configList(),
55 /* name */ "length", _element(),
56 /* default */ Arcane::String(),
57 /* min-occurs */ 1,
58 /* max-occurs */ 1,
59 /* optional */ false))
60 , progression(Arcane::CaseOptionBuildInfo(_configList(),
61 /* name */ "progression", _element(),
62 /* default */ "1.0",
63 /* min-occurs */ 1,
64 /* max-occurs */ 1,
65 /* optional */ false))
66
67 {
68
69
70 }
71 public:
72 // Interfaces for multi-arity class CaseOptionsPartInfoX
73
74 Arcane::Integer getN() { return n(); }
75 Arcane::ICaseFunction* getNFunction() { return n.function(); }
76 Arcane::IStandardFunction* getNStandardFunction() { return n.standardFunction(); }
77 Arcane::Real getLength() { return length(); }
78 Arcane::ICaseFunction* getLengthFunction() { return length.function(); }
79 Arcane::IStandardFunction* getLengthStandardFunction() { return length.standardFunction(); }
80 Arcane::Real getProgression() { return progression(); }
81 Arcane::ICaseFunction* getProgressionFunction() { return progression.function(); }
82 Arcane::IStandardFunction* getProgressionStandardFunction() { return progression.standardFunction(); }
83
84
85
86 // Interfaces for complex options
87
88
89 public:
90
91 const ThatClass* operator->() const { return this; }
92
93 public:
94
95 Arcane::CaseOptionInteger n;
96 Arcane::CaseOptionReal length;
97 Arcane::CaseOptionReal progression;
98 };
99
100 // Generation for sub-option 'x'
101 class CaseOptionPartInfoX
102 : public Arcane::CaseOptionsMulti
103 , private Arcane::ArrayView< CaseOptionPartInfoXValue * >
104 {
105 public:
106
107 typedef Arcane::ArrayView< CaseOptionPartInfoXValue * > BaseClass;
108
109 typedef CaseOptionPartInfoXValue value_type;
110
111 public:
112
113 CaseOptionPartInfoX(Arcane::ICaseOptionList* icl,
114 const Arcane::String& s, const Arcane::XmlNode& element)
115 : Arcane::CaseOptionsMulti(icl,s,element,1,-1)
116 {
117 // Generating translations and default values.
118 }
119
120 BaseClass operator()() { return (*this); }
121
122 protected:
123 void multiAllocate(const Arcane::XmlNodeList& elist)
124 {
125 Arcane::Integer s = elist.size();
126 value_type** v = 0;
127 if (s!=0)
128 v = new value_type*[s];
129 _setArray(v,s);
130 v = _ptr();
131 for( Arcane::Integer i=0; i<s; ++i ){
132 v[i] = new value_type(this,configList(),elist[i]);
133 }
134 }
135
136 public:
137
138 ~CaseOptionPartInfoX()
139 {
140 Arcane::Integer s = count();
141 if (s==0) return;
142 value_type** v = _ptr();
143 for( Arcane::Integer i=0; i<s; ++i ){
144 delete v[i];
145 }
146 delete[] v;
147 }
148
149 public:
150
151 const value_type& operator[](Arcane::Integer i) const
152 { return *(BaseClass::operator[](i)); }
153 value_type& operator[](Arcane::Integer i)
154 { return *(BaseClass::operator[](i)); }
155 Arcane::Integer count() const
156 { return BaseClass::size(); }
157 Arcane::Integer size() const
158 { return BaseClass::size(); }
159
160 };
161
162 // Generation for option 'y'
163 // Generating multiple arity CaseOption for complex option value 'y'
164 class CaseOptionPartInfoYValue
165 : public Arcane::CaseOptionComplexValue
166 {
167 public:
168
169 typedef CaseOptionPartInfoYValue ThatClass;
170
171 CaseOptionPartInfoYValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
172 : Arcane::CaseOptionComplexValue(opt,icl,element)
173 , n(Arcane::CaseOptionBuildInfo(_configList(),
174 /* name */ "n", _element(),
175 /* default */ Arcane::String(),
176 /* min-occurs */ 1,
177 /* max-occurs */ 1,
178 /* optional */ false))
179 , length(Arcane::CaseOptionBuildInfo(_configList(),
180 /* name */ "length", _element(),
181 /* default */ Arcane::String(),
182 /* min-occurs */ 1,
183 /* max-occurs */ 1,
184 /* optional */ false))
185 , progression(Arcane::CaseOptionBuildInfo(_configList(),
186 /* name */ "progression", _element(),
187 /* default */ "1.0",
188 /* min-occurs */ 1,
189 /* max-occurs */ 1,
190 /* optional */ false))
191
192 {
193
194
195 }
196 public:
197 // Interfaces for multi-arity class CaseOptionsPartInfoY
198
199 Arcane::Integer getN() { return n(); }
200 Arcane::ICaseFunction* getNFunction() { return n.function(); }
201 Arcane::IStandardFunction* getNStandardFunction() { return n.standardFunction(); }
202 Arcane::Real getLength() { return length(); }
203 Arcane::ICaseFunction* getLengthFunction() { return length.function(); }
204 Arcane::IStandardFunction* getLengthStandardFunction() { return length.standardFunction(); }
205 Arcane::Real getProgression() { return progression(); }
206 Arcane::ICaseFunction* getProgressionFunction() { return progression.function(); }
207 Arcane::IStandardFunction* getProgressionStandardFunction() { return progression.standardFunction(); }
208
209
210
211 // Interfaces for complex options
212
213
214 public:
215
216 const ThatClass* operator->() const { return this; }
217
218 public:
219
220 Arcane::CaseOptionInteger n;
221 Arcane::CaseOptionReal length;
222 Arcane::CaseOptionReal progression;
223 };
224
225 // Generation for sub-option 'y'
226 class CaseOptionPartInfoY
227 : public Arcane::CaseOptionsMulti
228 , private Arcane::ArrayView< CaseOptionPartInfoYValue * >
229 {
230 public:
231
232 typedef Arcane::ArrayView< CaseOptionPartInfoYValue * > BaseClass;
233
234 typedef CaseOptionPartInfoYValue value_type;
235
236 public:
237
238 CaseOptionPartInfoY(Arcane::ICaseOptionList* icl,
239 const Arcane::String& s, const Arcane::XmlNode& element)
240 : Arcane::CaseOptionsMulti(icl,s,element,1,-1)
241 {
242 // Generating translations and default values.
243 }
244
245 BaseClass operator()() { return (*this); }
246
247 protected:
248 void multiAllocate(const Arcane::XmlNodeList& elist)
249 {
250 Arcane::Integer s = elist.size();
251 value_type** v = 0;
252 if (s!=0)
253 v = new value_type*[s];
254 _setArray(v,s);
255 v = _ptr();
256 for( Arcane::Integer i=0; i<s; ++i ){
257 v[i] = new value_type(this,configList(),elist[i]);
258 }
259 }
260
261 public:
262
263 ~CaseOptionPartInfoY()
264 {
265 Arcane::Integer s = count();
266 if (s==0) return;
267 value_type** v = _ptr();
268 for( Arcane::Integer i=0; i<s; ++i ){
269 delete v[i];
270 }
271 delete[] v;
272 }
273
274 public:
275
276 const value_type& operator[](Arcane::Integer i) const
277 { return *(BaseClass::operator[](i)); }
278 value_type& operator[](Arcane::Integer i)
279 { return *(BaseClass::operator[](i)); }
280 Arcane::Integer count() const
281 { return BaseClass::size(); }
282 Arcane::Integer size() const
283 { return BaseClass::size(); }
284
285 };
286
287 // Generation for option 'z'
288 // Generating multiple arity CaseOption for complex option value 'z'
289 class CaseOptionPartInfoZValue
290 : public Arcane::CaseOptionComplexValue
291 {
292 public:
293
294 typedef CaseOptionPartInfoZValue ThatClass;
295
296 CaseOptionPartInfoZValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
297 : Arcane::CaseOptionComplexValue(opt,icl,element)
298 , n(Arcane::CaseOptionBuildInfo(_configList(),
299 /* name */ "n", _element(),
300 /* default */ Arcane::String(),
301 /* min-occurs */ 1,
302 /* max-occurs */ 1,
303 /* optional */ false))
304 , length(Arcane::CaseOptionBuildInfo(_configList(),
305 /* name */ "length", _element(),
306 /* default */ Arcane::String(),
307 /* min-occurs */ 1,
308 /* max-occurs */ 1,
309 /* optional */ false))
310 , progression(Arcane::CaseOptionBuildInfo(_configList(),
311 /* name */ "progression", _element(),
312 /* default */ "1.0",
313 /* min-occurs */ 1,
314 /* max-occurs */ 1,
315 /* optional */ false))
316
317 {
318
319
320 }
321 public:
322 // Interfaces for multi-arity class CaseOptionsPartInfoZ
323
324 Arcane::Integer getN() { return n(); }
325 Arcane::ICaseFunction* getNFunction() { return n.function(); }
326 Arcane::IStandardFunction* getNStandardFunction() { return n.standardFunction(); }
327 Arcane::Real getLength() { return length(); }
328 Arcane::ICaseFunction* getLengthFunction() { return length.function(); }
329 Arcane::IStandardFunction* getLengthStandardFunction() { return length.standardFunction(); }
330 Arcane::Real getProgression() { return progression(); }
331 Arcane::ICaseFunction* getProgressionFunction() { return progression.function(); }
332 Arcane::IStandardFunction* getProgressionStandardFunction() { return progression.standardFunction(); }
333
334
335
336 // Interfaces for complex options
337
338
339 public:
340
341 const ThatClass* operator->() const { return this; }
342
343 public:
344
345 Arcane::CaseOptionInteger n;
346 Arcane::CaseOptionReal length;
347 Arcane::CaseOptionReal progression;
348 };
349
350 // Generation for sub-option 'z'
351 class CaseOptionPartInfoZ
352 : public Arcane::CaseOptionsMulti
353 , private Arcane::ArrayView< CaseOptionPartInfoZValue * >
354 {
355 public:
356
357 typedef Arcane::ArrayView< CaseOptionPartInfoZValue * > BaseClass;
358
359 typedef CaseOptionPartInfoZValue value_type;
360
361 public:
362
363 CaseOptionPartInfoZ(Arcane::ICaseOptionList* icl,
364 const Arcane::String& s, const Arcane::XmlNode& element)
365 : Arcane::CaseOptionsMulti(icl,s,element,1,-1)
366 {
367 // Generating translations and default values.
368 }
369
370 BaseClass operator()() { return (*this); }
371
372 protected:
373 void multiAllocate(const Arcane::XmlNodeList& elist)
374 {
375 Arcane::Integer s = elist.size();
376 value_type** v = 0;
377 if (s!=0)
378 v = new value_type*[s];
379 _setArray(v,s);
380 v = _ptr();
381 for( Arcane::Integer i=0; i<s; ++i ){
382 v[i] = new value_type(this,configList(),elist[i]);
383 }
384 }
385
386 public:
387
388 ~CaseOptionPartInfoZ()
389 {
390 Arcane::Integer s = count();
391 if (s==0) return;
392 value_type** v = _ptr();
393 for( Arcane::Integer i=0; i<s; ++i ){
394 delete v[i];
395 }
396 delete[] v;
397 }
398
399 public:
400
401 const value_type& operator[](Arcane::Integer i) const
402 { return *(BaseClass::operator[](i)); }
403 value_type& operator[](Arcane::Integer i)
404 { return *(BaseClass::operator[](i)); }
405 Arcane::Integer count() const
406 { return BaseClass::size(); }
407 Arcane::Integer size() const
408 { return BaseClass::size(); }
409
410 };
411
412
413 /*-------------------------------------------------------------------------*/
414 /*--------------------------- Non Complex Options -------------------------*/
415 /*-------------------------------------------------------------------------*/
416
417 CaseOptionsCartesian3DMeshGenerator(Arcane::ICaseOptions* co)
418 : m_case_options(co)
419 , origin(Arcane::CaseOptionBuildInfo(_configList(),
420 /* name */ "origin", _element(),
421 /* default */ Arcane::String(),
422 /* min-occurs */ 1,
423 /* max-occurs */ 1,
424 /* optional */ false))
425 , nbPartX(Arcane::CaseOptionBuildInfo(_configList(),
426 /* name */ "nb-part-x", _element(),
427 /* default */ Arcane::String(),
428 /* min-occurs */ 1,
429 /* max-occurs */ 1,
430 /* optional */ false))
431 , nbPartY(Arcane::CaseOptionBuildInfo(_configList(),
432 /* name */ "nb-part-y", _element(),
433 /* default */ Arcane::String(),
434 /* min-occurs */ 1,
435 /* max-occurs */ 1,
436 /* optional */ false))
437 , nbPartZ(Arcane::CaseOptionBuildInfo(_configList(),
438 /* name */ "nb-part-z", _element(),
439 /* default */ Arcane::String(),
440 /* min-occurs */ 1,
441 /* max-occurs */ 1,
442 /* optional */ false))
443 , generateSodGroups(Arcane::CaseOptionBuildInfo(_configList(),
444 /* name */ "generate-sod-groups", _element(),
445 /* default */ "false",
446 /* min-occurs */ 1,
447 /* max-occurs */ 1,
448 /* optional */ false))
449 , faceNumberingVersion(Arcane::CaseOptionBuildInfo(_configList(),
450 /* name */ "face-numbering-version", _element(),
451 /* default */ "4",
452 /* min-occurs */ 1,
453 /* max-occurs */ 1,
454 /* optional */ false))
455 , edgeNumberingVersion(Arcane::CaseOptionBuildInfo(_configList(),
456 /* name */ "edge-numbering-version", _element(),
457 /* default */ "2",
458 /* min-occurs */ 1,
459 /* max-occurs */ 1,
460 /* optional */ false))
461 , x(_configList(),
462 /* name */ "x", _element())
463 , y(_configList(),
464 /* name */ "y", _element())
465 , z(_configList(),
466 /* name */ "z", _element())
467 {
468
469 }
470
471public:
472 // Interfaces for main CaseOptions
473
474 Arcane::Real3 getOrigin() { return origin(); }
475 Arcane::ICaseFunction* getOriginFunction() { return origin.function(); }
476 Arcane::IStandardFunction* getOriginStandardFunction() { return origin.standardFunction(); }
477 Arcane::Integer getNbPartX() { return nbPartX(); }
478 Arcane::ICaseFunction* getNbPartXFunction() { return nbPartX.function(); }
479 Arcane::IStandardFunction* getNbPartXStandardFunction() { return nbPartX.standardFunction(); }
480 Arcane::Integer getNbPartY() { return nbPartY(); }
481 Arcane::ICaseFunction* getNbPartYFunction() { return nbPartY.function(); }
482 Arcane::IStandardFunction* getNbPartYStandardFunction() { return nbPartY.standardFunction(); }
483 Arcane::Integer getNbPartZ() { return nbPartZ(); }
484 Arcane::ICaseFunction* getNbPartZFunction() { return nbPartZ.function(); }
485 Arcane::IStandardFunction* getNbPartZStandardFunction() { return nbPartZ.standardFunction(); }
486 bool getGenerateSodGroups() { return generateSodGroups(); }
487 Arcane::ICaseFunction* getGenerateSodGroupsFunction() { return generateSodGroups.function(); }
488 Arcane::IStandardFunction* getGenerateSodGroupsStandardFunction() { return generateSodGroups.standardFunction(); }
489 Arcane::Integer getFaceNumberingVersion() { return faceNumberingVersion(); }
490 Arcane::ICaseFunction* getFaceNumberingVersionFunction() { return faceNumberingVersion.function(); }
491 Arcane::IStandardFunction* getFaceNumberingVersionStandardFunction() { return faceNumberingVersion.standardFunction(); }
492 Arcane::Integer getEdgeNumberingVersion() { return edgeNumberingVersion(); }
493 Arcane::ICaseFunction* getEdgeNumberingVersionFunction() { return edgeNumberingVersion.function(); }
494 Arcane::IStandardFunction* getEdgeNumberingVersionStandardFunction() { return edgeNumberingVersion.standardFunction(); }
495
496
497
498 // Interfaces for complex options
499
500
501public:
502
503 Arcane::ICaseOptions* caseOptions() const
504 {
505 return m_case_options.get();
506 }
507
508 Arcane::ICaseOptionList* configList() const
509 {
510 return m_case_options->configList();
511 }
512
513 void setCaseModule(Arcane::IModule* m)
514 {
515 m_case_options->setCaseModule(m);
516 }
517
518 void setCaseServiceInfo(Arcane::IServiceInfo* si)
519 {
520 m_case_options->setCaseServiceInfo(si);
521 }
522
523 void addAlternativeNodeName(const Arcane::String& lang,
524 const Arcane::String& name)
525 {
526 m_case_options->addAlternativeNodeName(lang,name);
527 }
528
529private:
530
531 Arcane::ICaseOptionList* _configList() const { return configList(); }
532 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
533
534private:
535
536 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
537
538 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
539
540public:
541
542
543 Arcane::CaseOptionReal3 origin;
544 Arcane::CaseOptionInteger nbPartX;
545 Arcane::CaseOptionInteger nbPartY;
546 Arcane::CaseOptionInteger nbPartZ;
547 Arcane::CaseOptionBool generateSodGroups;
548 Arcane::CaseOptionInteger faceNumberingVersion;
549 Arcane::CaseOptionInteger edgeNumberingVersion;
550 CaseOptionPartInfoX x;
551 CaseOptionPartInfoY y;
552 CaseOptionPartInfoZ z;
553};
554
555/*---------------------------------------------------------------------------*/
556/*---------------------------------------------------------------------------*/
557
558ARCANE_END_NAMESPACE
559
560/*---------------------------------------------------------------------------*/
561/*---------------------------------------------------------------------------*/
562
563#endif
564
565
566
567/*---------------------------------------------------------------------------*/
568/*---------------------------------------------------------------------------*/
569// #WARNING#: This file has been generated automatically. Do not edit.
570// Axlstar version 1.0
571/*---------------------------------------------------------------------------*/
572/*---------------------------------------------------------------------------*/
573
574#ifndef ARCANE_MODULE_AXLSTAR_CARTESIAN3DMESHGENERATOR_H
575#define ARCANE_MODULE_AXLSTAR_CARTESIAN3DMESHGENERATOR_H
576
577/*---------------------------------------------------------------------------*/
578/*---------------------------------------------------------------------------*/
579
580#include "arcane/VariableTypes.h"
581#include "arcane/ServiceInfo.h"
582#include "arcane/ISubDomain.h"
583#include "arcane/ServiceBuildInfo.h"
584#include "arcane/ServiceFactory.h"
585#include "arcane/ServiceRegisterer.h"
586#include "arcane/BasicService.h"
587
588#ifndef ARCANE_HAS_SPECIFIC_BASIC_SERVICE
589// Code pour les versions de Arcane avant la 3.8 qui ne possèdent pas les
590// classes de base spécifiques pour les services
591namespace Arcane
592{
593using BasicCaseOptionService = BasicService;
594using BasicSubDomainService = BasicService;
595using BasicMeshService = BasicService;
596}
597#endif
598
599/*---------------------------------------------------------------------------*/
600/*---------------------------------------------------------------------------*/
601
602namespace Arcane
603{
604
605/*---------------------------------------------------------------------------*/
606/*---------------------------------------------------------------------------*/
607
608class CaseOptionsCartesian3DMeshGenerator;
609
610/*---------------------------------------------------------------------------*/
611/*---------------------------------------------------------------------------*/
612
614class ArcaneCartesian3DMeshGeneratorObject
615 : public Arcane::BasicCaseOptionService
616 , public Arcane::IMeshBuilder
617{
618public:
619 // NOTE GG: attention code dupliqué avec 'ServiceT4CaseAndStrong'. Bien reporter les modifications
620 template <typename ServiceClassType> static void fillServiceInfo(Arcane::ServiceInfo* si)
621 {
622 si->setCaseOptionsFileName("Cartesian3DMeshGenerator_arcane_std");
623 si->setAxlVersion(0.0);
624 si->setDefaultTagName("cartesian3-d-mesh-generator");
625 si->setAxlContent(getAxlContent());
626 Arcane::ServiceAllInterfaceRegisterer<ServiceClassType>::registerToServiceInfo(si
627 ,ARCANE_SERVICE_INTERFACE(Arcane::IMeshBuilder)
628);
629 }
630
631public:
632
634 ArcaneCartesian3DMeshGeneratorObject(const Arcane::ServiceBuildInfo& sbi)
635 : Arcane::BasicCaseOptionService(sbi)
636 , m_options(nullptr)
637 {
638 Arcane::ICaseOptions* co = sbi.caseOptions();
639 if (co) {
640 m_options = new CaseOptionsCartesian3DMeshGenerator(co);
641 }
642
643 }
644
646 virtual ~ArcaneCartesian3DMeshGeneratorObject()
647 {
648 delete m_options;
649 }
650
651
652public:
653
655 CaseOptionsCartesian3DMeshGenerator* options() const { return m_options; }
656
657private:
658
660 CaseOptionsCartesian3DMeshGenerator* m_options;
661
662protected:
663
665private:
666 static Arcane::FileContent getAxlContent()
667 {
668 const Arcane::Byte* content = (const Arcane::Byte*)"";
669 Arcane::Span<const Arcane::Byte> bytes(content,0);
670 int file_version = 1;
671 return Arcane::FileContent(bytes,file_version,"");
672 }
673};
674
675/*---------------------------------------------------------------------------*/
676/*---------------------------------------------------------------------------*/
677
678#define ARCANE_REGISTER_SERVICE_CARTESIAN3DMESHGENERATOR(service_name,class_name) \
679 ARCANE_REGISTER_AXL_SERVICE(class_name,Arcane::ServiceProperty(#service_name,Arcane::ST_CaseOption,\
680 Arcane::SFP_None ))
681
682/*---------------------------------------------------------------------------*/
683/*---------------------------------------------------------------------------*/
684
685} // End namespace Arcane
686
687/*---------------------------------------------------------------------------*/
688/*---------------------------------------------------------------------------*/
689
690#endif
691
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::ArcaneCartesian3DMeshGeneratorObject::m_options
CaseOptionsCartesian3DMeshGenerator * m_options
Options du jeu de données du service.
Definition Cartesian3DMeshGenerator_axl.h:660
Arcane::ArcaneCartesian3DMeshGeneratorObject::ArcaneCartesian3DMeshGeneratorObject
ArcaneCartesian3DMeshGeneratorObject(const Arcane::ServiceBuildInfo &sbi)
Constructeur.
Definition Cartesian3DMeshGenerator_axl.h:634
Arcane::ArcaneCartesian3DMeshGeneratorObject::options
CaseOptionsCartesian3DMeshGenerator * options() const
Options du jeu de données du service.
Definition Cartesian3DMeshGenerator_axl.h:655
Arcane::ArcaneCartesian3DMeshGeneratorObject::getAxlContent
static Arcane::FileContent getAxlContent()
Variables du service.
Definition Cartesian3DMeshGenerator_axl.h:666
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arcane::BasicService
Classe de base de service lié à un sous-domaine.
Definition BasicService.h:43
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::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::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::IStandardFunction
Interface gérant une fonction standard.
Definition IStandardFunction.h:42
Arcane::Internal::ServiceInfo
Informations d'un service.
Definition ServiceInfo.h:46
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Arcane::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::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::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::XmlNodeList
Liste de noeuds d'un arbre DOM.
Definition XmlNodeList.h:33
Arcane::XmlNode
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:223
Arcane::Byte
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43