Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
CaseOptionBase.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* CaseOptionBase.cc (C) 2000-2025 */
9/* */
10/* Gestion des options du jeu de données. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/CaseOptionBase.h"
15
16#include "arcane/utils/FatalErrorException.h"
17#include "arcane/utils/StringBuilder.h"
18
19#include "arcane/core/CaseOptionBuildInfo.h"
20#include "arcane/core/StringDictionary.h"
21#include "arcane/core/CaseOptions.h"
22#include "arcane/core/ICaseMng.h"
23#include "arcane/core/ICaseDocument.h"
24#include "arcane/core/CaseOptionException.h"
25#include "arcane/core/internal/ICaseOptionListInternal.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane
31{
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
65
66/*---------------------------------------------------------------------------*/
67/*---------------------------------------------------------------------------*/
68
69CaseOptionBasePrivate::
70CaseOptionBasePrivate(const CaseOptionBuildInfo& cob)
71: m_case_mng(cob.caseMng())
72, m_parent_option_list(cob.caseOptionList())
73, m_case_document_fragment(m_parent_option_list->caseDocumentFragment())
74, m_root_element()
75, m_true_name(cob.name())
76, m_name(m_true_name)
77, m_axl_default_value(cob.defaultValue())
78, m_default_value(m_axl_default_value)
79, m_min_occurs(cob.minOccurs())
80, m_max_occurs(cob.maxOccurs())
81, m_is_optional(cob.isOptional())
82, m_is_initialized(false)
83, m_is_override_default(false)
84{
85}
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
92
93CaseOptionBase::
94CaseOptionBase(const CaseOptionBuildInfo& cob)
95: m_p(new CaseOptionBasePrivate(cob))
96{
97 cob.caseOptionList()->_internalApi()->addConfig(this,cob.element());
98}
99
100/*---------------------------------------------------------------------------*/
101/*---------------------------------------------------------------------------*/
102
103CaseOptionBase::
104~CaseOptionBase()
105{
106 delete m_p;
107}
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
113caseMng() const
114{
115 return m_p->m_case_mng;
116}
117
118/*---------------------------------------------------------------------------*/
119/*---------------------------------------------------------------------------*/
120
122parentOptionList() const
123{
124 return m_p->m_parent_option_list;
125}
126
127/*---------------------------------------------------------------------------*/
128/*---------------------------------------------------------------------------*/
129
131traceMng() const
132{
133 return m_p->m_case_mng->traceMng();
134}
135
136/*---------------------------------------------------------------------------*/
137/*---------------------------------------------------------------------------*/
138
140subDomain() const
141{
142 return m_p->m_case_mng->subDomain();
143}
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
149caseDocument() const
150{
151 return caseMng()->caseDocument();
152}
153
154/*---------------------------------------------------------------------------*/
155/*---------------------------------------------------------------------------*/
156
159{
160 return m_p->m_case_document_fragment;
161}
162
163/*---------------------------------------------------------------------------*/
164/*---------------------------------------------------------------------------*/
165
167_defaultValue() const
168{
169 return m_p->m_default_value;
170}
171
172/*---------------------------------------------------------------------------*/
173/*---------------------------------------------------------------------------*/
174
175void CaseOptionBase::
176_setDefaultValue(const String& def_value)
177{
178 m_p->m_default_value = def_value;
180}
181
182/*---------------------------------------------------------------------------*/
183/*---------------------------------------------------------------------------*/
184
186search(bool is_phase1)
187{
188 _setCategoryDefaultValue();
189 _setTranslatedName();
190 _search(is_phase1);
191}
192
193/*---------------------------------------------------------------------------*/
194/*---------------------------------------------------------------------------*/
195
197trueName() const
198{
199 return m_p->m_true_name;
200}
201
202/*---------------------------------------------------------------------------*/
203/*---------------------------------------------------------------------------*/
204
206name() const
207{
208 return m_p->m_name;
209}
210
211/*---------------------------------------------------------------------------*/
212/*---------------------------------------------------------------------------*/
213
215minOccurs() const
216{
217 return m_p->m_min_occurs;
218}
219
220/*---------------------------------------------------------------------------*/
221/*---------------------------------------------------------------------------*/
222
224maxOccurs() const
225{
226 return m_p->m_max_occurs;
227}
228
229/*---------------------------------------------------------------------------*/
230/*---------------------------------------------------------------------------*/
231
233isOptional() const
234{
235 return m_p->m_is_optional;
236}
237
238/*---------------------------------------------------------------------------*/
239/*---------------------------------------------------------------------------*/
240
241void CaseOptionBase::
242_setTranslatedName()
243{
245 if (lang.null())
247 else{
249 if (!tr.null()){
250 //cerr << "** TRANSLATION FOR " << m_p->m_true_name << " is " << tr << " in " << lang << '\n';
251 m_p->m_name = tr;
252 }
253 }
254}
255
256/*---------------------------------------------------------------------------*/
257/*---------------------------------------------------------------------------*/
258
259void CaseOptionBase::
260_setCategoryDefaultValue()
261{
262 // Si le développeur a surchargé l'option, ne fait rien
263 if (m_p->m_is_override_default)
264 return;
265 String category = caseDocumentFragment()->defaultCategory();
266 if (category.null())
267 m_p->m_default_value = m_p->m_axl_default_value;
268 else{
269 String v = m_p->m_default_values.find(category);
270 if (!v.null()){
271 m_p->m_default_value = v;
272 }
273 }
274}
275
276/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
280translatedName(const String& lang) const
281{
282 if (!lang.null()){
283 String tr = m_p->m_name_translations.find(lang);
284 if (!tr.null())
285 return tr;
286 }
287 return m_p->m_name;
288}
289
290/*---------------------------------------------------------------------------*/
291/*---------------------------------------------------------------------------*/
292
294setRootElement(const XmlNode& root_element)
295{
296 m_p->m_root_element = root_element;
297}
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
303rootElement() const
304{
305 return m_p->m_root_element;
306}
307
308/*---------------------------------------------------------------------------*/
309/*---------------------------------------------------------------------------*/
310
312addAlternativeNodeName(const String& lang,const String& name)
313{
314 m_p->m_name_translations.add(lang,name);
315}
316
317/*---------------------------------------------------------------------------*/
318/*---------------------------------------------------------------------------*/
319
321addDefaultValue(const String& category,const String& value)
322{
323 m_p->m_default_values.add(category,value);
324}
325
326/*---------------------------------------------------------------------------*/
327/*---------------------------------------------------------------------------*/
328
329void CaseOptionBase::
330_setIsInitialized()
331{
332 m_p->m_is_initialized = true;
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338bool CaseOptionBase::
339_isInitialized() const
340{
341 return m_p->m_is_initialized;
342}
343
344/*---------------------------------------------------------------------------*/
345/*---------------------------------------------------------------------------*/
346
347void CaseOptionBase::
348_checkIsInitialized() const
349{
350 if (!_isInitialized()){
351 ARCANE_THROW(CaseOptionException,"option non initialisée '{0}'",name());
352 }
353}
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358void CaseOptionBase::
359_checkMinMaxOccurs(Integer nb_occur)
360{
361 Integer min_occurs = m_p->m_min_occurs;
362 Integer max_occurs = m_p->m_max_occurs;
363 bool is_optional = m_p->m_is_optional;
364
365 if (nb_occur == 0 && is_optional) {
366 return;
367 }
368
369 if (nb_occur<min_occurs){
370 StringBuilder msg = "Bad number of occurences (less than min)";
371 msg += " nb_occur=";
372 msg += nb_occur;
373 msg += " min_occur=";
374 msg += min_occurs;
375 msg += " option=";
376 msg += m_p->m_root_element.xpathFullName();
377 msg += "/";
378 msg += name();
379 throw CaseOptionException(A_FUNCINFO,msg.toString(),true);
380 }
381 if (max_occurs>=0)
382 if (nb_occur>max_occurs){
383 StringBuilder msg = "Bad number of occurences (greater than max)";
384 msg += " nb_occur=";
385 msg += nb_occur;
386 msg += " max_occur=";
387 msg += max_occurs;
388 msg += " option=";
389 msg += m_p->m_root_element.xpathFullName();
390 msg += "/";
391 msg += name();
392 throw CaseOptionException(A_FUNCINFO,msg.toString(),true);
393 }
394}
395
396/*---------------------------------------------------------------------------*/
397/*---------------------------------------------------------------------------*/
398
399String CaseOptionBase::
400_xpathFullName() const
401{
402 return m_p->m_root_element.xpathFullName();
403}
404
405/*---------------------------------------------------------------------------*/
406/*---------------------------------------------------------------------------*/
407
408}
409
410/*---------------------------------------------------------------------------*/
411/*---------------------------------------------------------------------------*/
412
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
const String m_axl_default_value
Valeur par défaut initiale.
Integer m_min_occurs
Nombre minimum d'occurences.
String m_name
Nom traduit de l'option.
ICaseMng * m_case_mng
Gestionnaire du sous-domaine.
XmlNode m_root_element
Elément du DOM de l'option.
Integer m_max_occurs
Nombre maximum d'occurences (-1 == unbounded)
StringDictionary m_default_values
Liste des valeurs par défaut par catégorie.
bool m_is_initialized
true si initialisé
ICaseDocumentFragment * m_case_document_fragment
Document associé
String m_default_value
Valeur par défaut.
StringDictionary m_name_translations
Liste des noms d'options par langue.
ICaseOptionList * m_parent_option_list
Parent.
String m_true_name
Nom de l'option.
String name() const
Retourne le nom de l'option correspondant au langage du jeu de données.
String translatedName(const String &lang) const
Nom dans la langue lang de l'option. Retourne name() si pas de traduction.
void addDefaultValue(const String &category, const String &value)
Ajoute la valeur par défaut value à la catégorie category.
String _defaultValue() const
Retourne la valeur par défaut de l'option ou 0 s'il n'y en a pas.
ICaseDocument * caseDocument() const
Retourne le gestionnaire de document.
void search(bool is_phase1)
Récupère la valeur du fichier de configuration pour la variable.
ICaseMng * caseMng() const
Gestionnaire de cas.
ICaseDocumentFragment * caseDocumentFragment() const
Retourne le document associé à cette option.
void addAlternativeNodeName(const String &lang, const String &name)
Ajoute une traduction pour le nom de l'option.
void setRootElement(const XmlNode &root_element)
Positionne l'élément racine à root_element.
bool isOptional() const
Permet de savoir si une option est optionnelle.
Integer maxOccurs() const
Nombre maximum d'occurences (pour une option multiple) (-1 == unbounded)
XmlNode rootElement() const
Retourne l'élément racine du DOM.
ITraceMng * traceMng() const
Gestionnaire de traces.
CaseOptionBasePrivate * m_p
Implémentation.
ISubDomain * subDomain() const
Gestionnaire de sous-domaine.
String trueName() const
Retourne le vrai nom (non traduit) de l'option.
ICaseOptionList * parentOptionList() const
OptionList parent.
Integer minOccurs() const
Nombre minimum d'occurences (pour une option multiple)
Informations pour construire une option de jeu de données.
Interface d'une partie d'un jeu de données.
virtual String defaultCategory() const =0
Catégorie utilisée pour les valeurs par défaut.
virtual String language() const =0
Langage utilisé dans le jeu de données.
Interface d'une classe gérant un document XML du jeu de données.
Interface du gestionnaire de cas.
Definition ICaseMng.h:56
virtual ICaseDocument * caseDocument()=0
Document XML du jeu de données (peut être nul si pas de jeu de donneés)
Interface d'une liste d'options du jeu de données.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Interface du gestionnaire de traces.
Dictionnaire de chaînes unicode.
String find(const String &key, bool throw_exception=false) const
Retourne la valeur associée à key.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Noeud d'un arbre DOM.
Definition XmlNode.h:51
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.