CaseOptionEnum.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CaseOptionEnum.cc                                           (C) 2000-2023 */
/*                                                                           */
/* Enumerated data set option.                                               */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/CaseOptionEnum.h"
 
#include "arcane/utils/Array.h"
#include "arcane/utils/ITraceMng.h"
 
#include "arcane/core/ICaseFunction.h"
#include "arcane/core/ICaseMng.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/StringDictionary.h"
#include "arcane/core/CaseOptionError.h"
#include "arcane/core/ICaseDocumentVisitor.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionName::
CaseOptionName(const String& aname)
: m_true_name(aname)
, m_translations(0)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionName::
CaseOptionName(const CaseOptionName& rhs)
: m_true_name(rhs.m_true_name)
, m_translations(0)
{
  if (rhs.m_translations)
    m_translations = new StringDictionary(*rhs.m_translations);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionName::
~CaseOptionName()
{
  delete m_translations;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionName::
addAlternativeNodeName(const String& lang, const String& name)
{
  if (!m_translations)
    m_translations = new StringDictionary();
  m_translations->add(lang, name);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionName::
name(const String& lang) const
{
  if (!m_translations || lang.null())
    return m_true_name;
  String s = m_translations->find(lang);
  if (s.null())
    return m_true_name;
  return s;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionEnumValue::
CaseOptionEnumValue(const String& name, int value)
: CaseOptionName(name)
, m_value(value)
{
}
 
CaseOptionEnumValue::
CaseOptionEnumValue(const CaseOptionEnumValue& rhs)
: CaseOptionName(rhs)
, m_value(rhs.m_value)
{
}
 
CaseOptionEnumValue::
~CaseOptionEnumValue()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionEnumValues::
CaseOptionEnumValues()
: m_enum_values(new EnumValueList())
{
}
 
CaseOptionEnumValues::
~CaseOptionEnumValues()
{
  for (auto i : (*m_enum_values)) {
    delete i;
  }
  delete m_enum_values;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionEnumValue* CaseOptionEnumValues::
enumValue(Integer index) const
{
  return (*m_enum_values)[index];
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnumValues::
addEnumValue(CaseOptionEnumValue* value, bool do_clone)
{
  CaseOptionEnumValue* svalue = value;
  if (do_clone)
    svalue = new CaseOptionEnumValue(*value);
  m_enum_values->add(svalue);
}
 
Integer CaseOptionEnumValues::
nbEnumValue() const
{
  return m_enum_values->size();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool CaseOptionEnumValues::
valueOfName(const String& name, const String& lang, int& value) const
{
  for (auto ev : (*m_enum_values)) {
    const String& n = ev->name(lang);
    if (n == name) {
      value = ev->value();
      return false;
    }
  }
  return true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionEnumValues::
nameOfValue(int value, const String& lang) const
{
  String s;
  for (auto ev : (*m_enum_values)) {
    if (ev->value() == value) {
      s = ev->name(lang);
      break;
    }
  }
  return s;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnumValues::
getValidNames(const String& lang, StringArray& names) const
{
  for (auto ev : (*m_enum_values)) {
    names.add(ev->name(lang));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionEnum::
CaseOptionEnum(const CaseOptionBuildInfo& cob, const String& type_name)
: CaseOptionSimple(cob)
, m_type_name(type_name)
, m_enum_values(new CaseOptionEnumValues())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionEnum::
~CaseOptionEnum()
{
  delete m_enum_values;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnum::
_search(bool is_phase1)
{
  CaseOptionSimple::_search(is_phase1);
  if (!is_phase1)
    return;
  bool is_default = _element().null();
  String str_val = (is_default) ? _defaultValue() : _element().value();
  bool has_valid_value = true;
  if (str_val.null()) {
    if (!isOptional()) {
      CaseOptionError::addOptionNotFoundError(caseDocumentFragment(), A_FUNCINFO,
                                              name(), rootElement());
 
      return;
    }
    else
      has_valid_value = false;
  }
  _setHasValidValue(has_valid_value);
 
  if (has_valid_value) {
    String lang;
    // The default value does not have an associated language. Therefore, it
    // should not be attempted to convert it.
    if (!is_default)
      lang = caseDocumentFragment()->language();
    int value = 0;
    bool is_bad = m_enum_values->valueOfName(str_val, lang, value);
 
    if (is_bad) {
      StringUniqueArray valid_values;
      m_enum_values->getValidNames(lang, valid_values);
      CaseOptionError::addInvalidTypeError(caseDocumentFragment(), A_FUNCINFO,
                                           name(), rootElement(), str_val, m_type_name, valid_values);
      return;
    }
    _setOptionValue(value);
  }
 
  _setIsInitialized();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnum::
_setEnumDefaultValue(int def_value)
{
  // If a value is provided by the user, do nothing.
  if (isPresent())
    return;
 
  // Value already initialized. In this case, the current value is also replaced
  if (_isInitialized())
    _setOptionValue(def_value);
 
  // The default value does not have an associated language.
  _setDefaultValue(m_enum_values->nameOfValue(def_value, String()));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnum::
print(const String& lang, std::ostream& o) const
{
  _checkIsInitialized();
  int v = _optionValue();
  o << "'" << m_enum_values->nameOfValue(v, lang) << "' (" << v << ")";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnum::
visit(ICaseDocumentVisitor* visitor) const
{
  visitor->applyVisitor(this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionEnum::
_updateFromFunction(Real current_time, Integer current_iteration)
{
  _checkIsInitialized();
  ICaseFunction* func = function();
  ITraceMng* msg = caseMng()->traceMng();
  String lang = caseDocumentFragment()->language();
  int current_value = _optionValue();
  String new_str = m_enum_values->nameOfValue(current_value, lang);
  switch (func->paramType()) {
  case ICaseFunction::ParamReal:
    new_str = _convertFunctionRealToString(func, current_time);
    break;
  case ICaseFunction::ParamInteger:
    new_str = _convertFunctionIntegerToString(func, current_iteration);
    break;
  case ICaseFunction::ParamUnknown:
    break;
  }
  int new_value = 0;
  bool is_bad = m_enum_values->valueOfName(new_str, lang, new_value);
  if (is_bad) {
    StringUniqueArray valid_values;
    m_enum_values->getValidNames(lang, valid_values);
    CaseOptionError::addInvalidTypeError(caseDocumentFragment(), A_FUNCINFO,
                                         name(), rootElement(), new_str, m_type_name, valid_values);
    return;
    //throw CaseOptionException("get_value",name(),rootElement(),new_str,m_type_name);
  }
  msg->debug() << "New value for enum option <" << name() << "> " << new_value;
  bool has_changed = new_value != current_value;
  _setChangedSinceLastIteration(has_changed);
  if (has_changed)
    _setOptionValue(new_value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionMultiEnum::
CaseOptionMultiEnum(const CaseOptionBuildInfo& cob, const String& type_name)
: CaseOptionBase(cob)
, m_type_name(type_name)
, m_enum_values(new CaseOptionEnumValues())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionMultiEnum::
~CaseOptionMultiEnum()
{
  delete m_enum_values;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionMultiEnum::
_search(bool is_phase1)
{
  XmlNodeList elem_list = rootElement().children(name());
 
  Integer size = elem_list.size();
  _checkMinMaxOccurs(size);
  if (size == 0)
    return;
 
  if (is_phase1) {
    _allocate(size);
 
    const String& lang = caseDocumentFragment()->language();
 
    for (Integer index = 0; index < size; ++index) {
      XmlNode velem = elem_list[index];
      // If the option is not present in the dataset, the default option is taken.
      String str_val = (velem.null()) ? _defaultValue() : velem.value();
      if (str_val.null()) {
        CaseOptionError::addOptionNotFoundError(caseDocumentFragment(), A_FUNCINFO,
                                                name(), rootElement());
        continue;
        //throw CaseOptionException("get_value",name(),rootElement());
      }
 
      int value = 0;
      bool is_bad = m_enum_values->valueOfName(str_val, lang, value);
 
      if (is_bad) {
        StringUniqueArray valid_values;
        m_enum_values->getValidNames(lang, valid_values);
        CaseOptionError::addInvalidTypeError(caseDocumentFragment(), A_FUNCINFO,
                                             name(), rootElement(), str_val, m_type_name, valid_values);
        continue;
        //throw CaseOptionException("get_value",name(),rootElement(),str_val,m_type_name);
      }
      else
        _setOptionValue(index, value);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionMultiEnum::
print(const String& lang, std::ostream& o) const
{
  for (Integer i = 0, s = _nbElem(); i < s; ++i) {
    int v = _optionValue(i);
    o << "'" << m_enum_values->nameOfValue(v, lang) << "' (" << v << ")";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionMultiEnum::
visit(ICaseDocumentVisitor* visitor) const
{
  visitor->applyVisitor(this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/