Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
ArcanePostProcessing_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_ARCANEPOSTPROCESSING_H
9#define ARCANE_CASEOPTION_AXLSTAR_ARCANEPOSTPROCESSING_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/ItemGroup.h"
21#include "arcane/CaseOptionService.h"
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26ARCANE_BEGIN_NAMESPACE
27extern "C++" bool
28_caseOptionConvert(const Arcane::CaseOptionBase&,
29 const Arcane::String&,
30 Arcane::ItemGroup &);
31ARCANE_END_NAMESPACE
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
37class CaseOptionsArcanePostProcessing
38{
39public:
40
41 /*-------------------------------------------------------------------------*/
42 /*--------------------------- Complex Options -----------------------------*/
43 /*-------------------------------------------------------------------------*/
44 // Generation for option 'output'
45 // Generating simple arity CaseOption for option 'output'
46 class CaseOptionOutput
47 : public Arcane::CaseOptions
48 {
49 public:
50
51 CaseOptionOutput(Arcane::ICaseOptionList* icl,
52 const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
53 : Arcane::CaseOptions(icl,s,element,is_optional)
54 , variable(Arcane::CaseOptionBuildInfo(_configList(),
55 /* name */ "variable", _element(),
56 /* default */ Arcane::String(),
57 /* min-occurs */ 0,
58 /* max-occurs */ -1,
59 /* optional */ false))
60 , group(Arcane::CaseOptionBuildInfo(_configList(),
61 /* name */ "group", _element(),
62 /* default */ Arcane::String(),
63 /* min-occurs */ 0,
64 /* max-occurs */ -1,
65 /* optional */ false),
66 /* type */ "Arcane::ItemGroup")
67 {
68
69variable.addAlternativeNodeName(
70 /* language */ Arcane::String("fr"),
71 /* alternative name */ Arcane::String("variable"));
72group.addAlternativeNodeName(
73 /* language */ Arcane::String("fr"),
74 /* alternative name */ Arcane::String("groupe"));
75addAlternativeNodeName(
76 /* language */ Arcane::String("fr"),
77 /* alternative name */ Arcane::String("depouillement"));
78 }
79
80 const CaseOptionOutput& operator()() const { return *this; }
81
82 public:
83 // Interfaces for simple arity CaseOptions
84
85 Arcane::ConstArrayView< Arcane::String > getVariable() { return variable.values(); }
86
87 Arcane::ConstArrayView< Arcane::ItemGroup > getGroup() { return group; }
88
89
90 // Interfaces for complex options
91
92
93 private:
94 // Méthodes pour unifier la construction des options.
95 Arcane::ICaseOptionList* _configList() { return configList(); }
96 Arcane::XmlNode _element() { return Arcane::XmlNode(); }
97
98 public:
99
100 Arcane::CaseOptionMultiSimpleT< Arcane::String > variable;
101 Arcane::CaseOptionMultiExtendedT< Arcane::ItemGroup > group;
102
103 };
104 // Generation for option 'experimental-python-plugin'
105 // Generating simple arity CaseOption for option 'experimental-python-plugin'
106 class CaseOptionExperimentalPythonPlugin
107 : public Arcane::CaseOptions
108 {
109 public:
110
111 CaseOptionExperimentalPythonPlugin(Arcane::ICaseOptionList* icl,
112 const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
113 : Arcane::CaseOptions(icl,s,element,is_optional)
114 , functionName(Arcane::CaseOptionBuildInfo(_configList(),
115 /* name */ "function-name", _element(),
116 /* default */ Arcane::String(),
117 /* min-occurs */ 1,
118 /* max-occurs */ 1,
119 /* optional */ false))
120 , externalPlugin(Arcane::CaseOptionBuildInfo(_configList(),
121 /* name */ "external-plugin", _element(),
122 /* default */ "BasicDotNetPythonExternalPlugin",
123 /* min-occurs */ 1,
124 /* max-occurs */ 1,
125 /* optional */ false),
126 /* allow-null */ true,
127 /* optional */ false)
128 {
129
130 }
131
132 const CaseOptionExperimentalPythonPlugin& operator()() const { return *this; }
133
134 public:
135 // Interfaces for simple arity CaseOptions
136
137 Arcane::String getFunctionName() { return functionName(); }
138 Arcane::ICaseFunction* getFunctionNameFunction() { return functionName.function(); }
139 Arcane::IStandardFunction* getFunctionNameStandardFunction() { return functionName.standardFunction(); }
140
141
142
143 Arcane::IExternalPlugin* getExternalPlugin() { return externalPlugin(); }
144 // Interfaces for complex options
145
146
147 private:
148 // Méthodes pour unifier la construction des options.
149 Arcane::ICaseOptionList* _configList() { return configList(); }
150 Arcane::XmlNode _element() { return Arcane::XmlNode(); }
151
152 public:
153
154 Arcane::CaseOptionString functionName;
155 Arcane::CaseOptionServiceT< Arcane::IExternalPlugin > externalPlugin;
156
157 };
158
159 /*-------------------------------------------------------------------------*/
160 /*--------------------------- Non Complex Options -------------------------*/
161 /*-------------------------------------------------------------------------*/
162
163 CaseOptionsArcanePostProcessing(Arcane::ICaseMng* cm)
164 : m_case_options(new Arcane::CaseOptions(cm,"arcane-post-processing"))
165 , outputFrequency(Arcane::CaseOptionBuildInfo(_configList(),
166 /* name */ "output-frequency", _element(),
167 /* default */ "0.0",
168 /* min-occurs */ 1,
169 /* max-occurs */ 1,
170 /* optional */ false))
171 , outputPeriod(Arcane::CaseOptionBuildInfo(_configList(),
172 /* name */ "output-period", _element(),
173 /* default */ "0",
174 /* min-occurs */ 1,
175 /* max-occurs */ 1,
176 /* optional */ false))
177 , outputHistoryPeriod(Arcane::CaseOptionBuildInfo(_configList(),
178 /* name */ "output-history-period", _element(),
179 /* default */ "1",
180 /* min-occurs */ 1,
181 /* max-occurs */ 1,
182 /* optional */ false))
183 , outputHistoryShrink(Arcane::CaseOptionBuildInfo(_configList(),
184 /* name */ "output-history-shrink", _element(),
185 /* default */ "false",
186 /* min-occurs */ 1,
187 /* max-occurs */ 1,
188 /* optional */ false))
189 , saveInit(Arcane::CaseOptionBuildInfo(_configList(),
190 /* name */ "save-init", _element(),
191 /* default */ "false",
192 /* min-occurs */ 1,
193 /* max-occurs */ 1,
194 /* optional */ false))
195 , saveFinalTime(Arcane::CaseOptionBuildInfo(_configList(),
196 /* name */ "save-final-time", _element(),
197 /* default */ "true",
198 /* min-occurs */ 1,
199 /* max-occurs */ 1,
200 /* optional */ false))
201 , endExecutionOutput(Arcane::CaseOptionBuildInfo(_configList(),
202 /* name */ "end-execution-output", _element(),
203 /* default */ "false",
204 /* min-occurs */ 1,
205 /* max-occurs */ 1,
206 /* optional */ false))
207 , format(Arcane::CaseOptionBuildInfo(_configList(),
208 /* name */ "format", _element(),
209 /* default */ "Ensight7PostProcessor",
210 /* min-occurs */ 1,
211 /* max-occurs */ 1,
212 /* optional */ false),
213 /* allow-null */ false,
214 /* optional */ false)
215 , output(_configList(),
216 /* name */ "output", _element())
217 , experimentalPythonPlugin(_configList(),
218 /* name */ "experimental-python-plugin", _element(),
219 /* optional */ true)
220 {
221
222format.addAlternativeNodeName(
223 /* language */ Arcane::String("fr"),
224 /* alternative name */ Arcane::String("format-service"));
225outputFrequency.addAlternativeNodeName(
226 /* language */ Arcane::String("fr"),
227 /* alternative name */ Arcane::String("frequence-sortie"));
228outputPeriod.addAlternativeNodeName(
229 /* language */ Arcane::String("fr"),
230 /* alternative name */ Arcane::String("periode-sortie"));
231outputHistoryPeriod.addAlternativeNodeName(
232 /* language */ Arcane::String("fr"),
233 /* alternative name */ Arcane::String("periode-sortie-historique"));
234outputHistoryShrink.addAlternativeNodeName(
235 /* language */ Arcane::String("fr"),
236 /* alternative name */ Arcane::String("compression-sortie-historique"));
237saveInit.addAlternativeNodeName(
238 /* language */ Arcane::String("fr"),
239 /* alternative name */ Arcane::String("sauvegarde-initiale"));
240saveFinalTime.addAlternativeNodeName(
241 /* language */ Arcane::String("fr"),
242 /* alternative name */ Arcane::String("sauvegarde-temps-final"));
243endExecutionOutput.addAlternativeNodeName(
244 /* language */ Arcane::String("fr"),
245 /* alternative name */ Arcane::String("sortie-fin-execution"));
246output.addAlternativeNodeName(
247 /* language */ Arcane::String("fr"),
248 /* alternative name */ Arcane::String("depouillement"));
249addAlternativeNodeName(
250 /* language */ Arcane::String("fr"),
251 /* alternative name */ Arcane::String("arcane-post-traitement"));
252 }
253
254public:
255 // Interfaces for main CaseOptions
256
257 Arcane::Real getOutputFrequency() { return outputFrequency(); }
258 Arcane::ICaseFunction* getOutputFrequencyFunction() { return outputFrequency.function(); }
259 Arcane::IStandardFunction* getOutputFrequencyStandardFunction() { return outputFrequency.standardFunction(); }
260 Arcane::Integer getOutputPeriod() { return outputPeriod(); }
261 Arcane::ICaseFunction* getOutputPeriodFunction() { return outputPeriod.function(); }
262 Arcane::IStandardFunction* getOutputPeriodStandardFunction() { return outputPeriod.standardFunction(); }
263 Arcane::Integer getOutputHistoryPeriod() { return outputHistoryPeriod(); }
264 Arcane::ICaseFunction* getOutputHistoryPeriodFunction() { return outputHistoryPeriod.function(); }
265 Arcane::IStandardFunction* getOutputHistoryPeriodStandardFunction() { return outputHistoryPeriod.standardFunction(); }
266 bool getOutputHistoryShrink() { return outputHistoryShrink(); }
267 Arcane::ICaseFunction* getOutputHistoryShrinkFunction() { return outputHistoryShrink.function(); }
268 Arcane::IStandardFunction* getOutputHistoryShrinkStandardFunction() { return outputHistoryShrink.standardFunction(); }
269 bool getSaveInit() { return saveInit(); }
270 Arcane::ICaseFunction* getSaveInitFunction() { return saveInit.function(); }
271 Arcane::IStandardFunction* getSaveInitStandardFunction() { return saveInit.standardFunction(); }
272 bool getSaveFinalTime() { return saveFinalTime(); }
273 Arcane::ICaseFunction* getSaveFinalTimeFunction() { return saveFinalTime.function(); }
274 Arcane::IStandardFunction* getSaveFinalTimeStandardFunction() { return saveFinalTime.standardFunction(); }
275 bool getEndExecutionOutput() { return endExecutionOutput(); }
276 Arcane::ICaseFunction* getEndExecutionOutputFunction() { return endExecutionOutput.function(); }
277 Arcane::IStandardFunction* getEndExecutionOutputStandardFunction() { return endExecutionOutput.standardFunction(); }
278
279
280
281 Arcane::IPostProcessorWriter* getFormat() { return format(); }
282 // Interfaces for complex options
283 bool hasExperimentalPythonPlugin() const
284 { return experimentalPythonPlugin.isPresent(); }
285
286
287public:
288
289 Arcane::ICaseOptions* caseOptions() const
290 {
291 return m_case_options.get();
292 }
293
294 Arcane::ICaseOptionList* configList() const
295 {
296 return m_case_options->configList();
297 }
298
299 void setCaseModule(Arcane::IModule* m)
300 {
301 m_case_options->setCaseModule(m);
302 }
303
304 void setCaseServiceInfo(Arcane::IServiceInfo* si)
305 {
306 m_case_options->setCaseServiceInfo(si);
307 }
308
309 void addAlternativeNodeName(const Arcane::String& lang,
310 const Arcane::String& name)
311 {
312 m_case_options->addAlternativeNodeName(lang,name);
313 }
314
315private:
316
317 Arcane::ICaseOptionList* _configList() const { return configList(); }
318 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
319
320private:
321
322 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
323
324 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
325
326public:
327
328
329 Arcane::CaseOptionReal outputFrequency;
330 Arcane::CaseOptionInteger outputPeriod;
331 Arcane::CaseOptionInteger outputHistoryPeriod;
332 Arcane::CaseOptionBool outputHistoryShrink;
333 Arcane::CaseOptionBool saveInit;
334 Arcane::CaseOptionBool saveFinalTime;
335 Arcane::CaseOptionBool endExecutionOutput;
336 Arcane::CaseOptionServiceT< Arcane::IPostProcessorWriter > format;
337 CaseOptionOutput output;
338 CaseOptionExperimentalPythonPlugin experimentalPythonPlugin;
339};
340
341/*---------------------------------------------------------------------------*/
342/*---------------------------------------------------------------------------*/
343
344#endif
345
346
347
348/*---------------------------------------------------------------------------*/
349/*---------------------------------------------------------------------------*/
350// #WARNING#: This file has been generated automatically. Do not edit.
351// Axlstar version 1.0
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
355#ifndef ARCANE_MODULE_AXLSTAR_ARCANEPOSTPROCESSING_H
356#define ARCANE_MODULE_AXLSTAR_ARCANEPOSTPROCESSING_H
357
358/*---------------------------------------------------------------------------*/
359/*---------------------------------------------------------------------------*/
360
361#include "arcane/VariableTypes.h"
362#include "arcane/EntryPoint.h"
363#include "arcane/ISubDomain.h"
364#include "arcane/ModuleBuildInfo.h"
365#include "arcane/ModuleFactory.h"
366#include "arcane/ServiceRegisterer.h"
367#include "arcane/BasicModule.h"
368#include "arcane/ServiceInfo.h"
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373namespace Arcane
374{
375class ISubDomain;
376class IModule;
377}
378
379/*---------------------------------------------------------------------------*/
380/*---------------------------------------------------------------------------*/
381
382class CaseOptionsArcanePostProcessing;
383
384/*---------------------------------------------------------------------------*/
385/*---------------------------------------------------------------------------*/
386
388class ArcaneArcanePostProcessingObject
389 : public Arcane::BasicModule
390{
391public:
392
393 static void fillServiceInfo(Arcane::ServiceInfo* si)
394 {
395 si->setCaseOptionsFileName("ArcanePostProcessing_arcane_std");
396 si->setAxlVersion(1.0);
397 si->setDefaultTagName(Arcane::String("arcane-post-processing"));
398 si->setAxlContent(getAxlContent());
399 si->setTagName(Arcane::String("arcane-post-traitement"),Arcane::String("fr"));
400 }
401
402public:
403
404 ArcaneArcanePostProcessingObject(const Arcane::ModuleBuildInfo& mb)
405 : Arcane::BasicModule(mb)
406 , m_options(nullptr)
407 , m_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingNextIteration" ))
408 , m_next_global_time(Arcane::VariableBuildInfo(this, "PostProcessingNextGlobalTime" ))
409 , m_curves_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingCurvesNextIteration" ))
410 , m_curves_next_global_time(Arcane::VariableBuildInfo(this, "PostProcessingCurvesNextGlobalTime" ))
411 , m_history_next_iteration(Arcane::VariableBuildInfo(this, "PostProcessingHistoryNextIteration" ))
412 {
413 m_options = new CaseOptionsArcanePostProcessing(mb.subDomain()->caseMng());
414 m_options->setCaseModule(this);
415 addEntryPoint(this, "PostProcessingExportData",
416 &ArcaneArcanePostProcessingObject::exportData,
417 Arcane::IEntryPoint::WComputeLoop,
418 Arcane::IEntryPoint::PAutoLoadEnd);
419 addEntryPoint(this, "PostProcessingExportDataStart",
420 &ArcaneArcanePostProcessingObject::exportDataStart,
421 Arcane::IEntryPoint::WComputeLoop,
422 Arcane::IEntryPoint::PAutoLoadBegin);
423 addEntryPoint(this, "PostProcessingStartInit",
424 &ArcaneArcanePostProcessingObject::postProcessingStartInit,
425 Arcane::IEntryPoint::WStartInit,
426 Arcane::IEntryPoint::PAutoLoadBegin);
427 addEntryPoint(this, "PostProcessingInit",
428 &ArcaneArcanePostProcessingObject::postProcessingInit,
429 Arcane::IEntryPoint::WInit,
430 Arcane::IEntryPoint::PAutoLoadEnd);
431 addEntryPoint(this, "PostProcessingExit",
432 &ArcaneArcanePostProcessingObject::postProcessingExit,
433 Arcane::IEntryPoint::WExit,
434 Arcane::IEntryPoint::PAutoLoadEnd);
435 }
436
437 virtual ~ArcaneArcanePostProcessingObject()
438 {
439 delete m_options;
440 }
441
442public:
443
445 virtual void exportData() = 0; // ExportData
446 virtual void exportDataStart() = 0; // ExportDataStart
447 virtual void postProcessingStartInit() = 0; // PostProcessingStartInit
448 virtual void postProcessingInit() = 0; // PostProcessingInit
449 virtual void postProcessingExit() = 0; // PostProcessingExit
450
452 CaseOptionsArcanePostProcessing* options() const { return m_options; }
453
454private:
455
457 CaseOptionsArcanePostProcessing* m_options;
458
459protected:
460
462 Arcane::VariableScalarInteger m_next_iteration;
463 Arcane::VariableScalarReal m_next_global_time;
464 Arcane::VariableScalarInteger m_curves_next_iteration;
465 Arcane::VariableScalarReal m_curves_next_global_time;
466 Arcane::VariableScalarInteger m_history_next_iteration;
467
468private:
469 static Arcane::FileContent getAxlContent()
470 {
471 const char* str_content = "";
472 const Arcane::Byte* content = (const Arcane::Byte*)(str_content);
473 Arcane::Span<const Arcane::Byte> bytes(content,0);
474 int file_version = 1;
475 return Arcane::FileContent(bytes,file_version,"");
476 }
477
478};
479
480/*---------------------------------------------------------------------------*/
481/*---------------------------------------------------------------------------*/
482
483#define ARCANE_REGISTER_MODULE_ARCANEPOSTPROCESSING(class_name) \
484 ARCANE_REGISTER_AXL_MODULE(class_name,Arcane::ModuleProperty("ArcanePostProcessing",false))
485
486/*---------------------------------------------------------------------------*/
487/*---------------------------------------------------------------------------*/
488
489#endif
490
ArcaneArcanePostProcessingObject::options
CaseOptionsArcanePostProcessing * options() const
Options du jeu de données du module.
Definition ArcanePostProcessing_axl.h:452
ArcaneArcanePostProcessingObject::m_next_iteration
Arcane::VariableScalarInteger m_next_iteration
Variables du module.
Definition ArcanePostProcessing_axl.h:462
ArcaneArcanePostProcessingObject::exportData
virtual void exportData()=0
points d'entrée
ArcaneArcanePostProcessingObject::m_options
CaseOptionsArcanePostProcessing * m_options
Options du jeu de données du module.
Definition ArcanePostProcessing_axl.h:457
Arcane::BasicModule
Basic module.
Definition BasicModule.h:42
Arcane::CaseOptionBase
Base class for a data set option.
Definition CaseOptionBase.h:51
Arcane::CaseOptionBuildInfo
Information for building a dataset option.
Definition CaseOptionBuildInfo.h:41
Arcane::CaseOptionMultiExtendedT
Option for the extended list of types dataset.
Definition CaseOptionExtended.h:195
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::IEntryPoint::WComputeLoop
static const char *const WComputeLoop
called during the calculation loop
Definition IEntryPoint.h:43
Arcane::IEntryPoint::WStartInit
static const char *const WStartInit
called during new case initialization
Definition IEntryPoint.h:51
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::IExternalPlugin
Interface for external service loading.
Definition IExternalPlugin.h:37
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::ItemGroup
Mesh entity group.
Definition ItemGroup.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::VariableBuildInfo
Parameters necessary for building a variable.
Definition VariableBuildInfo.h:44
Arcane::XmlNode
Node of a DOM tree.
Definition XmlNode.h:51
Arcane::VariableScalarReal
VariableRefScalarT< Real > VariableScalarReal
Scalar variable of real type.
Definition VariableTypedef.h:59
Arcane::VariableScalarInteger
VariableRefScalarT< Integer > VariableScalarInteger
Scalar variable of integer type.
Definition VariableTypedef.h:83
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::Real
double Real
Type representing a real number.
Definition ArccoreGlobal.h:275
Arcane::Byte
unsigned char Byte
Type of a byte.
Definition BaseTypes.h:43