ArcaneCaseMeshService_axl.h

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// #WARNING#: This file has been generated automatically. Do not edit.
// Axlstar version 1.0
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifndef ARCANE_CASEOPTION_AXLSTAR_ARCANECASEMESHSERVICE_H
#define ARCANE_CASEOPTION_AXLSTAR_ARCANECASEMESHSERVICE_H
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/String.h"
 
#include "arcane/CaseOptions.h"
#include "arcane/CaseOptionsMulti.h"
#include "arcane/CaseOptionBuildInfo.h"
#include "arcane/XmlNodeList.h"
#include "arcane/CaseOptionService.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class CaseOptionsArcaneCaseMeshService
{
public:
 
  /*-------------------------------------------------------------------------*/
  /*--------------------------- Complex Options -----------------------------*/
  /*-------------------------------------------------------------------------*/
  // Generation for option 'variable'
      // Generating multiple arity CaseOption for complex option value 'variable'
  class CaseOptionInitVariableValue
  : public Arcane::CaseOptionComplexValue
  {
  public:
 
    typedef CaseOptionInitVariableValue ThatClass;
 
    CaseOptionInitVariableValue(Arcane::ICaseOptionsMulti* opt,Arcane::ICaseOptionList* icl, const Arcane::XmlNode& element)
    : Arcane::CaseOptionComplexValue(opt,icl,element)
      , name(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "name", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
      , value(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "value", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
      , group(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "group", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
 
    {
 
 
    }
 public:
  // Interfaces for multi-arity class CaseOptionsInitVariable
  
    Arcane::String getName() { return name(); }
   Arcane::ICaseFunction* getNameFunction() { return name.function(); }
   Arcane::IStandardFunction* getNameStandardFunction() { return name.standardFunction(); }
    Arcane::String getValue() { return value(); }
   Arcane::ICaseFunction* getValueFunction() { return value.function(); }
   Arcane::IStandardFunction* getValueStandardFunction() { return value.standardFunction(); }
    Arcane::String getGroup() { return group(); }
   Arcane::ICaseFunction* getGroupFunction() { return group.function(); }
   Arcane::IStandardFunction* getGroupStandardFunction() { return group.standardFunction(); }
 
 
 
   // Interfaces for complex options
  
  
  public:
 
    const ThatClass* operator->() const { return this; }
 
  public:
   
  Arcane::CaseOptionString    name;
  Arcane::CaseOptionString    value;
  Arcane::CaseOptionString    group;
  };
 
  // Generation for sub-option 'variable'
  class CaseOptionInitVariable
    : public Arcane::CaseOptionsMulti
    , private Arcane::ArrayView< CaseOptionInitVariableValue * >       
  {
  public:
 
    typedef Arcane::ArrayView< CaseOptionInitVariableValue * > BaseClass;
 
    typedef CaseOptionInitVariableValue value_type;
 
  public:
 
    CaseOptionInitVariable(Arcane::ICaseOptionList* icl,
              const Arcane::String& s, const Arcane::XmlNode& element)
      : Arcane::CaseOptionsMulti(icl,s,element,0,-1) 
    {
    // Generating translations and default values.
        }
 
    BaseClass operator()() { return (*this); }
 
  protected:
    void multiAllocate(const Arcane::XmlNodeList& elist)
    {
      Arcane::Integer s = elist.size();
      value_type** v = 0;
      if (s!=0)
        v = new value_type*[s];
      _setArray(v,s);
      v = _ptr();
      for( Arcane::Integer i=0; i<s; ++i ){
        v[i] = new value_type(this,configList(),elist[i]);
      }
    }
 
  public:
 
    ~CaseOptionInitVariable()
    {
      Arcane::Integer s = count();
      if (s==0) return;
      value_type** v = _ptr();
      for( Arcane::Integer i=0; i<s; ++i ){
        delete v[i];
      }
      delete[] v;
    }
 
  public:
 
    const value_type& operator[](Arcane::Integer i) const
      { return *(BaseClass::operator[](i)); }
    value_type& operator[](Arcane::Integer i)
      { return *(BaseClass::operator[](i)); }
    Arcane::Integer count() const
      { return BaseClass::size(); }
    Arcane::Integer size() const
      { return BaseClass::size(); }
 
  };
  
  // Generation for option 'initialization'
      // Generating simple arity CaseOption for option 'initialization'
  class CaseOptionInit
    : public Arcane::CaseOptions
  {
  public:
 
    CaseOptionInit(Arcane::ICaseOptionList* icl,
              const Arcane::String& s, const Arcane::XmlNode& element, bool is_optional=false)
      : Arcane::CaseOptions(icl,s,element,is_optional)
      , variable(_configList(),
        /* name       */ "variable", _element())
    {
 
    }
        
    const CaseOptionInit& operator()() const { return *this; }
 
 public:
  // Interfaces for simple arity CaseOptions
  
 
 
 
   // Interfaces for complex options
  
  
  private:
    // Méthodes pour unifier la construction des options.
    Arcane::ICaseOptionList* _configList() { return configList(); }
    Arcane::XmlNode _element() { return Arcane::XmlNode(); }
 
  public:
  
  CaseOptionInitVariable   variable;
 
  };
 
  /*-------------------------------------------------------------------------*/
  /*--------------------------- Non Complex Options -------------------------*/
  /*-------------------------------------------------------------------------*/
  
  CaseOptionsArcaneCaseMeshService(Arcane::ICaseOptions* co)
    : m_case_options(co)
      , filename(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "filename", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ true))
      , partitioner(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "partitioner", _element(),
        /* default    */ "DefaultPartitioner",
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
      , nbGhostLayer(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "nb-ghost-layer", _element(),
        /* default    */ "1",
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
      , ghostLayerBuilderVersion(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "ghost-layer-builder-version", _element(),
        /* default    */ "3",
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false))
      , faceNumberingVersion(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "face-numbering-version", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ true))
      , generator(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "generator", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ true),
        /* allow-null */ false,
        /* optional   */ true)
      , specificReader(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "specific-reader", _element(),
        /* default    */ Arcane::String(),
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ true),
        /* allow-null */ false,
        /* optional   */ true)
      , subdivider(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "subdivider", _element(),
        /* default    */ "ArcaneBasicMeshSubdivider",
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ true),
        /* allow-null */ false,
        /* optional   */ true)
     , cellDimensionKind(Arcane::CaseOptionBuildInfo(_configList(),
        /* name       */ "cell-dimension-kind", _element(),
        /* default    */ "mono-dimension",
        /* min-occurs */ 1,
        /* max-occurs */ 1,
        /* optional   */ false),
        /* type       */ "Arcane::eMeshCellDimensionKind")
      , initialization(_configList(),
        /* name       */ "initialization", _element())
  {
 
      {
        auto x = new Arcane::CaseOptionEnumValue(
          /* enum value name */ Arcane::String("mono-dimension"),
          /* enum object     */ (int)(Arcane::eMeshCellDimensionKind::MonoDimension));
        cellDimensionKind.addEnumValue(x,false);
      }
      {
        auto x = new Arcane::CaseOptionEnumValue(
          /* enum value name */ Arcane::String("multi-dimension"),
          /* enum object     */ (int)(Arcane::eMeshCellDimensionKind::MultiDimension));
        cellDimensionKind.addEnumValue(x,false);
      }
      {
        auto x = new Arcane::CaseOptionEnumValue(
          /* enum value name */ Arcane::String("non-manifold"),
          /* enum object     */ (int)(Arcane::eMeshCellDimensionKind::NonManifold));
        cellDimensionKind.addEnumValue(x,false);
      }
  }
 
