CaseOptionService.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* CaseOptionService.h                                         (C) 2000-2019 */
/*                                                                           */
/* Options du jeu de données utilisant un service.                           */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CASEOPTIONSERVICE_H
#define ARCANE_CASEOPTIONSERVICE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ITraceMng.h"
#include "arcane/utils/Functor.h"
 
#include "arcane/CaseOptions.h"
#include "arcane/IServiceMng.h"
#include "arcane/ISubDomain.h"
#include "arcane/ServiceUtils.h"
#include "arcane/ArcaneException.h"
#include "arcane/IFactoryService.h"
#include "arcane/IServiceFactory.h"
#include "arcane/StringDictionary.h"
#include "arcane/CaseOptionServiceImpl.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IService;
class CaseOptionBuildInfo;
template<typename T> class CaseOptionServiceT;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class CaseOptionServiceContainer
: public ICaseOptionServiceContainer
{
 public:
  ~CaseOptionServiceContainer() override
  {
    removeInstances();
  }
 
  bool tryCreateService(Integer index,Internal::IServiceFactory2* factory,const ServiceBuildInfoBase& sbi) override
  {
    auto true_factory = dynamic_cast< Internal::IServiceFactory2T<InterfaceType>* >(factory);
    if (true_factory){
      Ref<InterfaceType> sr = true_factory->createServiceReference(sbi);
      InterfaceType* s = sr.get();
      m_services_reference[index] = sr;
      m_services[index] = s;
      return (s != nullptr);
    }
    return false;
  }
 
  bool hasInterfaceImplemented(Internal::IServiceFactory2* factory) const override
  {
    auto true_factory = dynamic_cast< Internal::IServiceFactory2T<InterfaceType>* >(factory);
    if (true_factory){
      return true;
    }
    return false;
  }
 
  void allocate(Integer asize) override
  {
    m_services.resize(asize,nullptr);
    m_services_reference.resize(asize);
  }
 
  Integer nbElem() const override
  {
    return m_services.size();
  }
 
  InterfaceType* child(Integer i) const
  {
    return m_services[i];
  }
 
  Ref<InterfaceType> childRef(Integer i) const
  {
    return m_services_reference[i];
  }
 
 public:
  void removeInstances()
  {
    m_services_reference.clear();
    m_services.clear();
  }
 public:
  ArrayView<InterfaceType*> view() { return m_services; }
 private:
  UniqueArray<InterfaceType*> m_services;
  UniqueArray<Ref<InterfaceType>> m_services_reference;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT CaseOptionService
{
 public:
 
 CaseOptionService(const CaseOptionBuildInfo& cob,bool allow_null,bool is_optional)
  : m_impl(new CaseOptionServiceImpl(cob,allow_null,is_optional))
  {
  }
 
  virtual ~CaseOptionService() = default;
 
 public:
 
  CaseOptionService(const CaseOptionService&) = delete;
  const CaseOptionService& operator=(const CaseOptionService&) = delete;
 
 public:
 
  ARCANE_DEPRECATED_REASON("Y2022: Use toICaseOptions() instead")
  operator CaseOptions& () { return *_impl(); }
 
  ARCANE_DEPRECATED_REASON("Y2022: Use toICaseOptions() instead")
  operator const CaseOptions& () const { return *_impl(); }
 
 public:
 
   const ICaseOptions* toICaseOptions() { return _impl(); }
 
 public:
 
  String rootTagName() const { return m_impl->rootTagName(); }
  String name() const { return m_impl->name(); }
  String serviceName() const { return m_impl->serviceName(); }
  bool isOptional() const { return m_impl->isOptional(); }
  bool isPresent() const { return m_impl->isPresent(); }
  void addAlternativeNodeName(const String& lang,const String& name)
  {
    m_impl->addAlternativeNodeName(lang,name);
  }
  void getAvailableNames(StringArray& names) const
  {
    m_impl->getAvailableNames(names);
  }
  void setDefaultValue(const String& def_value)
  {
    m_impl->setDefaultValue(def_value);
  }
  void addDefaultValue(const String& category,const String& value)
  {
    m_impl->addDefaultValue(category,value);
  }
  void setMeshName(const String& mesh_name);
 
  String meshName() const;
 
 protected:
 
  CaseOptionServiceImpl* _impl() { return m_impl.get(); }
  const CaseOptionServiceImpl* _impl() const { return m_impl.get(); }
 
 private:
 
  ReferenceCounter<CaseOptionServiceImpl> m_impl;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<class InterfaceType>
class CaseOptionServiceT
: public CaseOptionService
{
 public:
  CaseOptionServiceT(const CaseOptionBuildInfo& cob,bool allow_null,bool is_optional)
  : CaseOptionService(cob,allow_null,is_optional)
  {
    _impl()->setContainer(&m_container);
  }
  ~CaseOptionServiceT() = default;
 public:
  InterfaceType* operator()() const { return _instance(); }
  InterfaceType* instance() const { return _instance(); }
  Ref<InterfaceType> instanceRef() const { return _instanceRef(); }
 private:
  CaseOptionServiceContainer<InterfaceType> m_container;
 private:
  InterfaceType* _instance() const
  {
    if (m_container.nbElem()==1)
      return m_container.child(0);
    return nullptr;
  }
  Ref<InterfaceType> _instanceRef() const
  {
    if (m_container.nbElem()==1)
      return m_container.childRef(0);
    return {};
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT CaseOptionMultiService
{
 public:
  CaseOptionMultiService(const CaseOptionBuildInfo& cob,bool allow_null)
  : m_impl(new CaseOptionMultiServiceImpl(cob,allow_null))
  {
  }
  virtual ~CaseOptionMultiService() = default;
  CaseOptionMultiService(const CaseOptionMultiService&) = delete;
  const CaseOptionMultiService& operator=(const CaseOptionMultiService&) = delete;
 public:
  XmlNode rootElement() const { return m_impl->toCaseOptions()->configList()->rootElement(); }
  String rootTagName() const { return m_impl->rootTagName(); }
  String name() const { return m_impl->name(); }
  void getAvailableNames(StringArray& names) const
  {
    m_impl->getAvailableNames(names);
  }
  String serviceName(Integer index) const 
  {
    return m_impl->serviceName(index);
  }
  void addAlternativeNodeName(const String& lang,const String& name)
  {
    m_impl->addAlternativeNodeName(lang,name);
  }
  void setMeshName(const String& mesh_name);
 
  String meshName() const;
 
 protected:
 
  CaseOptionMultiServiceImpl* _impl() { return m_impl.get(); }
  const CaseOptionMultiServiceImpl* _impl() const { return m_impl.get(); }
 
 private:
 
  ReferenceCounter<CaseOptionMultiServiceImpl> m_impl;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class CaseOptionMultiServiceT
: public CaseOptionMultiService
, public ArrayView<InterfaceType*>
{
  typedef CaseOptionMultiServiceT<InterfaceType> ThatClass;
 public:
  CaseOptionMultiServiceT(const CaseOptionBuildInfo& cob,bool allow_null)
  : CaseOptionMultiService(cob,allow_null)
  , m_notify_functor(this,&ThatClass::_notify)
  {
    _impl()->setContainer(&m_container);
    _impl()->_setNotifyAllocateFunctor(&m_notify_functor);
  }
 public:
  CaseOptionMultiServiceT<InterfaceType>& operator()()
  {
    return *this;
  }
  const CaseOptionMultiServiceT<InterfaceType>& operator()() const
  {
    return *this;
  }
 protected:
  // Notification par l'implémentation
  void _notify()
  {
    this->setArray(m_container.view());
  }
 private:
  CaseOptionServiceContainer<InterfaceType> m_container;
  FunctorT<ThatClass> m_notify_functor;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif