CaseOptionSimple.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CaseOptionSimple.cc                                         (C) 2000-2025 */
/*                                                                           */
/* Simple data set option.                                                   */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/CaseOptionSimple.h"
 
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/StringBuilder.h"
#include "arcane/utils/internal/ParameterCaseOption.h"
 
#include "arcane/core/CaseOptionException.h"
#include "arcane/core/CaseOptionBuildInfo.h"
#include "arcane/core/XmlNodeList.h"
#include "arcane/core/ICaseFunction.h"
#include "arcane/core/ICaseMng.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/CaseNodeNames.h"
#include "arcane/core/CaseOptionError.h"
#include "arcane/core/IPhysicalUnitConverter.h"
#include "arcane/core/IPhysicalUnitSystem.h"
#include "arcane/core/IStandardFunction.h"
#include "arcane/core/ICaseDocumentVisitor.h"
#include "arcane/core/internal/StringVariableReplace.h"
#include "arcane/core/internal/ICaseMngInternal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void
_copyCaseOptionValue(T& out, const T& in);
 
template <> void _copyCaseOptionValue(String& out, const String& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(bool& out, const bool& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Real& out, const Real& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Int16& out, const Int16& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Int32& out, const Int32& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Int64& out, const Int64& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Real2& out, const Real2& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Real3& out, const Real3& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Real2x2& out, const Real2x2& in)
{
  out = in;
}
template <> void _copyCaseOptionValue(Real3x3& out, const Real3x3& in)
{
  out = in;
}
 
template <typename T> void
_copyCaseOptionValue(UniqueArray<T>& out, const Array<T>& in)
{
  out.copy(in);
}
 
template <typename T> void
_copyCaseOptionValue(UniqueArray<T>& out, const UniqueArray<T>& in)
{
  out.copy(in);
}
 
template <typename T> void
_copyCaseOptionValue(Array<T>& out, const Array<T>& in)
{
  out.copy(in);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionSimple::
CaseOptionSimple(const CaseOptionBuildInfo& cob)
: CaseOptionBase(cob)
, m_is_optional(cob.isOptional())
, m_has_valid_value(true)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionSimple::
CaseOptionSimple(const CaseOptionBuildInfo& cob, const String& physical_unit)
: CaseOptionBase(cob)
, m_is_optional(cob.isOptional())
, m_has_valid_value(true)
, m_default_physical_unit(physical_unit)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseOptionSimple::
~CaseOptionSimple()
{
  delete m_unit_converter;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionSimple::
_search(bool is_phase1)
{
  if (!is_phase1)
    return;
 
  //ITraceMng* msg = caseMng()->traceMng();
  const String& velem_name = name();
  XmlNodeList velems = rootElement().children(velem_name);
  XmlNode velem;
  Integer nb_elem = velems.size();
  ICaseDocumentFragment* doc = caseDocumentFragment();
  if (nb_elem >= 1) {
    velem = velems[0];
    if (nb_elem >= 2) {
      CaseOptionError::addWarning(doc, A_FUNCINFO, velem.xpathFullName(),
                                  String::format("Only one token of the element is allowed (nb_occur={0})",
                                                 nb_elem));
    }
  }
 
  // List of command line options.
  {
    const ParameterListWithCaseOption& params = caseMng()->_internalImpl()->parameters();
    const ParameterCaseOption pco{ params.getParameterCaseOption(doc->language()) };
 
    String reference_input = pco.getParameterOrNull(String::format("{0}/{1}", rootElement().xpathFullName(), velem_name), 1, false);
    if (!reference_input.null()) {
      // If the user specified an option that is not present in the
      // data set, we must create it.
      if (velem.null()) {
        velem = rootElement().createElement(name());
      }
      velem.setValue(reference_input);
    }
    if (!velem.null()) {
      velem.setValue(StringVariableReplace::replaceWithCmdLineArgs(params, velem.value(), true));
    }
  }
 
  m_element = velem;
  m_function = 0;
 
  _searchFunction(velem);
 
  String physical_unit = m_element.attrValue("unit");
  if (!physical_unit.null()) {
    _setPhysicalUnit(physical_unit);
    if (_allowPhysicalUnit()) {
      //TODO: CHECK IF THERE IS A DEFAULT_PHYSICAL_UNIT.
      m_unit_converter = caseMng()->physicalUnitSystem()->createConverter(physical_unit, defaultPhysicalUnit());
    }
    else
      CaseOptionError::addError(doc, A_FUNCINFO, velem.xpathFullName(),
                                String::format("Usage of a physic unit ('{0}') is not allowed for this kind of option",
                                               physical_unit));
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionSimple::
_setPhysicalUnit(const String& value)
{
  m_physical_unit = value;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionSimple::
physicalUnit() const
{
  return m_physical_unit;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionSimple::
_searchFunction(XmlNode& velem)
{
  if (velem.null())
    return;
 
  // Search for a possible associated function
  String fname = caseDocumentFragment()->caseNodeNames()->function_ref;
  String func_name = velem.attrValue(fname);
  if (func_name.null())
    return;
 
  ICaseFunction* func = caseMng()->findFunction(func_name);
  ITraceMng* msg = caseMng()->traceMng();
  if (!func) {
    msg->pfatal() << "In element <" << velem.name()
                  << ">: no function named <" << func_name << ">";
  }
 
  // Check if it is a standard function
  IStandardFunction* sf = dynamic_cast<IStandardFunction*>(func);
  if (sf) {
    msg->info() << "Use standard function: " << func_name;
    m_standard_function = sf;
  }
  else {
    msg->info() << "Use function: " << func_name;
    m_function = func;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionSimple::
_setChangedSinceLastIteration(bool has_changed)
{
  m_changed_since_last_iteration = has_changed;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool CaseOptionSimple::
hasChangedSinceLastIteration() const
{
  return m_changed_since_last_iteration;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionSimple::
xpathFullName() const
{
  if (!m_element.null())
    return m_element.xpathFullName();
  String fn = rootElement().xpathFullName() + "/" + name();
  return fn;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionSimple::
defaultPhysicalUnit() const
{
  return m_default_physical_unit;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseOptionSimple::
visit(ICaseDocumentVisitor* visitor) const
{
  visitor->applyVisitor(this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*
 * Taking into account the unit system but only for
 * 'Real' or 'RealArray' type options.
 * TODO: see if it is interesting for other types
 * like Real2, Real3.
 * For integer types like 'Integer', it is better not to support conversions because this risks resulting in values
 * that are too large or zero if the conversion results in a number less than 1
 * (for example, 5 centimeters converted to meters gives 0).
 */
template <typename DataType> static void
_checkPhysicalConvert(IPhysicalUnitConverter* converter, DataType& value)
{
  ARCANE_UNUSED(converter);
  ARCANE_UNUSED(value);
}
 
static void
_checkPhysicalConvert(IPhysicalUnitConverter* converter, Real& value)
{
  if (converter) {
    Real new_value = converter->convert(value);
    value = new_value;
  }
}
 
static void
_checkPhysicalConvert(IPhysicalUnitConverter* converter, RealUniqueArray& values)
{
  if (converter) {
    //TODO use local array to avoid allocation
    RealUniqueArray input_values(values);
    converter->convert(input_values, values);
  }
}
 
template <typename DataType> static bool
_allowConvert(const DataType& value)
{
  ARCANE_UNUSED(value);
  return false;
}
 
static bool
_allowConvert(const Real& value)
{
  ARCANE_UNUSED(value);
  return true;
}
 
static bool
_allowConvert(const RealUniqueArray& value)
{
  ARCANE_UNUSED(value);
  return true;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> CaseOptionSimpleT<T>::
CaseOptionSimpleT(const CaseOptionBuildInfo& cob)
: CaseOptionSimple(cob)
{
  _copyCaseOptionValue(m_value, Type());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> CaseOptionSimpleT<T>::
CaseOptionSimpleT(const CaseOptionBuildInfo& cob, const String& physical_unit)
: CaseOptionSimple(cob, physical_unit)
{
  _copyCaseOptionValue(m_value, Type());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> bool CaseOptionSimpleT<T>::
_allowPhysicalUnit()
{
  using Type = typename CaseOptionTraitsT<T>::ContainerType;
  return _allowConvert(Type());
}
 
namespace
{
  // This class aims to remove whitespace at the beginning and end of
  // a string unless the Type is a 'String'.
  // If the expected type is not a 'String', we consider that leading and trailing whitespace
  // is not significant.
  template <typename Type>
  class StringCollapser
  {
   public:
 
    static String collapse(const String& str)
    {
      return String::collapseWhiteSpace(str);
    }
  };
  template <>
  class StringCollapser<String>
  {
   public:
 
    static String collapse(const String& str)
    {
      return str;
    }
  };
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename T> void CaseOptionSimpleT<T>::
_search(bool is_phase1)
{
  CaseOptionSimple::_search(is_phase1);
  if (!is_phase1)
    return;
  ICaseDocumentFragment* doc = caseDocumentFragment();
 
  // If the option is not present in the data set, we take
  // the default option, unless the option is optional
  String str_val = (_element().null()) ? _defaultValue() : _element().value();
  bool has_valid_value = true;
  if (str_val.null()) {
    if (!isOptional()) {
      CaseOptionError::addOptionNotFoundError(doc, A_FUNCINFO,
                                              name(), rootElement());
      return;
    }
    else
      has_valid_value = false;
  }
  _setHasValidValue(has_valid_value);
  if (has_valid_value) {
    Type val = Type();
    str_val = StringCollapser<Type>::collapse(str_val);
    bool is_bad = builtInGetValue(val, str_val);
    //cerr << "** TRY CONVERT " << str_val << ' ' << val << ' ' << is_bad << endl;
    if (is_bad) {
      CaseOptionError::addInvalidTypeError(doc, A_FUNCINFO,
                                           name(), rootElement(), str_val, typeToName(val));
      return;
    }
    _checkPhysicalConvert(physicalUnitConverter(), val);
    m_value = val;
  }
  _setIsInitialized();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void CaseOptionSimpleT<T>::
setDefaultValue(const Type& def_value)
{
  // If a value is provided by the user, we do nothing.
  if (isPresent())
    return;
 
  // Value already initialized. In this case, we also replace the current value.
  if (_isInitialized())
    m_value = def_value;
 
  String s;
  bool is_bad = builtInPutValue(def_value, s);
  if (is_bad)
    ARCANE_FATAL("Can not set default value");
  _setDefaultValue(s);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace
{
  template <typename T>
  class FunctionConverterT
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, T& value)
    {
      ARCANE_UNUSED(tbl);
      ARCANE_UNUSED(t);
      ARCANE_UNUSED(value);
      throw CaseOptionException("FunctionConverter", "Invalid type");
    }
  };
 
  template <>
  class FunctionConverterT<Real>
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, Real& value)
    {
      tbl.value(t, value);
    }
  };
 
  template <>
  class FunctionConverterT<Real3>
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, Real3& value)
    {
      tbl.value(t, value);
    }
  };
 
  template <>
  class FunctionConverterT<bool>
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, bool& value)
    {
      tbl.value(t, value);
    }
  };
 
  template <>
  class FunctionConverterT<Integer>
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, Integer& value)
    {
      tbl.value(t, value);
    }
  };
 
  template <>
  class FunctionConverterT<String>
  {
   public:
 
    void convert(ICaseFunction& tbl, Real t, String& value)
    {
      tbl.value(t, value);
    }
  };
 
  /*---------------------------------------------------------------------------*/
  /*---------------------------------------------------------------------------*/
 
  template <typename ParamType, typename ValueType>
  class ComputeFunctionValue
  {
   public:
 
    static void convert(ICaseFunction* func, ParamType t, ValueType& new_value)
    {
      FunctionConverterT<ValueType>().convert(*func, t, new_value);
    }
  };
 
} // namespace
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> typename CaseOptionSimpleT<T>::Type CaseOptionSimpleT<T>::
valueAtParameter(Real t) const
{
  ICaseFunction* func = function();
  Type new_value(m_value);
  if (func) {
    ComputeFunctionValue<Real, T>::convert(func, t, new_value);
    _checkPhysicalConvert(physicalUnitConverter(), new_value);
  }
  return new_value;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> typename CaseOptionSimpleT<T>::Type CaseOptionSimpleT<T>::
valueAtParameter(Integer t) const
{
  ICaseFunction* func = function();
  Type new_value(m_value);
  if (func) {
    ComputeFunctionValue<Integer, T>::convert(func, t, new_value);
    _checkPhysicalConvert(physicalUnitConverter(), new_value);
  }
  return new_value;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void CaseOptionSimpleT<T>::
updateFromFunction(Real current_time, Integer current_iteration)
{
  _checkIsInitialized();
  ICaseFunction* func = function();
  if (!func)
    return;
  Type new_value(m_value);
  switch (func->paramType()) {
  case ICaseFunction::ParamReal:
    ComputeFunctionValue<Real, T>::convert(func, current_time, new_value);
    break;
  case ICaseFunction::ParamInteger:
    ComputeFunctionValue<Integer, T>::convert(func, current_iteration, new_value);
    break;
  case ICaseFunction::ParamUnknown:
    break;
  }
  _checkPhysicalConvert(physicalUnitConverter(), new_value);
  this->_setChangedSinceLastIteration(m_value != new_value);
  ITraceMng* msg = caseMng()->traceMng();
  msg->debug() << "New value for option <" << name() << "> " << new_value;
  _copyCaseOptionValue(m_value, new_value);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void CaseOptionSimpleT<T>::
print(const String& lang, std::ostream& o) const
{
  ARCANE_UNUSED(lang);
  _checkIsInitialized();
  if (hasValidValue())
    o << m_value;
  else
    o << "undefined";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> CaseOptionMultiSimpleT<T>::
CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob)
: CaseOptionMultiSimple(cob)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> CaseOptionMultiSimpleT<T>::
CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob,
                       const String& /*physical_unit*/)
: CaseOptionMultiSimple(cob)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> CaseOptionMultiSimpleT<T>::
~CaseOptionMultiSimpleT()
{
  const T* avalue = m_view.data();
  delete[] avalue;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> bool CaseOptionMultiSimpleT<T>::
_allowPhysicalUnit()
{
  using Type = typename CaseOptionTraitsT<T>::ContainerType;
  return _allowConvert(Type());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename T>
void CaseOptionMultiSimpleT<T>::
_search(bool is_phase1)
{
  if (!is_phase1)
    return;
 
  const ParameterListWithCaseOption& params = caseMng()->_internalImpl()->parameters();
  const ParameterCaseOption pco{ params.getParameterCaseOption(caseDocumentFragment()->language()) };
 
  String full_xpath = String::format("{0}/{1}", rootElement().xpathFullName(), name());
  // !!! In XML, we start at 1 and not 0.
  UniqueArray<Integer> option_in_param;
  pco.indexesInParam(full_xpath, option_in_param, false);
 
  XmlNodeList elem_list = rootElement().children(name());
  Integer asize = elem_list.size();
 
  bool is_optional = isOptional();
 
  if (asize == 0 && option_in_param.empty() && is_optional) {
    return;
  }
 
  Integer min_occurs = minOccurs();
  Integer max_occurs = maxOccurs();
 
  Integer max_in_param = 0;
 
  if (!option_in_param.empty()) {
    max_in_param = option_in_param[0];
    for (Integer index : option_in_param) {
      if (index > max_in_param)
        max_in_param = index;
    }
    if (max_occurs >= 0) {
      if (max_in_param > max_occurs) {
        StringBuilder msg = "Bad number of occurences in command line (greater than max)";
        msg += " index_max_in_param=";
        msg += max_in_param;
        msg += " max_occur=";
        msg += max_occurs;
        msg += " option=";
        msg += full_xpath;
        throw CaseOptionException(A_FUNCINFO, msg.toString(), true);
      }
    }
  }
 
  if (max_occurs >= 0) {
    if (asize > max_occurs) {
      StringBuilder msg = "Bad number of occurences (greater than max)";
      msg += " nb_occur=";
      msg += asize;
      msg += " max_occur=";
      msg += max_occurs;
      msg += " option=";
      msg += full_xpath;
      throw CaseOptionException(A_FUNCINFO, msg.toString(), true);
    }
  }
  // There will always be at least min_occurs options.
  // If there are not enough options in the dataset and in the command line parameters, we add default values (if there is no default, there will be a crash).
  Integer final_size = std::max(asize, std::max(min_occurs, max_in_param));
 
  const Type* old_value = m_view.data();
  delete[] old_value;
  using Type = typename CaseOptionTraitsT<T>::ContainerType;
  Type* ptr_value = new Type[final_size];
  m_view = ArrayViewType(final_size, ptr_value);
  this->_setArray(ptr_value, final_size);
 
  // First, we will have the dataset options: since we cannot define an index
  // for options in the dataset, they will necessarily be at the beginning and will be contiguous.
  // Then, if options are missing to reach min_occurs, we add default options.
  // If there is no default option, there will be an exception.
  // Finally, the user may have added options from the command line. We add them then.
  // If the user wants to modify dataset values from the command line, we
  // replace the options as we read them.
  for (Integer i = 0; i < final_size; ++i) {
    String str_val;
 
    // Command line parameters part.
    if (option_in_param.contains(i + 1)) {
      str_val = pco.getParameterOrNull(full_xpath, i + 1, false);
    }
 
    // Dataset part.
    else if (i < asize) {
      XmlNode velem = elem_list[i];
      if (!velem.null()) {
        str_val = velem.value();
      }
    }
 
    // Default value.
    if (str_val.null()) {
      str_val = _defaultValue();
    }
    else {
      // In an else: Symbol replacement does not apply to default values in the .axl.
      str_val = StringVariableReplace::replaceWithCmdLineArgs(params, str_val, true);
    }
 
    // Now, this crash also concerns the case where there are no default values and there
    // are not enough options to reach min_occurs.
    if (str_val.null())
      CaseOptionError::addOptionNotFoundError(caseDocumentFragment(), A_FUNCINFO,
                                              name(), rootElement());
    Type val = Type();
    str_val = StringCollapser<Type>::collapse(str_val);
    bool is_bad = builtInGetValue(val, str_val);
    if (is_bad)
      CaseOptionError::addInvalidTypeError(caseDocumentFragment(), A_FUNCINFO,
                                           name(), rootElement(), str_val, typeToName(val));
    //throw CaseOptionException("get_value",name(),rootElement(),str_val,typeToName(val));
    //ptr_value[i] = val;
    _copyCaseOptionValue(ptr_value[i], val);
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void CaseOptionMultiSimpleT<T>::
print(const String& lang, std::ostream& o) const
{
  ARCANE_UNUSED(lang);
  for (Integer i = 0; i < this->size(); ++i)
    o << this->_ptr()[i] << " ";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename T> void CaseOptionMultiSimpleT<T>::
visit(ICaseDocumentVisitor* visitor) const
{
  visitor->applyVisitor(this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionSimple::
_convertFunctionRealToString(ICaseFunction* func, Real t)
{
  String v;
  ComputeFunctionValue<Real, String>::convert(func, t, v);
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseOptionSimple::
_convertFunctionIntegerToString(ICaseFunction* func, Integer t)
{
  String v;
  ComputeFunctionValue<Integer, String>::convert(func, t, v);
  return v;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2x2>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3x3>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<bool>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int16>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int32>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int64>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<String>;
 
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<RealArray>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real2x2Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Real3x3Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<BoolArray>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int16Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int32Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<Int64Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionSimpleT<StringArray>;
 
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2x2>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3x3>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<bool>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int16>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int32>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int64>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<String>;
 
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<RealArray>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real2x2Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Real3x3Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<BoolArray>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int16Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int32Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<Int64Array>;
template class ARCANE_TEMPLATE_EXPORT CaseOptionMultiSimpleT<StringArray>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/