public:
  // Interfaces for main CaseOptions
  
    Arcane::String getFilename() { return filename(); }
   Arcane::ICaseFunction* getFilenameFunction() { return filename.function(); }
   Arcane::IStandardFunction* getFilenameStandardFunction() { return filename.standardFunction(); }
    Arcane::String getPartitioner() { return partitioner(); }
   Arcane::ICaseFunction* getPartitionerFunction() { return partitioner.function(); }
   Arcane::IStandardFunction* getPartitionerStandardFunction() { return partitioner.standardFunction(); }
    Arcane::Int32 getNbGhostLayer() { return nbGhostLayer(); }
   Arcane::ICaseFunction* getNbGhostLayerFunction() { return nbGhostLayer.function(); }
   Arcane::IStandardFunction* getNbGhostLayerStandardFunction() { return nbGhostLayer.standardFunction(); }
    Arcane::Int32 getGhostLayerBuilderVersion() { return ghostLayerBuilderVersion(); }
   Arcane::ICaseFunction* getGhostLayerBuilderVersionFunction() { return ghostLayerBuilderVersion.function(); }
   Arcane::IStandardFunction* getGhostLayerBuilderVersionStandardFunction() { return ghostLayerBuilderVersion.standardFunction(); }
    Arcane::Int32 getFaceNumberingVersion() { return faceNumberingVersion(); }
   Arcane::ICaseFunction* getFaceNumberingVersionFunction() { return faceNumberingVersion.function(); }
   Arcane::IStandardFunction* getFaceNumberingVersionStandardFunction() { return faceNumberingVersion.standardFunction(); }
 
 
     Arcane::eMeshCellDimensionKind getCellDimensionKind() { return cellDimensionKind(); }
 
     Arcane::IMeshBuilder* getGenerator() { return generator(); }
    Arcane::ICaseMeshReader* getSpecificReader() { return specificReader(); }
    Arcane::IMeshSubdivider* getSubdivider() { return subdivider(); }
  // Interfaces for complex options
      bool hasGenerator() const
      { return generator.isPresent(); }
      bool hasFilename() const
      { return filename.isPresent(); }
      bool hasFaceNumberingVersion() const
      { return faceNumberingVersion.isPresent(); }
      bool hasSpecificReader() const
      { return specificReader.isPresent(); }
      bool hasSubdivider() const
      { return subdivider.isPresent(); }
  
  
