Arcane  v3.15.3.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
CaseOptionSimple.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* CaseOptionEnum.cc (C) 2000-2023 */
9/* */
10/* Option du jeu de données de type énuméré. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/CaseOptionSimple.h"
15
16#include "arcane/utils/ValueConvert.h"
17#include "arcane/utils/ITraceMng.h"
18#include "arcane/utils/FatalErrorException.h"
19
20#include "arcane/core/CaseOptionException.h"
21#include "arcane/core/CaseOptionBuildInfo.h"
22#include "arcane/core/XmlNodeList.h"
23#include "arcane/core/ICaseFunction.h"
24#include "arcane/core/ICaseMng.h"
25#include "arcane/core/ICaseDocument.h"
26#include "arcane/core/CaseNodeNames.h"
27#include "arcane/core/CaseOptionError.h"
28#include "arcane/core/IPhysicalUnitConverter.h"
29#include "arcane/core/IPhysicalUnitSystem.h"
30#include "arcane/core/IStandardFunction.h"
31#include "arcane/core/ICaseDocumentVisitor.h"
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36namespace Arcane
37{
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42template<typename T> void
43_copyCaseOptionValue(T& out,const T& in);
44
45template<> void _copyCaseOptionValue(String& out,const String& in) { out = in; }
46template<> void _copyCaseOptionValue(bool& out,const bool& in) { out = in; }
47template<> void _copyCaseOptionValue(Real& out,const Real& in) { out = in; }
48template<> void _copyCaseOptionValue(Int16& out,const Int16& in) { out = in; }
49template<> void _copyCaseOptionValue(Int32& out,const Int32& in) { out = in; }
50template<> void _copyCaseOptionValue(Int64& out,const Int64& in) { out = in; }
51template<> void _copyCaseOptionValue(Real2& out,const Real2& in) { out = in; }
52template<> void _copyCaseOptionValue(Real3& out,const Real3& in) { out = in; }
53template<> void _copyCaseOptionValue(Real2x2& out,const Real2x2& in) { out = in; }
54template<> void _copyCaseOptionValue(Real3x3& out,const Real3x3& in) { out = in; }
55
56template<typename T> void
57_copyCaseOptionValue(UniqueArray<T>& out,const Array<T>& in)
58{
59 out.copy(in);
60}
61
62template<typename T> void
63_copyCaseOptionValue(UniqueArray<T>& out,const UniqueArray<T>& in)
64{
65 out.copy(in);
66}
67
68template<typename T> void
69_copyCaseOptionValue(Array<T>& out,const Array<T>& in)
70{
71 out.copy(in);
72}
73
74/*---------------------------------------------------------------------------*/
75/*---------------------------------------------------------------------------*/
76
77CaseOptionSimple::
78CaseOptionSimple(const CaseOptionBuildInfo& cob)
79: CaseOptionBase(cob)
80, m_is_optional(cob.isOptional())
81, m_has_valid_value(true)
82{
83}
84
85/*---------------------------------------------------------------------------*/
86/*---------------------------------------------------------------------------*/
87
88CaseOptionSimple::
89CaseOptionSimple(const CaseOptionBuildInfo& cob,const String& physical_unit)
90: CaseOptionBase(cob)
91, m_is_optional(cob.isOptional())
92, m_has_valid_value(true)
93, m_default_physical_unit(physical_unit)
94{
95}
96
97/*---------------------------------------------------------------------------*/
98/*---------------------------------------------------------------------------*/
99
100CaseOptionSimple::
101~CaseOptionSimple()
102{
103 delete m_unit_converter;
104}
105
106/*---------------------------------------------------------------------------*/
107/*---------------------------------------------------------------------------*/
108
109void CaseOptionSimple::
110_search(bool is_phase1)
111{
112 if (!is_phase1)
113 return;
114
115 //ITraceMng* msg = caseMng()->traceMng();
116 const String& velem_name = name();
117 XmlNodeList velems = rootElement().children(velem_name);
118 XmlNode velem;
119 Integer nb_elem = velems.size();
120 ICaseDocumentFragment* doc = caseDocumentFragment();
121 if (nb_elem>=1){
122 velem = velems[0];
123 if (nb_elem>=2){
124 CaseOptionError::addWarning(doc,A_FUNCINFO,velem.xpathFullName(),
125 String::format("Only one token of the element is allowed (nb_occur={0})",
126 nb_elem));
127 }
128 }
129
130 m_element = velem;
131 m_function = 0;
132
133 _searchFunction(velem);
134
135 String physical_unit = m_element.attrValue("unit");
136 if (!physical_unit.null()){
137 _setPhysicalUnit(physical_unit);
138 if (_allowPhysicalUnit()){
139 //TODO: VERIFIER QU'IL Y A UNE DEFAULT_PHYSICAL_UNIT.
140 m_unit_converter = caseMng()->physicalUnitSystem()->createConverter(physical_unit,defaultPhysicalUnit());
141 }
142 else
143 CaseOptionError::addError(doc,A_FUNCINFO,velem.xpathFullName(),
144 String::format("Usage of a physic unit ('{0}') is not allowed for this kind of option",
145 physical_unit));
146 }
147}
148
149/*---------------------------------------------------------------------------*/
150/*---------------------------------------------------------------------------*/
151
152void CaseOptionSimple::
153_setPhysicalUnit(const String& value)
154{
155 m_physical_unit = value;
156}
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
160
161String CaseOptionSimple::
162physicalUnit() const
163{
164 return m_physical_unit;
165}
166
167/*---------------------------------------------------------------------------*/
168/*---------------------------------------------------------------------------*/
169
170void CaseOptionSimple::
171_searchFunction(XmlNode& velem)
172{
173 if (velem.null())
174 return;
175
176 // Recherche une éventuelle fonction associée
177 String fname = caseDocumentFragment()->caseNodeNames()->function_ref;
178 String func_name = velem.attrValue(fname);
179 if (func_name.null())
180 return;
181
182 ICaseFunction* func = caseMng()->findFunction(func_name);
183 ITraceMng* msg = caseMng()->traceMng();
184 if (!func){
185 msg->pfatal() << "In element <" << velem.name()
186 << ">: no function named <" << func_name << ">";
187 }
188
189 // Recherche s'il s'agit d'une fonction standard
190 IStandardFunction* sf = dynamic_cast<IStandardFunction*>(func);
191 if (sf){
192 msg->info() << "Use standard function: " << func_name;
193 m_standard_function = sf;
194 }
195 else{
196 msg->info() << "Use function: " << func_name;
197 m_function = func;
198 }
199}
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203
204void CaseOptionSimple::
205_setChangedSinceLastIteration(bool has_changed)
206{
207 m_changed_since_last_iteration = has_changed;
208}
209
210/*---------------------------------------------------------------------------*/
211/*---------------------------------------------------------------------------*/
212
213bool CaseOptionSimple::
214hasChangedSinceLastIteration() const
215{
216 return m_changed_since_last_iteration;
217}
218
219/*---------------------------------------------------------------------------*/
220/*---------------------------------------------------------------------------*/
221
222String CaseOptionSimple::
223xpathFullName() const
224{
225 if (!m_element.null())
226 return m_element.xpathFullName();
227 String fn = rootElement().xpathFullName() + "/" + name();
228 return fn;
229}
230
231/*---------------------------------------------------------------------------*/
232/*---------------------------------------------------------------------------*/
233
234String CaseOptionSimple::
235defaultPhysicalUnit() const
237 return m_default_physical_unit;
238}
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
243void CaseOptionSimple::
244visit(ICaseDocumentVisitor* visitor) const
245{
246 visitor->applyVisitor(this);
247}
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251
252/*---------------------------------------------------------------------------*/
253/*---------------------------------------------------------------------------*/
254/*
255 * Prise en compte du système d'unité mais uniquement pour
256 * les options de type 'Real' ou 'RealArray'.
257 * TODO: voir si c'est intéressant pour les autres types
258 * comme Real2, Real3.
259 * Pour les types intégraux comme 'Integer', il ne vaut mieux
260 * pas supporter les conversions car cela risque de faire des valeurs
261 * trop grandes ou nulle si la conversion donne un nombre inférieur à 1
262 * (par exemple, 5 centimètres convertie en mètre donne 0).
263 */
264template<typename DataType> static void
265_checkPhysicalConvert(IPhysicalUnitConverter* converter,DataType& value)
266{
267 ARCANE_UNUSED(converter);
268 ARCANE_UNUSED(value);
269}
270
271static void
272_checkPhysicalConvert(IPhysicalUnitConverter* converter,Real& value)
273{
274 if (converter){
275 Real new_value = converter->convert(value);
276 value = new_value;
277 }
278}
279
280static void
281_checkPhysicalConvert(IPhysicalUnitConverter* converter,RealUniqueArray& values)
282{
283 if (converter){
284 //TODO utiliser tableau local pour eviter allocation
285 RealUniqueArray input_values(values);
286 converter->convert(input_values,values);
287 }
288}
289
290template<typename DataType> static bool
291_allowConvert(const DataType& value)
292{
293 ARCANE_UNUSED(value);
294 return false;
295}
296
297static bool
298_allowConvert(const Real& value)
299{
300 ARCANE_UNUSED(value);
301 return true;
302}
303
304static bool
305_allowConvert(const RealUniqueArray& value)
306{
307 ARCANE_UNUSED(value);
308 return true;
309}
310
311/*---------------------------------------------------------------------------*/
312/*---------------------------------------------------------------------------*/
313
314template<typename T> CaseOptionSimpleT<T>::
315CaseOptionSimpleT(const CaseOptionBuildInfo& cob)
316: CaseOptionSimple(cob)
317{
318 _copyCaseOptionValue(m_value,Type());
319}
320
321/*---------------------------------------------------------------------------*/
322/*---------------------------------------------------------------------------*/
323
324template<typename T> CaseOptionSimpleT<T>::
325CaseOptionSimpleT(const CaseOptionBuildInfo& cob,const String& physical_unit)
326: CaseOptionSimple(cob,physical_unit)
327{
328 _copyCaseOptionValue(m_value,Type());
329}
330
331/*---------------------------------------------------------------------------*/
332/*---------------------------------------------------------------------------*/
333
334template<typename T> bool CaseOptionSimpleT<T>::
335_allowPhysicalUnit()
336{
337 using Type = typename CaseOptionTraitsT<T>::ContainerType;
338 return _allowConvert(Type());
339}
340
341namespace
342{
343// Cette classe a pour but de supprimer les blancs en début et fin de
344// chaîne sauf si \a Type est une 'String'.
345// Si le type attendu n'est pas une 'String', on considère que les blancs
346// en début et fin ne sont pas significatifs.
347template<typename Type>
348class StringCollapser
349{
350 public:
351 static String collapse(const String& str)
352 {
353 return String::collapseWhiteSpace(str);
354 }
355};
356template<>
357class StringCollapser<String>
358{
359 public:
360 static String collapse(const String& str)
361 {
362 return str;
363 }
364};
365}
366
367/*---------------------------------------------------------------------------*/
368/*---------------------------------------------------------------------------*/
369/*!
370 * \brief Cherche la valeur de l'option dans le jeu de données.
371 *
372 * La valeur trouvée est stockée dans \a m_value.
373 *
374 * Si la valeur n'est pas présente dans le jeu de données, regarde s'il
375 * existe une valeur par défaut et utilise cette dernière.
376 */
377template<typename T> void CaseOptionSimpleT<T>::
378_search(bool is_phase1)
379{
380 CaseOptionSimple::_search(is_phase1);
381 if (!is_phase1)
382 return;
383 ICaseDocumentFragment* doc = caseDocumentFragment();
384
385 // Si l'option n'est pas présente dans le jeu de données, on prend
386 // l'option par défaut, sauf si l'option est facultative
387 String str_val = (_element().null()) ? _defaultValue() : _element().value();
388 bool has_valid_value = true;
389 if (str_val.null()){
390 if (!isOptional()){
391 CaseOptionError::addOptionNotFoundError(doc,A_FUNCINFO,
392 name(),rootElement());
393 return;
394 }
395 else
396 has_valid_value = false;
397 }
398 _setHasValidValue(has_valid_value);
399 if (has_valid_value){
400 Type val = Type();
401 str_val = StringCollapser<Type>::collapse(str_val);
402 bool is_bad = builtInGetValue(val,str_val);
403 //cerr << "** TRY CONVERT " << str_val << ' ' << val << ' ' << is_bad << endl;
404 if (is_bad){
405 CaseOptionError::addInvalidTypeError(doc,A_FUNCINFO,
406 name(),rootElement(),str_val,typeToName(val));
407 return;
408 }
409 _checkPhysicalConvert(physicalUnitConverter(),val);
410 m_value = val;
411 }
412 _setIsInitialized();
413}
414
415/*---------------------------------------------------------------------------*/
416/*---------------------------------------------------------------------------*/
417
418template<typename T> void CaseOptionSimpleT<T>::
420{
421 // Si on a une valeur donnée par l'utilisateur, on ne fait rien.
422 if (isPresent())
423 return;
424
425 // Valeur déjà initialisée. Dans ce cas on remplace aussi la valeur actuelle.
426 if (_isInitialized())
427 m_value = def_value;
428
429 String s;
431 if (is_bad)
432 ARCANE_FATAL("Can not set default value");
433 _setDefaultValue(s);
434}
435
436/*---------------------------------------------------------------------------*/
437/*---------------------------------------------------------------------------*/
438
439namespace
440{
441template<typename T>
442class FunctionConverterT
443{
444 public:
445 void convert(ICaseFunction& tbl,Real t,T& value)
446 {
447 ARCANE_UNUSED(tbl);
448 ARCANE_UNUSED(t);
449 ARCANE_UNUSED(value);
450 throw CaseOptionException("FunctionConverter","Invalid type");
451 }
452};
453
454template<>
455class FunctionConverterT<Real>
456{
457 public:
458 void convert(ICaseFunction& tbl,Real t,Real& value)
459 { tbl.value(t,value); }
460};
461
462template<>
463class FunctionConverterT<Real3>
464{
465 public:
466 void convert(ICaseFunction& tbl,Real t,Real3& value)
467 { tbl.value(t,value); }
468};
469
470template<>
471class FunctionConverterT<bool>
472{
473 public:
474 void convert(ICaseFunction& tbl,Real t,bool& value)
475 { tbl.value(t,value); }
476};
477
478template<>
479class FunctionConverterT<Integer>
480{
481 public:
482 void convert(ICaseFunction& tbl,Real t,Integer& value)
483 { tbl.value(t,value); }
484};
485
486template<>
487class FunctionConverterT<String>
488{
489 public:
490 void convert(ICaseFunction& tbl,Real t,String& value)
491 { tbl.value(t,value); }
492};
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
497template<typename ParamType,typename ValueType>
498class ComputeFunctionValue
499{
500 public:
501 static void convert(ICaseFunction* func,ParamType t,ValueType& new_value)
502 {
503 FunctionConverterT<ValueType>().convert(*func,t,new_value);
504 }
505};
506
507} // namespace
508
509/*---------------------------------------------------------------------------*/
510/*---------------------------------------------------------------------------*/
511
513valueAtParameter(Real t) const
514{
515 ICaseFunction* func = function();
516 Type new_value(m_value);
517 if (func){
518 ComputeFunctionValue<Real,T>::convert(func,t,new_value);
519 _checkPhysicalConvert(physicalUnitConverter(),new_value);
520 }
521 return new_value;
522}
523
524/*---------------------------------------------------------------------------*/
525/*---------------------------------------------------------------------------*/
526
528valueAtParameter(Integer t) const
529{
530 ICaseFunction* func = function();
531 Type new_value(m_value);
532 if (func){
533 ComputeFunctionValue<Integer,T>::convert(func,t,new_value);
534 _checkPhysicalConvert(physicalUnitConverter(),new_value);
535 }
536 return new_value;
537}
538
539/*---------------------------------------------------------------------------*/
540/*---------------------------------------------------------------------------*/
541
542template<typename T> void CaseOptionSimpleT<T>::
544{
545 _checkIsInitialized();
546 ICaseFunction* func = function();
547 if (!func)
548 return;
549 Type new_value(m_value);
550 switch(func->paramType()){
551 case ICaseFunction::ParamReal:
552 ComputeFunctionValue<Real,T>::convert(func,current_time,new_value);
553 break;
554 case ICaseFunction::ParamInteger:
555 ComputeFunctionValue<Integer,T>::convert(func,current_iteration,new_value);
556 break;
557 case ICaseFunction::ParamUnknown:
558 break;
559 }
560 _checkPhysicalConvert(physicalUnitConverter(),new_value);
561 this->_setChangedSinceLastIteration(m_value!=new_value);
562 ITraceMng* msg = caseMng()->traceMng();
563 msg->debug() << "New value for option <" << name() << "> " << new_value;
564 _copyCaseOptionValue(m_value,new_value);
565}
566
567/*---------------------------------------------------------------------------*/
568/*---------------------------------------------------------------------------*/
569
570template<typename T> void CaseOptionSimpleT<T>::
571print(const String& lang,std::ostream& o) const
572{
573 ARCANE_UNUSED(lang);
574 _checkIsInitialized();
575 if (hasValidValue())
576 o << m_value;
577 else
578 o << "undefined";
579}
580
581/*---------------------------------------------------------------------------*/
582/*---------------------------------------------------------------------------*/
583
584/*---------------------------------------------------------------------------*/
585/*---------------------------------------------------------------------------*/
586
587template<typename T> CaseOptionMultiSimpleT<T>::
590{
591}
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
595
596template<typename T> CaseOptionMultiSimpleT<T>::
597CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob,
598 const String& /*physical_unit*/)
599: CaseOptionMultiSimple(cob)
600{
601}
602
603/*---------------------------------------------------------------------------*/
604/*---------------------------------------------------------------------------*/
605
606template<typename T> CaseOptionMultiSimpleT<T>::
607~CaseOptionMultiSimpleT()
608{
609 const T* avalue = m_view.data();
610 delete[] avalue;
611}
612
613/*---------------------------------------------------------------------------*/
614/*---------------------------------------------------------------------------*/
615
616template<typename T> bool CaseOptionMultiSimpleT<T>::
617_allowPhysicalUnit()
618{
619 using Type = typename CaseOptionTraitsT<T>::ContainerType;
620 return _allowConvert(Type());
621}
622
623/*---------------------------------------------------------------------------*/
624/*---------------------------------------------------------------------------*/
625/*!
626 * \brief Cherche la valeur de l'option dans le jeu de donnée.
627 *
628 * La valeur trouvée est stockée dans \a m_value.
629 *
630 * Si la valeur n'est pas présente dans le jeu de donnée, regarde s'il
631 * existe une valeur par défaut et utilise cette dernière.
632 */
633template<typename T> void CaseOptionMultiSimpleT<T>::
634_search(bool is_phase1)
635{
636 if (!is_phase1)
637 return;
638 XmlNodeList elem_list = rootElement().children(name());
639
640 Integer asize = elem_list.size();
641 _checkMinMaxOccurs(asize);
642 if (asize==0)
643 return;
644
645 const Type* old_value = m_view.data();
646 delete[] old_value;
647 using Type = typename CaseOptionTraitsT<T>::ContainerType;
648 Type* ptr_value = new Type[asize];
649 m_view = ArrayViewType(asize,ptr_value);
650 this->_setArray(ptr_value,asize);
651
652 //cerr << "** MULTI SEARCH " << size << endl;
653 for( Integer i=0; i<asize; ++i ){
655 // Si l'option n'est pas présente dans le jeu de donnée, on prend
656 // l'option par défaut.
657 String str_val = (velem.null()) ? _defaultValue() : velem.value();
658 if (str_val.null())
659 CaseOptionError::addOptionNotFoundError(caseDocumentFragment(),A_FUNCINFO,
660 name(),rootElement());
661 Type val = Type();
662 str_val = StringCollapser<Type>::collapse(str_val);
663 bool is_bad = builtInGetValue(val,str_val);
664 if (is_bad)
665 CaseOptionError::addInvalidTypeError(caseDocumentFragment(),A_FUNCINFO,
666 name(),rootElement(),str_val,typeToName(val));
667 //throw CaseOptionException("get_value",name(),rootElement(),str_val,typeToName(val));
668 //ptr_value[i] = val;
669 _copyCaseOptionValue(ptr_value[i],val);
670 }
671}
672
673/*---------------------------------------------------------------------------*/
674/*---------------------------------------------------------------------------*/
675
676template<typename T> void CaseOptionMultiSimpleT<T>::
677print(const String& lang,std::ostream& o) const
678{
679 ARCANE_UNUSED(lang);
680 for( Integer i=0; i<this->size(); ++i )
681 o << this->_ptr()[i] << " ";
682}
683
684/*---------------------------------------------------------------------------*/
685/*---------------------------------------------------------------------------*/
686
687template<typename T> void CaseOptionMultiSimpleT<T>::
689{
690 visitor->applyVisitor(this);
691}
692
693/*---------------------------------------------------------------------------*/
694/*---------------------------------------------------------------------------*/
695
696String CaseOptionSimple::
697_convertFunctionRealToString(ICaseFunction* func,Real t)
698{
699 String v;
700 ComputeFunctionValue<Real,String>::convert(func,t,v);
701 return v;
702}
703
704/*---------------------------------------------------------------------------*/
705/*---------------------------------------------------------------------------*/
706
707String CaseOptionSimple::
708_convertFunctionIntegerToString(ICaseFunction* func,Integer t)
709{
710 String v;
711 ComputeFunctionValue<Integer,String>::convert(func,t,v);
712 return v;
713}
714
715/*---------------------------------------------------------------------------*/
716/*---------------------------------------------------------------------------*/
717
718template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real>;
719template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2>;
720template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3>;
721template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2x2>;
722template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3x3>;
723template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<bool>;
724template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int16>;
725template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int32>;
726template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int64>;
727template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<String>;
728
729template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<RealArray>;
730template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2Array>;
731template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3Array>;
732template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2x2Array>;
733template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3x3Array>;
734template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<BoolArray>;
735template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int16Array>;
736template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int32Array>;
737template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int64Array>;
738template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<StringArray>;
739
740template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real>;
741template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2>;
742template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3>;
743template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2x2>;
744template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3x3>;
745template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<bool>;
746template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int16>;
747template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int32>;
748template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int64>;
749template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<String>;
750
751template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<RealArray>;
752template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2Array>;
753template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3Array>;
754template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2x2Array>;
755template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3x3Array>;
756template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<BoolArray>;
757template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int16Array>;
758template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int32Array>;
759template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int64Array>;
760template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<StringArray>;
761
762/*---------------------------------------------------------------------------*/
763/*---------------------------------------------------------------------------*/
764
765} // End namespace Arcane
766
767/*---------------------------------------------------------------------------*/
768/*---------------------------------------------------------------------------*/
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Exception en rapport avec le jeu de données.
Option du jeu de données de type liste de types simples (réel, entier, booléen, .....
typename CaseOptionTraitsT< T >::ContainerType Type
Type de la valeur de l'option.
typename CaseOptionTraitsT< T >::ArrayViewType ArrayViewType
Type de la vue sur les valeurs de l'option.
Option du jeu de données de type simple (réel, entier, booléen, ...)
CaseOptionTraitsT< T >::ContainerType Type
Type de l'option.
Interface du visiteur pour une option du jeu de données.
Liste de noeuds d'un arbre DOM.
Definition XmlNodeList.h:33
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Interface du gestionnaire de traces.
virtual TraceMessage info()=0
Flot pour un message d'information.
Référence à une instance.
Chaîne de caractères unicode.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
bool builtInPutValue(const String &v, String &s)
Converti la valeur v dans la chaîne s.
double Real
Type représentant un réel.
Int32 Integer
Type représentant un entier.