Arcane  v3.14.10.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
CaseOptionSimple.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2023 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/* CaseOptionSimple.h (C) 2000-2023 */
9/* */
10/* Option simple du jeu de données. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CASEOPTIONSIMPLE_H
13#define ARCANE_CASEOPTIONSIMPLE_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/core/ICaseOptions.h"
18#include "arcane/core/CaseOptionBase.h"
19
20/*---------------------------------------------------------------------------*/
21/*---------------------------------------------------------------------------*/
22
23namespace Arcane
24{
25
26class IStandardFunction;
27class IPhysicalUnitConverter;
28class StringDictionary;
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33#ifdef ARCANE_CHECK
34#define ARCANE_CASEOPTION_CHECK_IS_INITIALIZED _checkIsInitialized()
35#else
36#define ARCANE_CASEOPTION_CHECK_IS_INITIALIZED
37#endif
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42template<typename Type>
44{
45 public:
46 using ContainerType = Type;
47 using ReferenceType = Type&;
48 using ConstReferenceType = const Type&;
49 using ArrayViewType = ArrayView<Type>;
50 using ConstArrayViewType = ConstArrayView<Type>;
51};
52
53/*---------------------------------------------------------------------------*/
54/*---------------------------------------------------------------------------*/
55/*!
56 * \brief Spécialisation pour les options 'Array'.
57 *
58 * Cela est nécessaire car on ne peut pas instancier la classe 'Array'. Pour
59 * ce type d'options, il est interdit de modifier les valeurs de l'option donc
60 * les vues sont forcément constantes.
61 */
62template<typename Type>
64{
65 public:
66 using ContainerType = UniqueArray<Type>;
67 using ReferenceType = const Array<Type>&;
68 using ConstReferenceType = const Array<Type>&;
69 using ArrayViewType = ConstArrayView<ContainerType>;
70 using ConstArrayViewType = ConstArrayView<ContainerType>;
71};
72
73/*---------------------------------------------------------------------------*/
74/*---------------------------------------------------------------------------*/
75/*!
76 * \brief Classe de base des options simples (uniquement une valeur).
77 * \ingroup CaseOption
78 */
79class ARCANE_CORE_EXPORT CaseOptionSimple
80: public CaseOptionBase
81{
82 public:
83
84 explicit CaseOptionSimple(const CaseOptionBuildInfo& cob);
85 CaseOptionSimple(const CaseOptionBuildInfo& cob,const String& physical_unit);
87
88 public:
89
90 //! Retourne \a true si l'option est présente
91 bool isPresent() const { return !m_element.null(); }
92
93 /*!
94 * \brief Retourne l'élément de l'option.
95 *
96 * \deprecated L'implémentation interne ne doit pas être utilisée pour permettre
97 * à terme d'utiliser un autre format que le XML.
98 */
99 ARCANE_DEPRECATED_LONG_TERM("Y2022: Do not access XML item from option")
100 XmlNode element() const { return m_element; }
101
102 /*!
103 * \brief Fonction associée à cette option (0 si aucune).
104 *
105 * Si une fonction est associée à l'option, les valeurs de cette
106 * dernière sont recalculées automatiquement à chaque itération.
107 */
108 ICaseFunction* function() const override { return m_function; }
109 /*!
110 * \brief Fonction standard associée à cette option (0 si aucune).
111 *
112 * Une fonction standard a un prototype spécifique et peut être appelée
113 * directement. Contrairement à function(), la présence d'une fonction
114 * standard ne change pas la valeur de l'option.
115 */
116 virtual IStandardFunction* standardFunction() const { return m_standard_function; }
117 /*!
118 * \brief Indique si la valeur a changée depuis la dernière itération.
119 *
120 * La valeur ne peut changée que si une fonction est associée à l'option.
121 * La méthode retourne vrai si la valeur de l'option est différente de l'itération
122 * précédente. Cette méthode fonctionne aussi en cas de retour arrière.
123 */
124 bool hasChangedSinceLastIteration() const;
125 //! Nom complet au format donné par la norme XPath.
126 String xpathFullName() const;
127 /*!
128 * \brief Unité physique par défaut de cette option (null si aucune unité),
129 * spécifiée dans le fichier .axl.
130 */
131 String defaultPhysicalUnit() const;
132 //! unité physique spécifiée dans le jeu de données (null si aucune unité)
133 String physicalUnit() const;
134 /*!
135 * \brief Convertisseur d'unité physique.
136 *
137 * Ce convertisseur n'existe que pour les options de type 'Real'ou 'RealArray'.
138 * Il est nul si l'option ne possède pas d'unité.
139 */
140 IPhysicalUnitConverter* physicalUnitConverter() const { return m_unit_converter; }
141 /*!
142 * \brief Indique si l'option est facultative.
143 *
144 * Si une option facultative n'est pas renseignée,
145 * sa valeur est indéfinie et ne doit donc pas être utilisée.
146 */
147 bool isOptional() const { return m_is_optional; }
148
149 /*!
150 * \brief Indique si l'option a une valeur invalide.
151 *
152 * C'est apriori toujours le cas, sauf si l'option est facultative
153 * (isOptional()==true) et non renseignée.
154 */
155 bool hasValidValue() const { return m_has_valid_value; }
156
157 void visit(ICaseDocumentVisitor* visitor) const override;
158
159 protected:
160
161 void _search(bool is_phase1) override;
162 virtual bool _allowPhysicalUnit() =0;
163 void _setChangedSinceLastIteration(bool has_changed);
164 void _searchFunction(XmlNode& velem);
165 void _setPhysicalUnit(const String& value);
166 void _setHasValidValue(bool v) { m_has_valid_value = v; }
167 XmlNode _element() const { return m_element; }
168
169 static String _convertFunctionRealToString(ICaseFunction* func,Real t);
170 static String _convertFunctionIntegerToString(ICaseFunction* func,Integer t);
171
172 private:
173
174 XmlNode m_element; //!< Element de l'option
175 ICaseFunction* m_function = nullptr; //!< Fonction associée (ou nullptr)
176 IStandardFunction* m_standard_function = nullptr; //!< Fonction standard associée (ou nullpt)
177 //! Convertisseur d'unité (nullptr si pas besoin). Valide uniquement pour les options 'Real'
178 IPhysicalUnitConverter* m_unit_converter = nullptr;
179 bool m_changed_since_last_iteration = false;
180 bool m_is_optional = false;
181 bool m_has_valid_value = false;
182 String m_default_physical_unit;
183 String m_physical_unit;
184};
185
186/*---------------------------------------------------------------------------*/
187/*---------------------------------------------------------------------------*/
188/*!
189 * \ingroup CaseOption
190 * \brief Option du jeu de données de type simple (réel, entier, booléen, ...)
191 *
192 * La méthode la plus utilisée de cette classe est l'opérateur operator()()
193 * qui permet de récupérer la valeur de l'option. Si une fonction (ICaseFunction)
194 * est associée à l'option, il est possible de récupérer la valeur de l'option
195 * au temps physique ou à l'itération passé en paramètre de la méthode
196 * valueAtParameter().
197 * \code
198 * CaseOptionSimpleT<Real> real_option;
199 * Real v = real_option(); // utilise operator()
200 * Real v = real_option; // utilise opérateur de cast implicite
201 * Real v = real_option.valueAtParameter(0.3); // valeur au temps physique 0.3
202 * \endcode
203 */
204template<class T>
206: public CaseOptionSimple
207{
208 public:
209
210 typedef CaseOptionSimpleT<T> ThatClass;
211#ifndef SWIG
212 typedef typename CaseOptionTraitsT<T>::ContainerType Type; //!< Type de l'option
213#else
214 typedef T Type; //!< Type de l'option
215#endif
216 public:
217
218 ARCANE_CORE_EXPORT CaseOptionSimpleT(const CaseOptionBuildInfo& cob);
219 ARCANE_CORE_EXPORT CaseOptionSimpleT(const CaseOptionBuildInfo& cob,const String& physical_unit);
220
221 public:
222
223 ARCANE_CORE_EXPORT virtual void print(const String& lang,std::ostream& o) const;
224
225 //! Retourne la valeur de l'option
226 const Type& value() const
227 {
228 ARCANE_CASEOPTION_CHECK_IS_INITIALIZED;
229 return m_value;
230 }
231
232 //! Valeur de l'option
233 operator const Type&() const { return value(); }
234
235 //! Retourne la valeur de l'option pour le paramètre réel t.
236 ARCANE_CORE_EXPORT Type valueAtParameter(Real t) const;
237
238 //! Retourne la valeur de l'option pour le paramètre entier t.
239 ARCANE_CORE_EXPORT Type valueAtParameter(Integer t) const;
240
241 //! Retourne la valeur de l'option
242 //const Type& operator()() const { return value(); }
243 const Type& operator()() const { return value(); }
244
245#ifdef ARCANE_DOTNET
246 operator ThatClass*() { return this; }
247 operator const ThatClass*() const { return this; }
248 const ThatClass* operator->() const { return this; }
249 static Real castTo__Arcane_Real(const ThatClass& v)
250 {
251 return (Real)(v);
252 }
253#endif
254
255 //! Retourne la valeur de l'option pour le paramètre réel t.
256 ARCANE_DEPRECATED Type operator()(Real t) const
257 { return valueAtParameter(t); }
258
259 //! Retourne la valeur de l'option pour le paramètre entier t.
260 ARCANE_DEPRECATED Type operator()(Integer t) const
261 { return valueAtParameter(t); }
262
263 /*!
264 * For internal use only
265 * \internal
266 */
267 ARCANE_CORE_EXPORT virtual void updateFromFunction(Real current_time,Integer current_iteration);
268
269 /*!
270 * \brief Positionne la valeur par défaut de l'option.
271 *
272 * Si l'option n'est pas pas présente dans le jeu de données, alors sa valeur sera
273 * celle spécifiée par l'argument \a def_value, sinon l'appel de cette méthode est sans effet.
274 */
275 ARCANE_CORE_EXPORT void setDefaultValue(const Type& def_value);
276
277 //! Retourne la valeur de l'option si isPresent()==true ou sinon \a arg_value
278 const Type& valueIfPresentOrArgument(const Type& arg_value)
279 {
280 ARCANE_CASEOPTION_CHECK_IS_INITIALIZED;
281 return isPresent() ? m_value : arg_value;
282 }
283
284 protected:
285
286 ARCANE_CORE_EXPORT virtual void _search(bool is_phase1);
287 ARCANE_CORE_EXPORT virtual bool _allowPhysicalUnit();
288
289 private:
290
291 Type m_value; //!< Valeur de l'option
292
293};
294
295/*---------------------------------------------------------------------------*/
296/*---------------------------------------------------------------------------*/
297
298class ARCANE_CORE_EXPORT CaseOptionMultiSimple
299: public CaseOptionBase
300{
301 public:
303 : CaseOptionBase(cob){}
304};
305
306/*---------------------------------------------------------------------------*/
307/*---------------------------------------------------------------------------*/
308/*!
309 * \ingroup CaseOption
310 * \brief Option du jeu de données de type liste de types simples (réel, entier, booléen, ...).
311 *
312 * \warning L'utilisation de la classe de base `ArrayView<T>` est obsolète et
313 * ne doit plus être utilisée. La méthode view() permet de récupérer une vue sur les
314 * valeurs de l'option.
315 */
316#ifndef SWIG
317template<class T>
320#ifdef ARCANE_HAS_PRIVATE_CASEOPTIONSMULTISIMPLE_BASE_CLASS
321, private ArrayView<T>
322#else
323, public ArrayView<T>
324#endif
325{
326 public:
327
328 //! Type de la valeur de l'option
329 using Type = typename CaseOptionTraitsT<T>::ContainerType;
330 using ReferenceType = typename CaseOptionTraitsT<T>::ReferenceType;
331 using ConstReferenceType = typename CaseOptionTraitsT<T>::ConstReferenceType;
332 //! Type de la vue sur les valeurs de l'option
333 using ArrayViewType = typename CaseOptionTraitsT<T>::ArrayViewType;
334 //! Type de la vue constante sur les valeurs de l'option
335 using ConstArrayViewType = typename CaseOptionTraitsT<T>::ConstArrayViewType;
336
337 public:
338
339 ARCANE_CORE_EXPORT CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob);
340 ARCANE_CORE_EXPORT CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob,const String& physical_unit);
341 ARCANE_CORE_EXPORT ~CaseOptionMultiSimpleT();
342
343 public:
344
345 ARCCORE_DEPRECATED_2021("Use view() instead")
346 ArrayView<T> operator()()
347 {
348 return *this;
349 }
350 ARCCORE_DEPRECATED_2021("Use view() instead")
351 const ArrayView<T> operator()() const
352 {
353 return *this;
354 }
355
356 //! Conversion vers la vue constante
357 ARCCORE_DEPRECATED_2021("Use view() instead")
358 operator ArrayView<T>() { ArrayView<T>* v = this; return *v; }
359
360 //! Conversion vers la vue constante
361 ARCCORE_DEPRECATED_2021("Use view() instead")
362 operator ConstArrayView<T>() const { const ArrayView<T>* v = this; return *v; }
363
364 //! Vue constante sur les éléments de l'option
366 {
367 return m_view;
368 }
369 //! Vue sur les éléments de l'option
371 {
372 return m_view;
373 }
374
375 ConstReferenceType operator[](Integer i) const { return m_view[i]; }
376 ReferenceType operator[](Integer i) { return m_view[i]; }
377
378 public:
379
380 ARCANE_CORE_EXPORT void print(const String& lang,std::ostream& o) const override;
381 ICaseFunction* function() const override { return 0; }
382 void updateFromFunction(Real,Integer) override {}
383
384 ConstArrayView<T> values() const { const ArrayView<T>* v = this; return *v; }
385 const T& value(Integer index) const { return this->operator[](index); }
386 Integer size() const { return ArrayView<T>::size(); }
387 ARCANE_CORE_EXPORT void visit(ICaseDocumentVisitor* visitor) const override;
388
389 protected:
390
391 void _search(bool is_phase1) override;
392 virtual bool _allowPhysicalUnit();
393
394 private:
395 ArrayViewType m_view;
396};
397#endif
398
399/*---------------------------------------------------------------------------*/
400/*---------------------------------------------------------------------------*/
401
402typedef CaseOptionSimpleT<Real> CaseOptionReal;
403typedef CaseOptionSimpleT<Real2> CaseOptionReal2;
404typedef CaseOptionSimpleT<Real3> CaseOptionReal3;
405typedef CaseOptionSimpleT<Real2x2> CaseOptionReal2x2;
406typedef CaseOptionSimpleT<Real3x3> CaseOptionReal3x3;
407typedef CaseOptionSimpleT<bool> CaseOptionBool;
408typedef CaseOptionSimpleT<Integer> CaseOptionInteger;
409typedef CaseOptionSimpleT<Int32> CaseOptionInt32;
410typedef CaseOptionSimpleT<Int64> CaseOptionInt64;
411typedef CaseOptionSimpleT<String> CaseOptionString;
412
413typedef CaseOptionSimpleT<RealArray> CaseOptionRealArray;
414typedef CaseOptionSimpleT<Real2Array> CaseOptionReal2Array;
415typedef CaseOptionSimpleT<Real3Array> CaseOptionReal3Array;
416typedef CaseOptionSimpleT<Real2x2Array> CaseOptionReal2x2Array;
417typedef CaseOptionSimpleT<Real3x3Array> CaseOptionReal3x3Array;
418typedef CaseOptionSimpleT<BoolArray> CaseOptionBoolArray;
419typedef CaseOptionSimpleT<IntegerArray> CaseOptionIntegerArray;
420typedef CaseOptionSimpleT<Int32Array> CaseOptionInt32Array;
421typedef CaseOptionSimpleT<Int64Array> CaseOptionInt64Array;
422typedef CaseOptionSimpleT<StringArray> CaseOptionStringArray;
423
424/*---------------------------------------------------------------------------*/
425/*---------------------------------------------------------------------------*/
426
427} // End namespace Arcane
428
429/*---------------------------------------------------------------------------*/
430/*---------------------------------------------------------------------------*/
431
432#endif
Classe de base d'une option du jeu de donnée.
Option du jeu de données de type liste de types simples (réel, entier, booléen, .....
typename CaseOptionTraitsT< T >::ConstArrayViewType ConstArrayViewType
Type de la vue constante sur les valeurs de l'option.
ConstArrayViewType view() const
Vue constante sur les éléments de l'option.
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.
void updateFromFunction(Real, Integer) override
Met à jour la valeur de l'option à partir d'une fonction.
void print(const String &lang, std::ostream &o) const override
Imprime la valeur de l'option dans le langage lang,sur le flot o.
ICaseFunction * function() const override
Retourne la fonction liée à cette option ou nullptr s'il n'y en a pas.
void visit(ICaseDocumentVisitor *visitor) const override
Applique le visiteur sur cette option.
void _search(bool is_phase1) override
Cherche la valeur de l'option dans le jeu de donnée.
ArrayViewType view()
Vue sur les éléments de l'option.
Option du jeu de données de type simple (réel, entier, booléen, ...)
const Type & valueIfPresentOrArgument(const Type &arg_value)
Retourne la valeur de l'option si isPresent()==true ou sinon arg_value.
virtual void _search(bool is_phase1)
Cherche la valeur de l'option dans le jeu de données.
ARCANE_DEPRECATED Type operator()(Real t) const
Retourne la valeur de l'option pour le paramètre réel t.
Type valueAtParameter(Real t) const
Retourne la valeur de l'option pour le paramètre réel t.
CaseOptionTraitsT< T >::ContainerType Type
Type de l'option.
virtual void print(const String &lang, std::ostream &o) const
Imprime la valeur de l'option dans le langage lang,sur le flot o.
const Type & value() const
Retourne la valeur de l'option.
const Type & operator()() const
Retourne la valeur de l'option.
ARCANE_DEPRECATED Type operator()(Integer t) const
Retourne la valeur de l'option pour le paramètre entier t.
virtual void updateFromFunction(Real current_time, Integer current_iteration)
void setDefaultValue(const Type &def_value)
Positionne la valeur par défaut de l'option.
Classe de base des options simples (uniquement une valeur).
bool hasValidValue() const
Indique si l'option a une valeur invalide.
ICaseFunction * function() const override
Fonction associée à cette option (0 si aucune).
bool isOptional() const
Indique si l'option est facultative.
virtual IStandardFunction * standardFunction() const
Fonction standard associée à cette option (0 si aucune).
ARCANE_DEPRECATED_LONG_TERM("Y2022: Do not access XML item from option") XmlNode element() const
Retourne l'élément de l'option.
IPhysicalUnitConverter * physicalUnitConverter() const
Convertisseur d'unité physique.
bool isPresent() const
Retourne true si l'option est présente.
Interface du visiteur pour une option du jeu de données.
Interface gérant une fonction standard.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Vue modifiable d'un tableau d'un type T.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Classe de base des vecteurs 1D de données.
Vue constante d'un tableau de type T.
Chaîne de caractères unicode.
Vecteur 1D de données avec sémantique par valeur (style STL).
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
double Real
Type représentant un réel.
Int32 Integer
Type représentant un entier.