public:
 
  Arcane::ICaseOptions* caseOptions() const 
  { 
    return m_case_options.get();
  }
  
  Arcane::ICaseOptionList* configList() const 
  {
    return m_case_options->configList(); 
  }
  
  void setCaseModule(Arcane::IModule* m) 
  { 
    m_case_options->setCaseModule(m); 
  }
  
  void setCaseServiceInfo(Arcane::IServiceInfo* si) 
  {
    m_case_options->setCaseServiceInfo(si); 
  }
  
  void addAlternativeNodeName(const Arcane::String& lang,
                              const Arcane::String& name)
  { 
    m_case_options->addAlternativeNodeName(lang,name); 
  }
 
private:
 
  Arcane::ICaseOptionList* _configList() const { return configList(); }
  Arcane::XmlNode _element() const { return Arcane::XmlNode(); }
 
private:
 
  static Arcane::ICaseOptions* _createCaseOption(Arcane::ICaseMng* cm,Arcane::ICaseOptions* co);
 
  Arcane::ReferenceCounter<Arcane::ICaseOptions> m_case_options;
 
public:
 
  
  Arcane::CaseOptionString    filename;
  Arcane::CaseOptionString    partitioner;
  Arcane::CaseOptionInt32    nbGhostLayer;
  Arcane::CaseOptionInt32    ghostLayerBuilderVersion;
  Arcane::CaseOptionInt32    faceNumberingVersion;
  Arcane::CaseOptionServiceT< Arcane::IMeshBuilder >   generator;
  Arcane::CaseOptionServiceT< Arcane::ICaseMeshReader >   specificReader;
  Arcane::CaseOptionServiceT< Arcane::IMeshSubdivider >   subdivider;
  Arcane::CaseOptionEnumT< Arcane::eMeshCellDimensionKind >   cellDimensionKind;
  CaseOptionInit   initialization;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif
 
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// #WARNING#: This file has been generated automatically. Do not edit.
// Axlstar version 1.0
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#ifndef ARCANE_MODULE_AXLSTAR_ARCANECASEMESHSERVICE_H
#define ARCANE_MODULE_AXLSTAR_ARCANECASEMESHSERVICE_H
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/VariableTypes.h"
#include "arcane/ServiceInfo.h"
#include "arcane/ISubDomain.h"
#include "arcane/ServiceBuildInfo.h"
#include "arcane/ServiceFactory.h"
#include "arcane/ServiceRegisterer.h"
#include "arcane/BasicService.h"
 
#ifndef ARCANE_HAS_SPECIFIC_BASIC_SERVICE
// Code pour les versions de Arcane avant la 3.8 qui ne possèdent pas les
// classes de base spécifiques pour les services
namespace Arcane
{
using BasicCaseOptionService = BasicService;
using BasicSubDomainService = BasicService;
using BasicMeshService = BasicService;
}
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class CaseOptionsArcaneCaseMeshService;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ArcaneArcaneCaseMeshServiceObject
  : public Arcane::AbstractService
  , public Arcane::ICaseMeshService
{
public:
  // NOTE GG: attention code dupliqué avec 'ServiceT4CaseAndStrong'. Bien reporter les modifications
  template <typename ServiceClassType> static void fillServiceInfo(Arcane::ServiceInfo* si)
  {
    si->setCaseOptionsFileName("ArcaneCaseMeshService_arcane_impl");
    si->setAxlVersion(1.0);
    si->setDefaultTagName("arcane-case-mesh-service");
    si->setAxlContent(getAxlContent());
    Arcane::ServiceAllInterfaceRegisterer<ServiceClassType>::registerToServiceInfo(si
    ,ARCANE_SERVICE_INTERFACE(Arcane::ICaseMeshService)
);
  }
  
public:

  ArcaneArcaneCaseMeshServiceObject(const Arcane::ServiceBuildInfo& sbi)
    : Arcane::AbstractService(sbi)
    , m_options(nullptr)
  {
    Arcane::ICaseOptions* co = sbi.caseOptions();
    if (co) {
      m_options = new CaseOptionsArcaneCaseMeshService(co);
    }
  
  }

  virtual ~ArcaneArcaneCaseMeshServiceObject()
  {
    delete m_options;
  }
 
 
public:

  CaseOptionsArcaneCaseMeshService* options() const { return m_options; }
 
private:
        
  CaseOptionsArcaneCaseMeshService* m_options;
      
protected:

private:
  static Arcane::FileContent getAxlContent()
 {
   const Arcane::Byte* content = (const Arcane::Byte*)"";
   Arcane::Span<const Arcane::Byte> bytes(content,0);
   int file_version = 1;
   return Arcane::FileContent(bytes,file_version,"");
 }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#define ARCANE_REGISTER_SERVICE_ARCANECASEMESHSERVICE(service_name,class_name) \
  ARCANE_REGISTER_AXL_SERVICE(class_name,Arcane::ServiceProperty(#service_name,Arcane::ST_CaseOption,\
   Arcane::SFP_None ))
  
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif