CaseDocumentLangTranslator.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CaseDocumentLangTranslator.cc                               (C) 2000-2022 */
/*                                                                           */
/* Class managing the translation of a dataset into another language.        */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Collection.h"
#include "arcane/utils/Enumerator.h"
#include "arcane/utils/OStringStream.h"
#include "arcane/utils/ArgumentException.h"
#include "arcane/utils/ScopedPtr.h"
 
#include "arcane/impl/CaseDocumentLangTranslator.h"
 
#include "arcane/core/AbstractCaseDocumentVisitor.h"
#include "arcane/core/CaseOptions.h"
#include "arcane/core/CaseOptionService.h"
#include "arcane/core/ICaseMng.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/CaseNodeNames.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class CaseDocumentLangTranslatorVisitor
: public AbstractCaseDocumentVisitor
, public TraceAccessor
{
 public:
 
  CaseDocumentLangTranslatorVisitor(ITraceMng* tm, const String& new_lang)
  : TraceAccessor(tm)
  {
    m_new_lang = new_lang;
  }
 
 public:
 
  void beginVisit(const ICaseOptions* opt) override
  {
    info() << "BeginOpt " << _getName(opt) << " {";
  }
  void endVisit(const ICaseOptions* opt) override
  {
    info() << "EndOptList " << opt->rootTagName() << " }";
  }
  void applyVisitor(const CaseOptionSimple* opt) override
  {
    info() << "SimpleOpt " << _getName(opt);
  }
  void applyVisitor(const CaseOptionMultiSimple* opt) override
  {
    info() << "MultiSimple " << _getName(opt);
  }
  void applyVisitor(const CaseOptionMultiExtended* opt) override
  {
    info() << "MultiExtended " << _getName(opt);
  }
  void applyVisitor(const CaseOptionExtended* opt) override
  {
    info() << "Extended " << _getName(opt);
  }
  void applyVisitor(const CaseOptionMultiEnum* opt) override
  {
    info() << "MultiEnum " << _getName(opt);
    info() << "WARNING: MultiEnum not handled in translator";
  }
  void applyVisitor(const CaseOptionEnum* opt) override
  {
    info() << "Enum " << _getName(opt);
    _manageEnum(opt);
  }
  void beginVisit(const CaseOptionServiceImpl* opt) override
  {
    info() << "BeginService " << _getName(opt);
  }
  void endVisit(const CaseOptionServiceImpl* opt) override
  {
    info() << "EndService " << _getName(opt);
  }
  void beginVisit(const CaseOptionMultiServiceImpl* opt, Integer index) override
  {
    info() << "BeginMultiService " << _getName(opt) << " index=" << index;
  }
  void endVisit(const CaseOptionMultiServiceImpl* opt, Integer index) override
  {
    info() << "EndMultiService " << _getName(opt) << " index=" << index;
  }
  String _getName(const CaseOptionBase* opt)
  {
    String full_xpath = opt->rootElement().xpathFullName();
    String name = opt->name();
    String new_name = opt->translatedName(m_new_lang);
 
    if (name != new_name)
      m_stream() << full_xpath << "/" << name << ":" << new_name << '\n';
    return name;
  }
  String _getName(const ICaseOptions* opt)
  {
    String full_xpath = opt->configList()->rootElement().xpathFullName();
    String name = opt->rootTagName();
    String new_name = opt->translatedName(m_new_lang);
 
    if (name != new_name)
      m_stream() << full_xpath << ":" << new_name << '\n';
    return name;
  }
  void _manageEnum(const CaseOptionEnum* opt)
  {
    // Nothing to convert if no element is associated with the option
    // or if the value is invalid.
    if (!opt->isPresent())
      return;
    if (!opt->hasValidValue())
      return;
 
    int v = opt->enumValueAsInt();
    String new_name = opt->enumValues()->nameOfValue(v, m_new_lang);
    m_stream() << opt->xpathFullName() << ":text#" << new_name << '\n';
  }
 
 public:
 
  void printAll()
  {
    info() << "ALL: " << m_stream.str();
  }
 
 public:
 
  String convertString() { return m_stream.str(); }
 
 private:
 
  OStringStream m_stream;
  String m_new_lang;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseDocumentLangTranslator::
CaseDocumentLangTranslator(ITraceMng* tm)
: TraceAccessor(tm)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
CaseDocumentLangTranslator::
~CaseDocumentLangTranslator()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseDocumentLangTranslator::
build()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String CaseDocumentLangTranslator::
translate(ICaseMng* cm, const String& new_lang)
{
  if (new_lang.null())
    throw ArgumentException(A_FUNCINFO, "Invalid value for langage");
  CaseDocumentLangTranslatorVisitor my_visitor(traceMng(), new_lang);
  CaseOptionsCollection opts = cm->blocks();
  for (CaseOptionsCollection::Enumerator i(opts); ++i;) {
    ICaseOptions* o = *i;
    info() << " OptName=" << o->rootTagName();
    o->visit(&my_visitor);
  }
  my_visitor.printAll();
 
  ICaseDocument* cd = cm->caseDocument();
  CaseNodeNames* current_cnn = cd->caseNodeNames();
  ScopedPtrT<CaseNodeNames> cnn{ new CaseNodeNames(new_lang) };
 
  // NOTE: These conversions depend on CaseDocument and must be
  // updated if the latter changes (as well as CaseNodeNames)
 
  _addConvert(cd->fragment()->rootElement(), cnn->root);
  _addConvert(cd->timeloopElement(), cnn->timeloop);
  _addConvert(cd->titleElement(), cnn->title);
  _addConvert(cd->descriptionElement(), cnn->description);
  _addConvert(cd->modulesElement(), cnn->modules);
 
  String slash = "/";
  const XmlNodeList& mesh_elems = cd->meshElements();
  for (Integer i = 0, n = mesh_elems.size(); i < n; ++i) {
    XmlNode xnode(mesh_elems.node(i));
    _addConvert(xnode, cnn->mesh);
    _addConvert(xnode.child(current_cnn->mesh_file), cnn->mesh_file);
  }
 
  _addConvert(cd->functionsElement(), cnn->functions);
 
  // TODO: Handle TiedInterface + CaseFunctions + following Attributes:
  // TODO: Use JSON format to output conversion information.
 
  /*m_user_class = m_root_elem.attrValue(cnn->user_class);
  m_code_name = m_root_elem.attrValue(cnn->code_name);
  m_code_version = m_root_elem.attrValue(cnn->code_version);
  m_code_unit_system = m_root_elem.attrValue(cnn->code_unit);*/
 
  return my_visitor.convertString() + m_global_convert_string;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void CaseDocumentLangTranslator::
_addConvert(XmlNode node, const String& new_name)
{
  if (!node.null())
    m_global_convert_string = m_global_convert_string + node.xpathFullName() + ":" + new_name + "\n";
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/