Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
AlephTestModule_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_ARCANETEST_ALEPHTESTMODULE_H
9#define ARCANE_CASEOPTION_AXLSTAR_ARCANETEST_ALEPHTESTMODULE_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::FaceGroup &);
31ARCANE_END_NAMESPACE
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36namespace ArcaneTest {
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
40
42class CaseOptionsAlephTestModule
43{
44public:
45
46 /*-------------------------------------------------------------------------*/
47 /*--------------------------- Complex Options -----------------------------*/
48 /*-------------------------------------------------------------------------*/
49 // Generation for option 'boundary-condition'
50 // Generating multiple arity CaseOption for complex option value 'boundary-condition'
51 class CaseOptionBoundaryConditionValue
52 : public Arcane::CaseOptionComplexValue
53 {
54 public:
55
56 typedef CaseOptionBoundaryConditionValue ThatClass;
57
58 CaseOptionBoundaryConditionValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
59 : Arcane::CaseOptionComplexValue(opt,icl,element)
60 , value(Arcane::CaseOptionBuildInfo(_configList(),
61 /* name */ "value", _element(),
62 /* default */ Arcane::String(),
63 /* min-occurs */ 1,
64 /* max-occurs */ 1,
65 /* optional */ false))
66 , surface(Arcane::CaseOptionBuildInfo(_configList(),
67 /* name */ "surface", _element(),
68 /* default */ Arcane::String(),
69 /* min-occurs */ 1,
70 /* max-occurs */ 1,
71 /* optional */ false),
72 /* type */ "Arcane::FaceGroup")
73
74 {
75
76
77 }
78 public:
79 // Interfaces for multi-arity class CaseOptionsBoundaryCondition
80
81 Arcane::Real getValue() { return value(); }
82 Arcane::ICaseFunction* getValueFunction() { return value.function(); }
83 Arcane::IStandardFunction* getValueStandardFunction() { return value.standardFunction(); }
84
85
86 Arcane::FaceGroup getSurface() { return surface(); }
87
88 // Interfaces for complex options
89
90
91 public:
92
93 const ThatClass* operator->() const { return this; }
94
95 public:
96
97 Arcane::CaseOptionReal value;
98 Arcane::CaseOptionExtendedT< Arcane::FaceGroup > surface;
99 };
100
101 // Generation for sub-option 'boundary-condition'
102 class CaseOptionBoundaryCondition
103 : public Arcane::CaseOptionsMulti
104 , private Arcane::ArrayView< CaseOptionBoundaryConditionValue * >
105 {
106 public:
107
108 typedef Arcane::ArrayView< CaseOptionBoundaryConditionValue * > BaseClass;
109
110 typedef CaseOptionBoundaryConditionValue value_type;
111
112 public:
113
114 CaseOptionBoundaryCondition(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 ~CaseOptionBoundaryCondition()
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
164 /*-------------------------------------------------------------------------*/
165 /*--------------------------- Non Complex Options -------------------------*/
166 /*-------------------------------------------------------------------------*/
167
168 CaseOptionsAlephTestModule(Arcane::ICaseMng* cm)
169 : m_case_options(new Arcane::CaseOptions(cm,"aleph-test-module"))
170 , iterations(Arcane::CaseOptionBuildInfo(_configList(),
171 /* name */ "iterations", _element(),
172 /* default */ "8",
173 /* min-occurs */ 1,
174 /* max-occurs */ 1,
175 /* optional */ false))
176 , alephDeleteKernel(Arcane::CaseOptionBuildInfo(_configList(),
177 /* name */ "aleph-delete-kernel", _element(),
178 /* default */ "false",
179 /* min-occurs */ 1,
180 /* max-occurs */ 1,
181 /* optional */ false))
182 , alephNumberOfSolvers(Arcane::CaseOptionBuildInfo(_configList(),
183 /* name */ "aleph-number-of-solvers", _element(),
184 /* default */ "2",
185 /* min-occurs */ 1,
186 /* max-occurs */ 1,
187 /* optional */ false))
188 , alephUnderlyingSolver(Arcane::CaseOptionBuildInfo(_configList(),
189 /* name */ "aleph-underlying-solver", _element(),
190 /* default */ "2",
191 /* min-occurs */ 1,
192 /* max-occurs */ 1,
193 /* optional */ false))
194 , alephNumberOfCores(Arcane::CaseOptionBuildInfo(_configList(),
195 /* name */ "aleph-number-of-cores", _element(),
196 /* default */ "1",
197 /* min-occurs */ 1,
198 /* max-occurs */ 1,
199 /* optional */ false))
200 , alephCellOrdering(Arcane::CaseOptionBuildInfo(_configList(),
201 /* name */ "aleph-cell-ordering", _element(),
202 /* default */ "false",
203 /* min-occurs */ 1,
204 /* max-occurs */ 1,
205 /* optional */ false))
206 , deltaT(Arcane::CaseOptionBuildInfo(_configList(),
207 /* name */ "deltaT", _element(),
208 /* default */ "0.005",
209 /* min-occurs */ 1,
210 /* max-occurs */ 1,
211 /* optional */ false))
212 , initTemperature(Arcane::CaseOptionBuildInfo(_configList(),
213 /* name */ "init-temperature", _element(),
214 /* default */ "200",
215 /* min-occurs */ 1,
216 /* max-occurs */ 1,
217 /* optional */ false))
218 , initAmr(Arcane::CaseOptionBuildInfo(_configList(),
219 /* name */ "init-amr", _element(),
220 /* default */ "0.0",
221 /* min-occurs */ 1,
222 /* max-occurs */ 1,
223 /* optional */ false))
224 , trigRefine(Arcane::CaseOptionBuildInfo(_configList(),
225 /* name */ "trig-refine", _element(),
226 /* default */ "0.001",
227 /* min-occurs */ 1,
228 /* max-occurs */ 1,
229 /* optional */ false))
230 , trigCoarse(Arcane::CaseOptionBuildInfo(_configList(),
231 /* name */ "trig-coarse", _element(),
232 /* default */ "0.001",
233 /* min-occurs */ 1,
234 /* max-occurs */ 1,
235 /* optional */ false))
236 , schema(Arcane::CaseOptionBuildInfo(_configList(),
237 /* name */ "schema", _element(),
238 /* default */ "Faces",
239 /* min-occurs */ 1,
240 /* max-occurs */ 1,
241 /* optional */ false),
242 /* allow-null */ false,
243 /* optional */ false)
244 , boundaryCondition(_configList(),
245 /* name */ "boundary-condition", _element())
246 {
247
248 }
249
250public:
251 // Interfaces for main CaseOptions
252
253 Arcane::Integer getIterations() { return iterations(); }
254 Arcane::ICaseFunction* getIterationsFunction() { return iterations.function(); }
255 Arcane::IStandardFunction* getIterationsStandardFunction() { return iterations.standardFunction(); }
256 bool getAlephDeleteKernel() { return alephDeleteKernel(); }
257 Arcane::ICaseFunction* getAlephDeleteKernelFunction() { return alephDeleteKernel.function(); }
258 Arcane::IStandardFunction* getAlephDeleteKernelStandardFunction() { return alephDeleteKernel.standardFunction(); }
259 Arcane::Integer getAlephNumberOfSolvers() { return alephNumberOfSolvers(); }
260 Arcane::ICaseFunction* getAlephNumberOfSolversFunction() { return alephNumberOfSolvers.function(); }
261 Arcane::IStandardFunction* getAlephNumberOfSolversStandardFunction() { return alephNumberOfSolvers.standardFunction(); }
262 Arcane::Integer getAlephUnderlyingSolver() { return alephUnderlyingSolver(); }
263 Arcane::ICaseFunction* getAlephUnderlyingSolverFunction() { return alephUnderlyingSolver.function(); }
264 Arcane::IStandardFunction* getAlephUnderlyingSolverStandardFunction() { return alephUnderlyingSolver.standardFunction(); }
265 Arcane::Integer getAlephNumberOfCores() { return alephNumberOfCores(); }
266 Arcane::ICaseFunction* getAlephNumberOfCoresFunction() { return alephNumberOfCores.function(); }
267 Arcane::IStandardFunction* getAlephNumberOfCoresStandardFunction() { return alephNumberOfCores.standardFunction(); }
268 bool getAlephCellOrdering() { return alephCellOrdering(); }
269 Arcane::ICaseFunction* getAlephCellOrderingFunction() { return alephCellOrdering.function(); }
270 Arcane::IStandardFunction* getAlephCellOrderingStandardFunction() { return alephCellOrdering.standardFunction(); }
271 Arcane::Real getDeltaT() { return deltaT(); }
272 Arcane::ICaseFunction* getDeltaTFunction() { return deltaT.function(); }
273 Arcane::IStandardFunction* getDeltaTStandardFunction() { return deltaT.standardFunction(); }
274 Arcane::Real getInitTemperature() { return initTemperature(); }
275 Arcane::ICaseFunction* getInitTemperatureFunction() { return initTemperature.function(); }
276 Arcane::IStandardFunction* getInitTemperatureStandardFunction() { return initTemperature.standardFunction(); }
277 Arcane::Real getInitAmr() { return initAmr(); }
278 Arcane::ICaseFunction* getInitAmrFunction() { return initAmr.function(); }
279 Arcane::IStandardFunction* getInitAmrStandardFunction() { return initAmr.standardFunction(); }
280 Arcane::Real getTrigRefine() { return trigRefine(); }
281 Arcane::ICaseFunction* getTrigRefineFunction() { return trigRefine.function(); }
282 Arcane::IStandardFunction* getTrigRefineStandardFunction() { return trigRefine.standardFunction(); }
283 Arcane::Real getTrigCoarse() { return trigCoarse(); }
284 Arcane::ICaseFunction* getTrigCoarseFunction() { return trigCoarse.function(); }
285 Arcane::IStandardFunction* getTrigCoarseStandardFunction() { return trigCoarse.standardFunction(); }
286
287
288
289 AlephTestScheme* getSchema() { return schema(); }
290 // Interfaces for complex options
291
292
293public:
294
295 Arcane::ICaseOptions* caseOptions() const
296 {
297 return m_case_options.get();
298 }
299
300 Arcane::ICaseOptionList* configList() const
301 {
302 return m_case_options->configList();
303 }
304
305 void setCaseModule(Arcane::IModule* m)
306 {
307 m_case_options->setCaseModule(m);
308 }
309
310 void setCaseServiceInfo(Arcane::IServiceInfo* si)
311 {
312 m_case_options->setCaseServiceInfo(si);
313 }
314
315 void addAlternativeNodeName(const Arcane::String& lang,
316 const Arcane::String& name)
317 {
318 m_case_options->addAlternativeNodeName(lang,name);
319 }
320
321private:
322
323 Arcane::ICaseOptionList* _configList() const { return configList(); }
324 Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
325
326private:
327
328 static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
329
330 Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
331
332public:
333
334
335 Arcane::CaseOptionInteger iterations;
336 Arcane::CaseOptionBool alephDeleteKernel;
337 Arcane::CaseOptionInteger alephNumberOfSolvers;
338 Arcane::CaseOptionInteger alephUnderlyingSolver;
339 Arcane::CaseOptionInteger alephNumberOfCores;
340 Arcane::CaseOptionBool alephCellOrdering;
341 Arcane::CaseOptionReal deltaT;
342 Arcane::CaseOptionReal initTemperature;
343 Arcane::CaseOptionReal initAmr;
344 Arcane::CaseOptionReal trigRefine;
345 Arcane::CaseOptionReal trigCoarse;
346 Arcane::CaseOptionServiceT< AlephTestScheme > schema;
347 CaseOptionBoundaryCondition boundaryCondition;
348};
349
350/*---------------------------------------------------------------------------*/
351/*---------------------------------------------------------------------------*/
352
353}
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358#endif
359
360
361
362/*---------------------------------------------------------------------------*/
363/*---------------------------------------------------------------------------*/
364// #WARNING#: This file has been generated automatically. Do not edit.
365// Axlstar version 1.0
366/*---------------------------------------------------------------------------*/
367/*---------------------------------------------------------------------------*/
368
369#ifndef ARCANE_MODULE_AXLSTAR_ARCANETEST_ALEPHTESTMODULE_H
370#define ARCANE_MODULE_AXLSTAR_ARCANETEST_ALEPHTESTMODULE_H
371
372/*---------------------------------------------------------------------------*/
373/*---------------------------------------------------------------------------*/
374
375#include "arcane/VariableTypes.h"
376#include "arcane/EntryPoint.h"
377#include "arcane/ISubDomain.h"
378#include "arcane/ModuleBuildInfo.h"
379#include "arcane/ModuleFactory.h"
380#include "arcane/ServiceRegisterer.h"
381#include "arcane/BasicModule.h"
382#include "arcane/ServiceInfo.h"
383
384/*---------------------------------------------------------------------------*/
385/*---------------------------------------------------------------------------*/
386
387namespace Arcane
388{
389class ISubDomain;
390class IModule;
391}
392
393/*---------------------------------------------------------------------------*/
394/*---------------------------------------------------------------------------*/
395
396namespace ArcaneTest {
397
398/*---------------------------------------------------------------------------*/
399/*---------------------------------------------------------------------------*/
400
401class CaseOptionsAlephTestModule;
402
403/*---------------------------------------------------------------------------*/
404/*---------------------------------------------------------------------------*/
405
407class ArcaneAlephTestModuleObject
408 : public Arcane::BasicModule
409{
410public:
411
412 static void fillServiceInfo(Arcane::ServiceInfo* si)
413 {
414 si->setCaseOptionsFileName("AlephTestModule_arcane_aleph_tests");
415 si->setAxlVersion(1.0);
416 si->setDefaultTagName(Arcane::String("aleph-test-module"));
417 si->setAxlContent(getAxlContent());
418 }
419
420public:
421
422 ArcaneAlephTestModuleObject(const Arcane::ModuleBuildInfo& mb)
423 : Arcane::BasicModule(mb)
424 , m_options(nullptr)
425 , m_cell_temperature(Arcane::VariableBuildInfo(this, "CellTemperature" ))
426 , m_face_temperature(Arcane::VariableBuildInfo(this, "FaceTemperature" , Arcane::IVariable::PNoDump))
427 , m_cell_matrix_idx(Arcane::VariableBuildInfo(this, "CellMatrixIdx" , Arcane::IVariable::PNoDump| Arcane::IVariable::PNoNeedSync))
428 , m_sub_domain_id(Arcane::VariableBuildInfo(this, "SubDomainId" , Arcane::IVariable::PNoDump| Arcane::IVariable::PNoNeedSync))
429 , m_unique_id(Arcane::VariableBuildInfo(this, "UniqueId" , Arcane::IVariable::PNoDump| Arcane::IVariable::PNoNeedSync))
430 {
431 m_options = new CaseOptionsAlephTestModule(mb.subDomain()->caseMng());
432 m_options->setCaseModule(this);
433 addEntryPoint(this, "init",
434 &ArcaneAlephTestModuleObject::init,
435 Arcane::IEntryPoint::WInit,
436 Arcane::IEntryPoint::PNone);
437 addEntryPoint(this, "compute",
438 &ArcaneAlephTestModuleObject::compute,
439 Arcane::IEntryPoint::WComputeLoop,
440 Arcane::IEntryPoint::PNone);
441 }
442
443 virtual ~ArcaneAlephTestModuleObject()
444 {
445 delete m_options;
446 }
447
448public:
449
451 virtual void init() = 0; // Init
452 virtual void compute() = 0; // Compute
453
455 CaseOptionsAlephTestModule* options() const { return m_options; }
456
457private:
458
460 CaseOptionsAlephTestModule* m_options;
461
462protected:
463
465 Arcane::VariableCellReal m_cell_temperature;
466 Arcane::VariableFaceReal m_face_temperature;
467 Arcane::VariableCellInteger m_cell_matrix_idx;
468 Arcane::VariableCellInteger m_sub_domain_id;
469 Arcane::VariableCellInt64 m_unique_id;
470
471private:
472 static Arcane::FileContent getAxlContent()
473 {
474 const char* str_content = "";
475 const Arcane::Byte* content = (const Arcane::Byte*)(str_content);
476 Arcane::Span<const Arcane::Byte> bytes(content,0);
477 int file_version = 1;
478 return Arcane::FileContent(bytes,file_version,"");
479 }
480
481};
482
483/*---------------------------------------------------------------------------*/
484/*---------------------------------------------------------------------------*/
485
486#define ARCANE_REGISTER_MODULE_ALEPHTESTMODULE(class_name) \
487 ARCANE_REGISTER_AXL_MODULE(class_name,Arcane::ModuleProperty("AlephTestModule",false))
488
489/*---------------------------------------------------------------------------*/
490/*---------------------------------------------------------------------------*/
491
492}
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
497#endif
498
ArcaneTest::ArcaneAlephTestModuleObject::options
CaseOptionsAlephTestModule * options() const
Options du jeu de données du module.
Definition AlephTestModule_axl.h:455
ArcaneTest::ArcaneAlephTestModuleObject::init
virtual void init()=0
points d'entrée
ArcaneTest::ArcaneAlephTestModuleObject::m_options
CaseOptionsAlephTestModule * m_options
Options du jeu de données du module.
Definition AlephTestModule_axl.h:460
ArcaneTest::ArcaneAlephTestModuleObject::m_cell_temperature
Arcane::VariableCellReal m_cell_temperature
Variables du module.
Definition AlephTestModule_axl.h:465
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::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::CaseOptionComplexValue
Base class for a complex option value.
Definition CaseOptionComplexValue.h:40
Arcane::CaseOptionExtendedT
Option for the extended type dataset.
Definition CaseOptionExtended.h:96
Arcane::CaseOptionSimple::function
ICaseFunction * function() const override
Function associated with this option (0 if none).
Definition CaseOptionSimple.h:112
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::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::WComputeLoop
static const char *const WComputeLoop
called during the calculation loop
Definition IEntryPoint.h:43
Arcane::IEntryPoint::PNone
@ PNone
No properties.
Definition IEntryPoint.h:67
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::IVariable::PNoNeedSync
@ PNoNeedSync
Indicates that the variable is not necessarily synchronized.
Definition IVariable.h:70
Arcane::IVariable::PNoDump
@ PNoDump
Indicates that the variable should not be saved.
Definition IVariable.h:62
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::VariableBuildInfo
Parameters necessary for building a variable.
Definition VariableBuildInfo.h:44
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::FaceGroup
ItemGroupT< Face > FaceGroup
Group of faces.
Definition ItemTypes.h:179
Arcane::VariableFaceReal
MeshVariableScalarRefT< Face, Real > VariableFaceReal
Real type quantity at face.
Definition VariableTypedef.h:285
Arcane::VariableCellReal
MeshVariableScalarRefT< Cell, Real > VariableCellReal
Real type quantity at cell center.
Definition VariableTypedef.h:291
Arcane::VariableCellInt64
MeshVariableScalarRefT< Cell, Int64 > VariableCellInt64
Quantity at the cell center of 64-bit integer type.
Definition VariableTypedef.h:631
Arcane::VariableCellInteger
MeshVariableScalarRefT< Cell, Integer > VariableCellInteger
Quantity at the cell center of integer type.
Definition VariableTypedef.h:501
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
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