ServiceFactory.h

Aller à la documentation de ce fichier.

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ServiceFactory.h                                            (C) 2000-2019 */
/*                                                                           */
/* Manufacture des services.                                                 */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_SERVICEFACTORY_H
#define ARCANE_SERVICEFACTORY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/NotSupportedException.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/ExternalRef.h"
 
#include "arcane/IApplication.h"
#include "arcane/ISession.h"
#include "arcane/ISubDomain.h"
#include "arcane/ServiceBuildInfo.h"
 
#include "arcane/IServiceFactory.h"
#include "arcane/ServiceRegisterer.h"
#include "arcane/ServiceInfo.h"
#include "arcane/IService.h"
#include "arcane/ServiceProperty.h"
#include "arcane/ServiceInstance.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Internal
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class DotNetServiceInstance
: public IServiceInstance
{
 public:
  DotNetServiceInstance(IServiceInfo* si)
  : m_service_info(si), m_handle(nullptr){}
 public:
  void addReference() override { ++m_nb_ref; }
  void removeReference() override
  {
    Int32 v = std::atomic_fetch_add(&m_nb_ref,-1);
    if (v==1)
      delete this;
  }
 public:
  IServiceInfo* serviceInfo() const override
  {
    return m_service_info;
  }
  void setDotNetHandle(ExternalRef handle) { m_handle = handle; }
  ExternalRef _internalDotNetHandle() const override { return m_handle; }
 private:
  std::atomic<Int32> m_nb_ref = 0;
  IServiceInfo* m_service_info;
  ExternalRef m_handle;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class ServiceInstanceT
: public IServiceInstanceT<InterfaceType>
{
 public:
  ServiceInstanceT(Ref<InterfaceType> i,IServiceInfo* si)
  : m_instance(i), m_service_info(si){}
 public:
  void addReference() override { ++m_nb_ref; }
  void removeReference() override
  {
    Int32 v = std::atomic_fetch_add(&m_nb_ref,-1);
    if (v==1)
      delete this;
  }
 public:
  Ref<InterfaceType> instance() override
  {
    return m_instance;
  }
  IServiceInfo* serviceInfo() const override
  {
    return m_service_info;
  }
 private:
  std::atomic<Int32> m_nb_ref = 0;
  Ref<InterfaceType> m_instance;
  IServiceInfo* m_service_info;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ServiceFactoryInfo
: public IServiceFactoryInfo
{
 public:
 
  explicit ServiceFactoryInfo(IServiceInfo* si)
  : m_service_info(si), m_is_autoload(false), m_is_singleton(false) {}
  ~ServiceFactoryInfo() override {}
 
 public:
  
  IServiceInfo* serviceInfo() const override { return m_service_info; }
 
  bool isAutoload() const override { return m_is_autoload; }
  bool isSingleton() const override { return m_is_singleton; }
 
  virtual bool isModule() const { return false; }
  virtual void initializeModuleFactory(ISubDomain*) {}
  virtual IModule* createModule(ISubDomain*,IMesh*) { return nullptr; }
 
 public:
 
  void setAutoload(bool v) { m_is_autoload = v; }
  void setSingleton(bool v) { m_is_singleton = v; }
  void initProperties(int v)
  {
    if (v & SFP_Singleton)
      setSingleton(v);
    if (v & SFP_Autoload)
      setAutoload(v);
  }
  void initProperties(){}
 
 private:
  
  IServiceInfo* m_service_info;
  bool m_is_autoload;
  bool m_is_singleton;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class IServiceInterfaceFactory
{
 public:
  virtual ~IServiceInterfaceFactory() = default;
 public:
  virtual Ref<InterfaceType> createReference(const ServiceBuildInfo& sbi) =0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class ServiceFactory2TV2
: public IServiceFactory2T<InterfaceType>
{
 public:
 
  ServiceFactory2TV2(IServiceInfo* si,IServiceInterfaceFactory<InterfaceType>* sub_factory)
  : m_service_info(si), m_sub_factory(sub_factory), m_type_flags(si->usageType())
  {
  }
 
  ~ServiceFactory2TV2() override
  {
    delete m_sub_factory;
  }
 
  ServiceInstanceRef createServiceInstance(const ServiceBuildInfoBase& sbi) override
  {
    return _create(this->createServiceReference(sbi));
  }
 
  Ref<InterfaceType> createServiceReference(const ServiceBuildInfoBase& sbi) override
  {
    if (!(m_type_flags & sbi.creationType()))
      return {};
    return _createReference(sbi);
  }
 
  IServiceInfo* serviceInfo() const override
  {
    return m_service_info;
  }
 
 protected:
 
  IServiceInfo* m_service_info;
  IServiceInterfaceFactory<InterfaceType>* m_sub_factory;
  int m_type_flags;
 
 private:
  
  InterfaceType* _createInstance(const ServiceBuildInfoBase& sbib)
  {
    InterfaceType* it = m_sub_factory->createInstance(ServiceBuildInfo(m_service_info,sbib));
    return it;
  }
 
  Ref<InterfaceType> _createReference(const ServiceBuildInfoBase& sbib)
  {
    return m_sub_factory->createReference(ServiceBuildInfo(m_service_info,sbib));
  }
 
  ServiceInstanceRef _create(Ref<InterfaceType> it)
  {
    IServiceInstance* x = (!it) ? nullptr : new ServiceInstanceT<InterfaceType>(it,m_service_info);
    return ServiceInstanceRef::createRef(x);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename ServiceType,typename InterfaceType>
class ServiceInterfaceFactory
: public IServiceInterfaceFactory<InterfaceType>
{
 public:
 
  Ref<InterfaceType> createReference(const ServiceBuildInfo& sbi) override
  {
    ServiceType* st = new ServiceType(sbi);
    st->build();
    return makeRef<InterfaceType>(st);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT IServiceInstanceAdder
{
 public:
  virtual ~IServiceInstanceAdder() = default;
  virtual void addInstance(ServiceInstanceRef instance) =0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT SingletonServiceFactoryBase
: public ISingletonServiceFactory
{
 public:
  class ServiceInstance;
 public:
  explicit SingletonServiceFactoryBase(IServiceInfo* si) : m_service_info(si){}
 public:
 
  Ref<ISingletonServiceInstance> createSingletonServiceInstance(const ServiceBuildInfoBase& sbib) override;
 
  IServiceInfo* serviceInfo() const override { return m_service_info; }
 protected:
  virtual ServiceInstanceRef _createInstance(const ServiceBuildInfoBase& sbi,IServiceInstanceAdder* instance_adder) =0;
 private:
  IServiceInfo* m_service_info;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename ServiceType,typename ... Interfaces>
class SingletonServiceFactory
: public SingletonServiceFactoryBase
{
  class Helper
  {
   public:
    Helper(ServiceType* service,IServiceInfo* si,IServiceInstanceAdder* adder)
    : m_service(service), m_service_info(si), m_adder(adder) {}
   private:
    template<typename InterfaceType> void _create()
    {
      InterfaceType* x = m_service;
      // ATTENTION: la référence suivante ne doit pas détruire 'm_service' car
      // ce dernier a déjà un ServiceReference qui a été construit lors de
      // l'appel à _createInstance().
      auto x_ref = Ref<InterfaceType>::_createNoDestroy(x);
      auto instance = new ServiceInstanceT<InterfaceType>(x_ref,m_service_info);
      // TODO: indiquer qu'il ne faut pas détruire la référence.
      auto instance_ref = ServiceInstanceRef::createRef(instance);
      m_adder->addInstance(instance_ref);
    }
    template<typename I1,typename I2,typename ... OtherInterfaces>
    void _create()
    {
      _create<I1>();
      // Applique la récursivité sur les types restants
      _create<I2,OtherInterfaces...>();
    }
   public:
    void createInterfaceInstances()
    {
      _create<Interfaces...>();
    }
   private:
    ServiceType* m_service;
    IServiceInfo* m_service_info;
    IServiceInstanceAdder* m_adder;
  };
 public:
  explicit SingletonServiceFactory(IServiceInfo* si) : SingletonServiceFactoryBase(si){}
 protected:
  ServiceInstanceRef _createInstance(const ServiceBuildInfoBase& sbib,IServiceInstanceAdder* instance_adder) override
  {
    ServiceBuildInfo sbi(serviceInfo(),sbib);
    ServiceType* st = new ServiceType(sbi);
    st->build();
    auto st_ref = makeRef(st);
    Helper ssf(st,serviceInfo(),instance_adder);
    ssf.createInterfaceInstances();
    IServiceInstance* si = new ServiceInstanceT<ServiceType>(st_ref,serviceInfo());
    return ServiceInstanceRef::createRef(si);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename InterfaceType>
class ServiceInterfaceRegisterer
{
 public:
 
  typedef InterfaceType Interface;
 
  explicit ServiceInterfaceRegisterer(const char* name)
  : m_name(name), m_namespace_name(nullptr)
  {
  }
 
  ServiceInterfaceRegisterer(const char* namespace_name,const char* name)
  : m_name(name), m_namespace_name(namespace_name)
  {
  }
 
 public:
 
  template<typename ServiceType> void
  registerToServiceInfo(ServiceInfo* si) const
  {
    IServiceInterfaceFactory<InterfaceType>* factory = new ServiceInterfaceFactory<ServiceType,InterfaceType>();
    if (m_namespace_name)
      si->addImplementedInterface(String(m_namespace_name)+String("::")+String(m_name));
    else
      si->addImplementedInterface(m_name);
    si->addFactory(new ServiceFactory2TV2<InterfaceType>(si,factory));
  }
 
 private:
 
  const char* m_name;
  const char* m_namespace_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename ServiceType>
class ServiceAllInterfaceRegisterer
{
 private:
 
  template<typename InterfaceType> static void
  _create(ServiceInfo* si,const InterfaceType& i1)
  {
    i1.template registerToServiceInfo<ServiceType>(si);
  }
  template<typename I1,typename I2,typename ... OtherInterfaces>
  static void _create(ServiceInfo* si,const I1& i1,const I2& i2,const OtherInterfaces& ... args)
  {
    _create<I1>(si,i1);
    // Applique la récursivité sur les types restants
    _create<I2,OtherInterfaces...>(si,i2,args...);
  }
 
 public:
 
  template<typename ... Interfaces> static void
  registerToServiceInfo(ServiceInfo* si, const Interfaces& ... args)
  {
    si->setSingletonFactory(new Internal::SingletonServiceFactory<ServiceType,typename Interfaces::Interface ... >(si));
    _create(si,args...);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Internal
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_SERVICE_INTERFACE(ainterface)\
  Arcane::Internal::ServiceInterfaceRegisterer< ainterface >(#ainterface)
 
#define ARCANE_SERVICE_INTERFACE_NS(ainterface_ns,ainterface) \
  Arcane::Internal::ServiceInterfaceRegisterer<ainterface_ns :: ainterface>(#ainterface_ns,#ainterface)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_SERVICE(aclass,a_service_property,...) \
namespace\
{\
  Arcane::IServiceInfo*\
  ARCANE_JOIN_WITH_LINE(arcaneCreateServiceInfo##aclass) (const Arcane::ServiceProperty& property) \
  {\
    auto* si = Arcane::Internal::ServiceInfo::create(property,__FILE__,__LINE__); \
    Arcane::Internal::ServiceAllInterfaceRegisterer<aclass> :: registerToServiceInfo(si,__VA_ARGS__); \
    return si;\
  }\
}\
Arcane::ServiceRegisterer ARCANE_EXPORT ARCANE_JOIN_WITH_LINE(globalServiceRegisterer##aclass) \
  (& ARCANE_JOIN_WITH_LINE(arcaneCreateServiceInfo##aclass),a_service_property)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_AXL_SERVICE(aclass,a_service_properties) \
namespace\
{\
  Arcane::IServiceInfo*\
  ARCANE_JOIN_WITH_LINE(arcaneCreateServiceInfo##aclass) (const Arcane::ServiceProperty& properties) \
  {\
    Arcane::ServiceInfo* si = Arcane::ServiceInfo::create(properties,__FILE__,__LINE__); \
    aclass :: fillServiceInfo< aclass >(si);                            \
    return si;\
  }\
}\
Arcane::ServiceRegisterer ARCANE_EXPORT ARCANE_JOIN_WITH_LINE(globalServiceRegisterer##aclass) \
  (& ARCANE_JOIN_WITH_LINE(arcaneCreateServiceInfo##aclass),a_service_properties)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * Les types et macros suivants sont obsolètes.
 *
 * A terme, seule la macro ARCANE_REGISTER_SERVICE sera utilisée.
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_APPLICATION_FACTORY(aclass,ainterface,aname) \
ARCANE_REGISTER_SERVICE ( aclass, Arcane::ServiceProperty(#aname,Arcane::ST_Application) ,\
                          ARCANE_SERVICE_INTERFACE(ainterface) )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_SUB_DOMAIN_FACTORY(aclass,ainterface,aname)  \
ARCANE_REGISTER_SERVICE ( aclass, Arcane::ServiceProperty(#aname,Arcane::ST_SubDomain) ,\
                          ARCANE_SERVICE_INTERFACE(ainterface) )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_SUB_DOMAIN_FACTORY4(aclass,ainterface_ns,ainterface,aname) \
ARCANE_REGISTER_SERVICE ( aclass, Arcane::ServiceProperty(#aname,Arcane::ST_SubDomain) ,\
                          ARCANE_SERVICE_INTERFACE_NS(ainterface_ns,ainterface) )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY(aclass,ainterface,aname) \
ARCANE_REGISTER_SERVICE ( aclass, Arcane::ServiceProperty(#aname,Arcane::ST_CaseOption) , \
                          ARCANE_SERVICE_INTERFACE(ainterface) )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY4(aclass,ainterface_ns,ainterface,aname) \
ARCANE_REGISTER_SERVICE ( aclass, Arcane::ServiceProperty(#aname,Arcane::ST_CaseOption) ,\
                          ARCANE_SERVICE_INTERFACE_NS(ainterface_ns,ainterface) )
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif