CaseOptionSimple.h

// -*- 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.h                                          (C) 2000-2025 */
/*                                                                           */
/* Simple data set option.                                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CASEOPTIONSIMPLE_H
#define ARCANE_CASEOPTIONSIMPLE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ICaseOptions.h"
#include "arcane/core/CaseOptionBase.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
class IStandardFunction;
class IPhysicalUnitConverter;
class StringDictionary;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifdef ARCANE_CHECK
#define ARCANE_CASEOPTION_CHECK_IS_INITIALIZED _checkIsInitialized()
#else
#define ARCANE_CASEOPTION_CHECK_IS_INITIALIZED
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename Type>
class CaseOptionTraitsT
{
 public:
 
  using ContainerType = Type;
  using ReferenceType = Type&;
  using ConstReferenceType = const Type&;
  using ArrayViewType = ArrayView<Type>;
  using ConstArrayViewType = ConstArrayView<Type>;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename Type>
class CaseOptionTraitsT<Array<Type>>
{
 public:
 
  using ContainerType = UniqueArray<Type>;
  using ReferenceType = const Array<Type>&;
  using ConstReferenceType = const Array<Type>&;
  using ArrayViewType = ConstArrayView<ContainerType>;
  using ConstArrayViewType = ConstArrayView<ContainerType>;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT CaseOptionSimple
: public CaseOptionBase
{
 public:
 
  explicit CaseOptionSimple(const CaseOptionBuildInfo& cob);
  CaseOptionSimple(const CaseOptionBuildInfo& cob, const String& physical_unit);
  ~CaseOptionSimple();
 
 public:

  bool isPresent() const { return !m_element.null(); }

  ARCANE_DEPRECATED_LONG_TERM("Y2022: Do not access XML item from option")
  XmlNode element() const { return m_element; }

  ICaseFunction* function() const override { return m_function; }
  virtual IStandardFunction* standardFunction() const { return m_standard_function; }
  bool hasChangedSinceLastIteration() const;
  String xpathFullName() const;
  String defaultPhysicalUnit() const;
  String physicalUnit() const;
  IPhysicalUnitConverter* physicalUnitConverter() const { return m_unit_converter; }
  bool isOptional() const { return m_is_optional; }

  bool hasValidValue() const { return m_has_valid_value; }
 
  void visit(ICaseDocumentVisitor* visitor) const override;
 
 protected:
 
  void _search(bool is_phase1) override;
  virtual bool _allowPhysicalUnit() = 0;
  void _setChangedSinceLastIteration(bool has_changed);
  void _searchFunction(XmlNode& velem);
  void _setPhysicalUnit(const String& value);
  void _setHasValidValue(bool v) { m_has_valid_value = v; }
  XmlNode _element() const { return m_element; }
 
  static String _convertFunctionRealToString(ICaseFunction* func, Real t);
  static String _convertFunctionIntegerToString(ICaseFunction* func, Integer t);
 
 private:
 
  XmlNode m_element; 
  ICaseFunction* m_function = nullptr; 
  IStandardFunction* m_standard_function = nullptr; 
  IPhysicalUnitConverter* m_unit_converter = nullptr;
  bool m_changed_since_last_iteration = false;
  bool m_is_optional = false;
  bool m_has_valid_value = false;
  String m_default_physical_unit;
  String m_physical_unit;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <class T>
class CaseOptionSimpleT
: public CaseOptionSimple
{
 public:
 
  typedef CaseOptionSimpleT<T> ThatClass;
#ifndef SWIG
  typedef typename CaseOptionTraitsT<T>::ContainerType Type; 
#else
  typedef T Type; 
#endif
 public:
 
  ARCANE_CORE_EXPORT CaseOptionSimpleT(const CaseOptionBuildInfo& cob);
  ARCANE_CORE_EXPORT CaseOptionSimpleT(const CaseOptionBuildInfo& cob, const String& physical_unit);
 
 public:
 
  ARCANE_CORE_EXPORT virtual void print(const String& lang, std::ostream& o) const;

  const Type& value() const
  {
    ARCANE_CASEOPTION_CHECK_IS_INITIALIZED;
    return m_value;
  }

  operator const Type&() const { return value(); }

  ARCANE_CORE_EXPORT Type valueAtParameter(Real t) const;

  ARCANE_CORE_EXPORT Type valueAtParameter(Integer t) const;

  //const Type& operator()() const { return value(); }
  const Type& operator()() const { return value(); }
 
#ifdef ARCANE_DOTNET
  operator ThatClass*() { return this; }
  operator const ThatClass*() const { return this; }
  const ThatClass* operator->() const { return this; }
  static Real castTo__Arcane_Real(const ThatClass& v)
  {
    return (Real)(v);
  }
#endif

  ARCANE_DEPRECATED Type operator()(Real t) const
  {
    return valueAtParameter(t);
  }

  ARCANE_DEPRECATED Type operator()(Integer t) const
  {
    return valueAtParameter(t);
  }

  ARCANE_CORE_EXPORT virtual void updateFromFunction(Real current_time, Integer current_iteration);

  ARCANE_CORE_EXPORT void setDefaultValue(const Type& def_value);

  const Type& valueIfPresentOrArgument(const Type& arg_value)
  {
    ARCANE_CASEOPTION_CHECK_IS_INITIALIZED;
    return isPresent() ? m_value : arg_value;
  }
 
 protected:
 
  ARCANE_CORE_EXPORT virtual void _search(bool is_phase1);
  ARCANE_CORE_EXPORT virtual bool _allowPhysicalUnit();
 
 private:
 
  Type m_value; 
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_CORE_EXPORT CaseOptionMultiSimple
: public CaseOptionBase
{
 public:
 
  CaseOptionMultiSimple(const CaseOptionBuildInfo& cob)
  : CaseOptionBase(cob)
  {}
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

#ifndef SWIG
template <class T>
class CaseOptionMultiSimpleT
: public CaseOptionMultiSimple
#ifdef ARCANE_HAS_PRIVATE_CASEOPTIONSMULTISIMPLE_BASE_CLASS
, private ArrayView<T>
#else
, public ArrayView<T>
#endif
{
 public:

  using Type = typename CaseOptionTraitsT<T>::ContainerType;
  using ReferenceType = typename CaseOptionTraitsT<T>::ReferenceType;
  using ConstReferenceType = typename CaseOptionTraitsT<T>::ConstReferenceType;
  using ArrayViewType = typename CaseOptionTraitsT<T>::ArrayViewType;
  using ConstArrayViewType = typename CaseOptionTraitsT<T>::ConstArrayViewType;
 
 public:
 
  ARCANE_CORE_EXPORT CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob);
  ARCANE_CORE_EXPORT CaseOptionMultiSimpleT(const CaseOptionBuildInfo& cob, const String& physical_unit);
  ARCANE_CORE_EXPORT ~CaseOptionMultiSimpleT();
 
 public:
 
  ARCCORE_DEPRECATED_2021("Use view() instead")
  ArrayView<T> operator()()
  {
    return *this;
  }
  ARCCORE_DEPRECATED_2021("Use view() instead")
  const ArrayView<T> operator()() const
  {
    return *this;
  }

  ARCCORE_DEPRECATED_2021("Use view() instead")
  operator ArrayView<T>()
  {
    ArrayView<T>* v = this;
    return *v;
  }

  ARCCORE_DEPRECATED_2021("Use view() instead")
  operator ConstArrayView<T>() const
  {
    const ArrayView<T>* v = this;
    return *v;
  }

  ConstArrayViewType view() const
  {
    return m_view;
  }

  ArrayViewType view()
  {
    return m_view;
  }
 
  ConstReferenceType operator[](Integer i) const { return m_view[i]; }
  ReferenceType operator[](Integer i) { return m_view[i]; }
 
 public:
 
  ARCANE_CORE_EXPORT void print(const String& lang, std::ostream& o) const override;
  ICaseFunction* function() const override { return 0; }
  void updateFromFunction(Real, Integer) override {}
 
  ConstArrayView<T> values() const
  {
    const ArrayView<T>* v = this;
    return *v;
  }
  const T& value(Integer index) const { return this->operator[](index); }
  Integer size() const { return ArrayView<T>::size(); }
  ARCANE_CORE_EXPORT void visit(ICaseDocumentVisitor* visitor) const override;
  bool isPresent() const { return !m_view.empty(); }
 
 protected:
 
  void _search(bool is_phase1) override;
  virtual bool _allowPhysicalUnit();
 
 private:
 
  ArrayViewType m_view;
};
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef CaseOptionSimpleT<Real> CaseOptionReal;
typedef CaseOptionSimpleT<Real2> CaseOptionReal2;
typedef CaseOptionSimpleT<Real3> CaseOptionReal3;
typedef CaseOptionSimpleT<Real2x2> CaseOptionReal2x2;
typedef CaseOptionSimpleT<Real3x3> CaseOptionReal3x3;
typedef CaseOptionSimpleT<bool> CaseOptionBool;
typedef CaseOptionSimpleT<Integer> CaseOptionInteger;
typedef CaseOptionSimpleT<Int32> CaseOptionInt32;
typedef CaseOptionSimpleT<Int64> CaseOptionInt64;
typedef CaseOptionSimpleT<String> CaseOptionString;
 
typedef CaseOptionSimpleT<RealArray> CaseOptionRealArray;
typedef CaseOptionSimpleT<Real2Array> CaseOptionReal2Array;
typedef CaseOptionSimpleT<Real3Array> CaseOptionReal3Array;
typedef CaseOptionSimpleT<Real2x2Array> CaseOptionReal2x2Array;
typedef CaseOptionSimpleT<Real3x3Array> CaseOptionReal3x3Array;
typedef CaseOptionSimpleT<BoolArray> CaseOptionBoolArray;
typedef CaseOptionSimpleT<IntegerArray> CaseOptionIntegerArray;
typedef CaseOptionSimpleT<Int32Array> CaseOptionInt32Array;
typedef CaseOptionSimpleT<Int64Array> CaseOptionInt64Array;
typedef CaseOptionSimpleT<StringArray> CaseOptionStringArray;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif