Configuration.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Configuration.cc                                            (C) 2000-2014 */
/*                                                                           */
/* Management of execution configuration options.                            */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
#include "arcane/utils/TraceAccessor.h"
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/String.h"
#include "arcane/utils/ValueConvert.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/ScopedPtr.h"
#include "arcane/utils/OStringStream.h"
 
#include "arcane/core/Configuration.h"
#include "arcane/core/XmlNode.h"
#include "arcane/core/XmlNodeList.h"
 
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IApplication;
class Configuration;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ConfigurationMng
: public TraceAccessor
, public IConfigurationMng
{
 public:
 
  ConfigurationMng(ITraceMng* tm);
  ~ConfigurationMng();
 
 public:
 
  virtual IConfiguration* defaultConfiguration() const;
  virtual IConfiguration* createConfiguration();
 
 private:
 
  Configuration* m_default_configuration;
 
 private:
 
  Configuration* _createConfiguration();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ConfigurationSection
: public IConfigurationSection
{
 public:
 
  ConfigurationSection(const Configuration* configuration, const String& base_name)
  : m_configuration(configuration)
  , m_base_name(base_name)
  {}
 
  virtual ~ConfigurationSection() {}
 
 public:
 
  virtual Int32 value(const String& name, Int32 default_value) const;
  virtual Int64 value(const String& name, Int64 default_value) const;
  virtual Real value(const String& name, Real default_value) const;
  virtual bool value(const String& name, bool default_value) const;
  virtual String value(const String& name, const String& default_value) const;
  virtual String value(const String& name, const char* default_value) const;
 
  virtual Integer valueAsInteger(const String& name, Integer default_value) const
  {
    return value(name, default_value);
  }
  virtual Int32 valueAsInt32(const String& name, Int32 default_value) const
  {
    return value(name, default_value);
  }
  virtual Int64 valueAsInt64(const String& name, Int64 default_value) const
  {
    return value(name, default_value);
  }
  virtual Real valueAsReal(const String& name, Real default_value) const
  {
    return value(name, default_value);
  }
  virtual bool valueAsBool(const String& name, bool default_value) const
  {
    return value(name, default_value);
  }
  virtual String valueAsString(const String& name, const String& default_value) const
  {
    return value(name, default_value);
  }
 
 private:
 
  const Configuration* m_configuration;
  String m_base_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Configuration
: public TraceAccessor
, public IConfiguration
{
  struct ConfigValue
  {
    ConfigValue(const String& value, Integer priority)
    : m_value(value)
    , m_priority(priority)
    {}
    const String& value() const { return m_value; }
    Integer priority() const { return m_priority; }
 
   private:
 
    String m_value;
    Integer m_priority;
  };
 
  typedef std::map<String, ConfigValue> KeyValueMap;
 
 public:
 
  Configuration(ConfigurationMng* cm, ITraceMng* tm);
 
 public:
 
  IConfigurationSection* createSection(const String& name) const override
  {
    return new ConfigurationSection(this, name);
  }
 
  IConfigurationSection* mainSection() const override { return m_main_section.get(); }
 
  void addValue(const String& name, const String& value, Integer priority) override;
  IConfiguration* clone() const override;
  void merge(const IConfiguration* c) override;
  void dump() const override;
  void dump(std::ostream& o) const override;
 
 public:
 
  template <typename T> T getValue(const String& base_name, const String& name, T default_value) const
  {
    T v = T();
    KeyValueMap::const_iterator i;
    if (base_name.null())
      i = m_values.find(name);
    else
      i = m_values.find(base_name + "." + name);
 
    if (i == m_values.end())
      return default_value;
 
    String value = i->second.value();
    if (builtInGetValue(v, value))
      throw FatalErrorException(A_FUNCINFO, String::format("Can not convert '{0}' to type '{1}'", value, _typeName((T*)0)));
 
    return v;
  }
 
 private:
 
  static const char* _typeName(Int32*) { return "Int32"; }
  static const char* _typeName(Int64*) { return "Int64"; }
  static const char* _typeName(Real*) { return "Real"; }
  static const char* _typeName(bool*) { return "bool"; }
  static const char* _typeName(String*) { return "String"; }
 
  void _checkAdd(const String& name, const String& value, Integer priority)
  {
    KeyValueMap::iterator i = m_values.find(name);
    //info() << "CHECK_ADD name=" << name << " value=" << value << " priority=" << priority;
    if (i == m_values.end()) {
      //info() << "NOT_FOUND name=" << name << " value=" << value << " priority=" << priority;
      m_values.insert(std::make_pair(name, ConfigValue(value, priority)));
    }
    else {
      Integer orig_priority = i->second.priority();
      //info() << "FOUND name=" << name << " value=" << value << " orig_priority=" << orig_priority;
      if (priority < orig_priority) {
        //info() << "REPLACING name=" << name << " value=" << value << " new_priority=" << priority;
        i->second = ConfigValue(value, priority);
      }
    }
  }
 
 private:
 
  ConfigurationMng* m_configuration_mng;
  KeyValueMap m_values;
  ScopedPtrT<IConfigurationSection> m_main_section;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Int32 ConfigurationSection::
value(const String& name, Int32 default_value) const
{
  return m_configuration->getValue(m_base_name, name, default_value);
}
 
Int64 ConfigurationSection::
value(const String& name, Int64 default_value) const
{
  return m_configuration->getValue(m_base_name, name, default_value);
}
 
Real ConfigurationSection::
value(const String& name, Real default_value) const
{
  return m_configuration->getValue(m_base_name, name, default_value);
}
 
bool ConfigurationSection::
value(const String& name, bool default_value) const
{
  return m_configuration->getValue(m_base_name, name, default_value);
}
 
String ConfigurationSection::
value(const String& name, const String& default_value) const
{
  return m_configuration->getValue(m_base_name, name, default_value);
}
 
String ConfigurationSection::
value(const String& name, const char* default_value) const
{
  return m_configuration->getValue(m_base_name, name, String(default_value));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Configuration::
Configuration(ConfigurationMng* cm, ITraceMng* tm)
: TraceAccessor(tm)
, m_configuration_mng(cm)
, m_main_section(new ConfigurationSection(this, String()))
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IConfiguration* Configuration::
clone() const
{
  Configuration* cf = new Configuration(m_configuration_mng, traceMng());
 
  for (auto& i : m_values) {
    cf->m_values.insert(std::make_pair(i.first, i.second));
  }
 
  return cf;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Configuration::
dump() const
{
  OStringStream ostr;
  dump(ostr());
  info() << ostr.str();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Configuration::
dump(std::ostream& o) const
{
  o << "Configuration:\n";
  for (auto& i : m_values) {
    String s1 = i.first;
    String s2 = i.second.value();
    o << " name=" << s1 << " value=" << s2 << " (" << i.second.priority() << ")\n";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Configuration::
merge(const IConfiguration* c)
{
  const Configuration* cc = ARCANE_CHECK_POINTER(dynamic_cast<const Configuration*>(c));
  for (auto& i : cc->m_values) {
    String s1 = i.first;
    const ConfigValue& cv = i.second;
    //String s2 = i->second.value();
    _checkAdd(s1, cv.value(), cv.priority());
    //info() << "MERGING CONFIGURATION name=" << s1 << " value=" << s2;
    //m_values[s1] = s2;
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void Configuration::
addValue(const String& name, const String& value, Integer priority)
{
  _checkAdd(name, value, priority);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ConfigurationMng::
ConfigurationMng(ITraceMng* tm)
: TraceAccessor(tm)
, m_default_configuration(0)
{
  m_default_configuration = _createConfiguration();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ConfigurationMng::
~ConfigurationMng()
{
  delete m_default_configuration;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Configuration* ConfigurationMng::
_createConfiguration()
{
  return new Configuration(this, traceMng());
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IConfiguration* ConfigurationMng::
defaultConfiguration() const
{
  return m_default_configuration;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IConfiguration* ConfigurationMng::
createConfiguration()
{
  return _createConfiguration();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
extern "C++" IConfigurationMng*
arcaneCreateConfigurationMng(ITraceMng* tm)
{
  IConfigurationMng* cm = new ConfigurationMng(tm);
  return cm;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/