Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
ArcaneCeaVerifier_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_ARCANECEAVERIFIER_H
9#define ARCANE_CASEOPTION_AXLSTAR_ARCANECEAVERIFIER_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 CaseOptionsArcaneCeaVerifier
31{
32public:
33
34 /*-------------------------------------------------------------------------*/
35 /*--------------------------- Complex Options -----------------------------*/
36 /*-------------------------------------------------------------------------*/
37 // Generation for option 'trace'
38 // Generating multiple arity CaseOption for complex option value 'trace'
39 class CaseOptionTraceValue
40 : public Arcane::CaseOptionComplexValue
41 {
42 public:
43
44 typedef CaseOptionTraceValue ThatClass;
45
46 CaseOptionTraceValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
47 : Arcane::CaseOptionComplexValue(opt,icl,element)
48 , variableName(Arcane::CaseOptionBuildInfo(_configList(),
49 /* name */ "variable-name", _element(),
50 /* default */ Arcane::String(),
51 /* min-occurs */ 1,
52 /* max-occurs */ 1,
53 /* optional */ false))
54 , uniqueId(Arcane::CaseOptionBuildInfo(_configList(),
55 /* name */ "unique-id", _element(),
56 /* default */ Arcane::String(),
57 /* min-occurs */ 0,
58 /* max-occurs */ -1,
59 /* optional */ false))
60
61 {
62
63variableName.addAlternativeNodeName(
64 /* language */ Arcane::String("fr"),
65 /* alternative name */ Arcane::String("nom-variable"));
66uniqueId.addAlternativeNodeName(
67 /* language */ Arcane::String("fr"),
68 /* alternative name */ Arcane::String("unique-id"));
69
70 }
71 public:
72 // Interfaces for multi-arity class CaseOptionsTrace
73
74 Arcane::ConstArrayView< Arcane::Integer > getUniqueId() { return uniqueId.values(); }
75 Arcane::String getVariableName() { return variableName(); }
76 Arcane::ICaseFunction* getVariableNameFunction() { return variableName.function(); }
77 Arcane::IStandardFunction* getVariableNameStandardFunction() { return variableName.standardFunction(); }
78
79
80
81 // Interfaces for complex options
82
83
84 public:
85
86 const ThatClass* operator->() const { return this; }
87
88 public:
89
90 Arcane::CaseOptionString variableName;
91 Arcane::CaseOptionMultiSimpleT< Arcane::Integer > uniqueId;
92 };
93
94 // Generation for sub-option 'trace'
95 class CaseOptionTrace
96 : public Arcane::CaseOptionsMulti
97 , private Arcane::ArrayView< CaseOptionTraceValue * >
98 {
99 public:
100
101 typedef Arcane::ArrayView< CaseOptionTraceValue * > BaseClass;
102
103 typedef CaseOptionTraceValue value_type;
104
105 public:
106
107 CaseOptionTrace(Arcane::ICaseOptionList* icl,
108 const Arcane::String& s, const Arcane::XmlNode& element)
109 : Arcane::CaseOptionsMulti(icl,s,element,0,-1)
110 {
111 // Generating translations and default values.
112 addAlternativeNodeName(
113 /* language */ Arcane::String("fr"),
114 /* alternative name */ Arcane::String("trace"));
115 }
116
117 BaseClass operator()() { return (*this); }
118
119 protected:
120 void multiAllocate(const Arcane::XmlNodeList& elist)
121 {
122 Arcane::Integer s = elist.size();
123 value_type** v = 0;
124 if (s!=0)
125 v = new value_type*[s];
126 _setArray(v,s);
127 v = _ptr();
128 for( Arcane::Integer i=0; i<s; ++i ){
129 v[i] = new value_type(this,configList(),elist[i]);
130 }
131 }
132
133 public:
134
135 ~CaseOptionTrace()
136 {
137 Arcane::Integer s = count();
138 if (s==0) return;
139 value_type** v = _ptr();
140 for( Arcane::Integer i=0; i<s; ++i ){
141 delete v[i];
142 }
143 delete[] v;
144 }
145
146 public:
147
148 const value_type& operator[](Arcane::Integer i) const
149 { return *(BaseClass::operator[](i)); }
150 value_type& operator[](Arcane::Integer i)
151 { return *(BaseClass::operator[](i)); }
152 Arcane::Integer count() const
153 { return BaseClass::size(); }
154 Arcane::Integer size() const
155 { return BaseClass::size(); }
156
157 };
158
159
160 /*-------------------------------------------------------------------------*/
161 /*--------------------------- Non Complex Options -------------------------*/
162 /*-------------------------------------------------------------------------*/
163
164 CaseOptionsArcaneCeaVerifier(Arcane::ICaseMng* cm)
165 : m_case_options(new Arcane::CaseOptions(cm,"arcane-cea-verifier"))
166 , verify(Arcane::CaseOptionBuildInfo(_configList(),
167 /* name */ "verify", _element(),
168 /* default */ "false",
169 /* min-occurs */ 1,
170 /* max-occurs */ 1,
171 /* optional */ false))
172 , generate(Arcane::CaseOptionBuildInfo(_configList(),
173 /* name */ "generate", _element(),
174 /* default */ "false",
175 /* min-occurs */ 1,
176 /* max-occurs */ 1,
177 /* optional */ false))
178 , referenceFile(Arcane::CaseOptionBuildInfo(_configList(),
179 /* name */ "reference-file", _element(),
180 /* default */ "verif",
181 /* min-occurs */ 1,
182 /* max-occurs */ 1,
183 /* optional */ false))
184 , compareParallelSequential(Arcane::CaseOptionBuildInfo(_configList(),
185 /* name */ "compare-parallel-sequential", _element(),
186 /* default */ "false",
187 /* min-occurs */ 1,
188 /* max-occurs */ 1,
189 /* optional */ false))
190 , resultFile(Arcane::CaseOptionBuildInfo(_configList(),
191 /* name */ "result-file", _element(),
192 /* default */ "compare.xml",
193 /* min-occurs */ 1,
194 /* max-occurs */ 1,
195 /* optional */ false))
196 , verifierServiceName(Arcane::CaseOptionBuildInfo(_configList(),
197 /* name */ "verifier-service-name", _element(),
198 /* default */ "ArcaneBasicVerifier2",
199 /* min-occurs */ 1,
200 /* max-occurs */ 1,
201 /* optional */ false))
202 , filesInOutputDir(Arcane::CaseOptionBuildInfo(_configList(),
203 /* name */ "files-in-output-dir", _element(),
204 /* default */ "false",
205 /* min-occurs */ 1,
206 /* max-occurs */ 1,
207 /* optional */ false))
208 , trace(_configList(),
209 /* name */ "trace", _element())
210 {
211
212verify.addAlternativeNodeName(
213 /* language */ Arcane::String("fr"),
214 /* alternative name */ Arcane::String("verification-active"));
215generate.addAlternativeNodeName(
216 /* language */ Arcane::String("fr"),
217 /* alternative name */ Arcane::String("generation"));
218referenceFile.addAlternativeNodeName(
219 /* language */ Arcane::String("fr"),
220 /* alternative name */ Arcane::String("fichier-reference"));
221compareParallelSequential.addAlternativeNodeName(
222 /* language */ Arcane::String("fr"),
223 /* alternative name */ Arcane::String("comparaison-parallele-sequentiel"));
224resultFile.addAlternativeNodeName(
225 /* language */ Arcane::String("fr"),
226 /* alternative name */ Arcane::String("fichier-resultat"));
227filesInOutputDir.addAlternativeNodeName(
228 /* language */ Arcane::String("fr"),
229 /* alternative name */ Arcane::String("fichiers-dans-dossier-output"));
230trace.addAlternativeNodeName(
231 /* language */ Arcane::String("fr"),
232 /* alternative name */ Arcane::String("trace"));
233addAlternativeNodeName(
234 /* language */ Arcane::String("fr"),
235 /* alternative name */ Arcane::String("verificateur"));
236 }
237
238public:
239 // Interfaces for main CaseOptions
240
241 bool getVerify() { return verify(); }
242 Arcane::ICaseFunction* getVerifyFunction() { return verify.function(); }
243 Arcane::IStandardFunction* getVerifyStandardFunction() { return verify.standardFunction(); }
244 bool getGenerate() { return generate(); }
245 Arcane::ICaseFunction* getGenerateFunction() { return generate.function(); }
246 Arcane::IStandardFunction* getGenerateStandardFunction() { return generate.standardFunction(); }
247 Arcane::String getReferenceFile() { return referenceFile(); }
248 Arcane::ICaseFunction* getReferenceFileFunction() { return referenceFile.function(); }
249 Arcane::IStandardFunction* getReferenceFileStandardFunction() { return referenceFile.standardFunction(); }
250 bool getCompareParallelSequential() { return compareParallelSequential(); }
251 Arcane::ICaseFunction* getCompareParallelSequentialFunction() { return compareParallelSequential.function(); }
252 Arcane::IStandardFunction* getCompareParallelSequentialStandardFunction() { return compareParallelSequential.standardFunction(); }
253 Arcane::String getResultFile() { return resultFile(); }
254 Arcane::ICaseFunction* getResultFileFunction() { return resultFile.function(); }
255 Arcane::IStandardFunction* getResultFileStandardFunction() { return resultFile.standardFunction(); }
256 Arcane::String getVerifierServiceName() { return verifierServiceName(); }
257 Arcane::ICaseFunction* getVerifierServiceNameFunction() { return verifierServiceName.function(); }
258 Arcane::IStandardFunction* getVerifierServiceNameStandardFunction() { return verifierServiceName.standardFunction(); }
259 bool getFilesInOutputDir() { return filesInOutputDir(); }
260 Arcane::ICaseFunction* getFilesInOutputDirFunction() { return filesInOutputDir.function(); }
261 Arcane::IStandardFunction* getFilesInOutputDirStandardFunction() { return filesInOutputDir.standardFunction(); }
262
263
264
265 // Interfaces for complex options
266
267
268public:
269
270 Arcane::ICaseOptions* caseOptions() const
271 {
272 return m_case_options.get();
273 }
274
275 Arcane::ICaseOptionList* configList() const
276 {
277 return m_case_options->configList();
278 }
279
280 void setCaseModule(Arcane::IModule* m)
281 {
282 m_case_options->setCaseModule(m);
283 }
284
285 void setCaseServiceInfo(Arcane::IServiceInfo* si)
286 {
287 m_case_options->setCaseServiceInfo(si);
288 }
289
290 void addAlternativeNodeName(const Arcane::String& lang,
291 const Arcane::String& name)
292 {
293 m_case_options->addAlternativeNodeName(lang,name);
294 }
295
296private:
297
298 Arcane::ICaseOptionList* _configList() const { return configList(); }
299 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
300
301private:
302
303 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
304
305 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
306
307public:
308
309
310 Arcane::CaseOptionBool verify;
311 Arcane::CaseOptionBool generate;
312 Arcane::CaseOptionString referenceFile;
313 Arcane::CaseOptionBool compareParallelSequential;
314 Arcane::CaseOptionString resultFile;
315 Arcane::CaseOptionString verifierServiceName;
316 Arcane::CaseOptionBool filesInOutputDir;
317 CaseOptionTrace trace;
318};
319
320/*---------------------------------------------------------------------------*/
321/*---------------------------------------------------------------------------*/
322
323ARCANE_END_NAMESPACE
324
325/*---------------------------------------------------------------------------*/
326/*---------------------------------------------------------------------------*/
327
328#endif
329
330
331
332/*---------------------------------------------------------------------------*/
333/*---------------------------------------------------------------------------*/
334// #WARNING#: This file has been generated automatically. Do not edit.
335// Axlstar version 1.0
336/*---------------------------------------------------------------------------*/
337/*---------------------------------------------------------------------------*/
338
339#ifndef ARCANE_MODULE_AXLSTAR_ARCANECEAVERIFIER_H
340#define ARCANE_MODULE_AXLSTAR_ARCANECEAVERIFIER_H
341
342/*---------------------------------------------------------------------------*/
343/*---------------------------------------------------------------------------*/
344
345#include "arcane/VariableTypes.h"
346#include "arcane/EntryPoint.h"
347#include "arcane/ISubDomain.h"
348#include "arcane/ModuleBuildInfo.h"
349#include "arcane/ModuleFactory.h"
350#include "arcane/ServiceRegisterer.h"
351#include "arcane/BasicModule.h"
352#include "arcane/ServiceInfo.h"
353
354/*---------------------------------------------------------------------------*/
355/*---------------------------------------------------------------------------*/
356
357namespace Arcane
358{
359class ISubDomain;
360class IModule;
361}
362
363/*---------------------------------------------------------------------------*/
364/*---------------------------------------------------------------------------*/
365
366namespace Arcane
367{
368
369/*---------------------------------------------------------------------------*/
370/*---------------------------------------------------------------------------*/
371
372class CaseOptionsArcaneCeaVerifier;
373
374/*---------------------------------------------------------------------------*/
375/*---------------------------------------------------------------------------*/
376
378class ArcaneArcaneCeaVerifierObject
379 : public Arcane::BasicModule
380{
381public:
382
383 static void fillServiceInfo(Arcane::ServiceInfo* si)
384 {
385 si->setCaseOptionsFileName("ArcaneCeaVerifier_arcane_std");
386 si->setAxlVersion(0.0);
387 si->setDefaultTagName(Arcane::String("arcane-cea-verifier"));
388 si->setAxlContent(getAxlContent());
389 si->setTagName(Arcane::String("verificateur"),Arcane::String("fr"));
390 }
391
392public:
393
394 ArcaneArcaneCeaVerifierObject(const Arcane::ModuleBuildInfo& mb)
395 : Arcane::BasicModule(mb)
396 , m_options(nullptr)
397 {
398 m_options = new CaseOptionsArcaneCeaVerifier(mb.subDomain()->caseMng());
399 m_options->setCaseModule(this);
400 addEntryPoint(this, "VerifierOnExit",
401 &ArcaneArcaneCeaVerifierObject::onExit,
402 Arcane::IEntryPoint::WExit,
403 Arcane::IEntryPoint::PAutoLoadEnd);
404 addEntryPoint(this, "VerifierOnInit",
405 &ArcaneArcaneCeaVerifierObject::onInit,
406 Arcane::IEntryPoint::WInit,
407 Arcane::IEntryPoint::PAutoLoadBegin);
408 }
409
410 virtual ~ArcaneArcaneCeaVerifierObject()
411 {
412 delete m_options;
413 }
414
415public:
416
418 virtual void onExit() = 0; // OnExit
419 virtual void onInit() = 0; // OnInit
420
422 CaseOptionsArcaneCeaVerifier* options() const { return m_options; }
423
424private:
425
427 CaseOptionsArcaneCeaVerifier* m_options;
428
429protected:
430
432
433private:
434 static Arcane::FileContent getAxlContent()
435 {
436 const char* str_content = "";
437 const Arcane::Byte* content = (const Arcane::Byte*)(str_content);
438 Arcane::Span<const Arcane::Byte> bytes(content,0);
439 int file_version = 1;
440 return Arcane::FileContent(bytes,file_version,"");
441 }
442
443};
444
445/*---------------------------------------------------------------------------*/
446/*---------------------------------------------------------------------------*/
447
448#define ARCANE_REGISTER_MODULE_ARCANECEAVERIFIER(class_name) \
449 ARCANE_REGISTER_AXL_MODULE(class_name,Arcane::ModuleProperty("ArcaneCeaVerifier",true))
450
451/*---------------------------------------------------------------------------*/
452/*---------------------------------------------------------------------------*/
453
454} // End namespace Arcane
455
456/*---------------------------------------------------------------------------*/
457/*---------------------------------------------------------------------------*/
458
459#endif
460
Arcane::ArcaneArcaneCeaVerifierObject::options
CaseOptionsArcaneCeaVerifier * options() const
Options du jeu de données du module.
Definition ArcaneCeaVerifier_axl.h:422
Arcane::ArcaneArcaneCeaVerifierObject::onExit
virtual void onExit()=0
points d'entrée
Arcane::ArcaneArcaneCeaVerifierObject::getAxlContent
static Arcane::FileContent getAxlContent()
Variables du module.
Definition ArcaneCeaVerifier_axl.h:434
Arcane::ArcaneArcaneCeaVerifierObject::m_options
CaseOptionsArcaneCeaVerifier * m_options
Options du jeu de données du module.
Definition ArcaneCeaVerifier_axl.h:427
Arcane::ArrayView
Modifiable view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:96
Arcane::BasicModule
Basic module.
Definition BasicModule.h:42
Arcane::CaseOptionBuildInfo
Information for building a dataset option.
Definition CaseOptionBuildInfo.h:41
Arcane::CaseOptionComplexValue
Base class for a complex option value.
Definition CaseOptionComplexValue.h:40
Arcane::CaseOptionsMulti
Base class for an array of complex data set options.
Definition CaseOptionsMulti.h:36
Arcane::CaseOptions
Base class for a data set options list.
Definition CaseOptions.h:58
Arcane::CaseOptions::addAlternativeNodeName
void addAlternativeNodeName(const String &lang, const String &name) override
Adds a translation for the option name. Adds the option name name corresponding to language lang....
Definition CaseOptions.cc:263
Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550
Arcane::FileContent
Description and content of a file.
Definition FileContent.h:33
Arcane::ICaseFunction
Interface of a dataset function.
Definition ICaseFunction.h:46
Arcane::ICaseMng
Case manager interface.
Definition ICaseMng.h:57
Arcane::ICaseOptionList
Interface for a data set options list.
Definition ICaseOptionList.h:39
Arcane::ICaseOptionsMulti
Interface for a list of options that appears multiple times.
Definition ICaseOptions.h:155
Arcane::IEntryPoint::PAutoLoadEnd
@ PAutoLoadEnd
Automatically loaded at the end. This means that a module possessing an entry point with this propert...
Definition IEntryPoint.h:81
Arcane::IEntryPoint::PAutoLoadBegin
@ PAutoLoadBegin
Automatically loaded at the beginning. This means that a module possessing an entry point with this p...
Definition IEntryPoint.h:74
Arcane::IEntryPoint::WInit
static const char *const WInit
called during initialization
Definition IEntryPoint.h:47
Arcane::IModule
Interface of a module.
Definition IModule.h:40
Arcane::IStandardFunction
Interface managing a standard function.
Definition IStandardFunction.h:41
Arcane::ISubDomain
Interface of the subdomain manager.
Definition ISubDomain.h:75
Arcane::ISubDomain::caseMng
virtual ICaseMng * caseMng()=0
Returns the dataset manager.
Arcane::Internal::ServiceInfo
Information about a service.
Definition ServiceInfo.h:51
Arcane::ModuleBuildInfo
Information for building a module.
Definition ModuleBuildInfo.h:39
Arcane::ModuleBuildInfo::subDomain
ISubDomain * subDomain() const
Access to the associated subdomain.
Definition ModuleBuildInfo.h:69
Arcane::Span
View of an array of elements of type T.
Definition Span.h:635
Arcane::XmlNodeList
List of nodes of a DOM tree.
Definition XmlNodeList.h:36
Arcane::XmlNode
Node of a DOM tree.
Definition XmlNode.h:51
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293
Arcane::Byte
unsigned char Byte
Type of a byte.
Definition BaseTypes.h:43
Arcane::addEntryPoint
void addEntryPoint(ModuleType *module, const char *name, void(ModuleType::*func)(), const String &where=IEntryPoint::WComputeLoop, int property=IEntryPoint::PNone)
Template routine allowing an entry point to be referenced in a module.
Definition EntryPoint.h:174