ServiceBuilder.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ServiceBuilder.h                                            (C) 2000-2023 */
/*                                                                           */
/* Utility class for instantiating a service.                                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_SERVICEBUILDER_H
#define ARCANE_CORE_SERVICEBUILDER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Array.h"
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/FatalErrorException.h"
#include "arcane/utils/ParallelFatalErrorException.h"
 
#include "arcane/core/ISession.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/IApplication.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/ICaseOptions.h"
#include "arcane/core/IFactoryService.h"
#include "arcane/core/ServiceFinder2.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
namespace AxlOptionsBuilder
{
  class Document;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum eServiceBuilderProperties
{
  SB_None = 0,
  SB_AllowNull = 1,
  SB_Collective = 2
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename InterfaceType>
class ServiceBuilder
{
 public:

  ServiceBuilder(ISubDomain* sd)
  : m_service_finder(sd->application(), ServiceBuildInfoBase(sd))
  {}

  ServiceBuilder(const MeshHandle& mesh_handle)
  : m_service_finder(mesh_handle.application(), ServiceBuildInfoBase(mesh_handle))
  {}

  ServiceBuilder(ISession* session)
  : m_service_finder(session->application(), ServiceBuildInfoBase(session))
  {}

  ServiceBuilder(IApplication* app)
  : m_service_finder(app, ServiceBuildInfoBase(app))
  {}

  ServiceBuilder(IApplication* app, ICaseOptions* opt)
  : m_service_finder(app, ServiceBuildInfoBase(_arcaneDeprecatedGetSubDomain(opt), opt))
  {}
 
  ~ServiceBuilder() {}
 
 public:

  Ref<InterfaceType>
  createReference(const String& name, eServiceBuilderProperties properties = SB_None)
  {
    Ref<InterfaceType> mf = m_service_finder.createReference(name);
    if (!mf) {
      if (properties & SB_AllowNull)
        return {};
      _throwFatal(name, properties);
    }
    return mf;
  }

  Ref<InterfaceType>
  createReference(const String& name, IMesh* mesh,
                  eServiceBuilderProperties properties = SB_None)
  {
    Ref<InterfaceType> mf = m_service_finder.createReference(name, mesh);
    if (!mf) {
      if (properties & SB_AllowNull)
        return {};
      _throwFatal(name, properties);
    }
    return mf;
  }

  UniqueArray<Ref<InterfaceType>> createAllInstances()
  {
    return m_service_finder.createAll();
  }

  InterfaceType* getSingleton(eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* mf = m_service_finder.getSingleton();
    if (!mf) {
      if (properties & SB_AllowNull)
        return 0;
      _throwFatal(properties);
    }
    return mf;
  }

  static Ref<InterfaceType>
  createReference(ISubDomain* sd, const String& name,
                  eServiceBuilderProperties properties = SB_None)
  {
    return createReference(sd, name, 0, properties);
  }

  static Ref<InterfaceType>
  createReference(ISession* session, const String& name,
                  eServiceBuilderProperties properties = SB_None)
  {
    Ref<InterfaceType> it;
    {
      ServiceBuilder sb(session);
      it = sb.createReference(name, properties);
    }
    return it;
  }

  static Ref<InterfaceType>
  createReference(IApplication* app, const String& name,
                  eServiceBuilderProperties properties = SB_None)
  {
    Ref<InterfaceType> it;
    {
      ServiceBuilder sb(app);
      it = sb.createReference(name, properties);
    }
    return it;
  }

  static Ref<InterfaceType>
  createReference(ISubDomain* sd, const String& name, IMesh* mesh,
                  eServiceBuilderProperties properties = SB_None)
  {
    Ref<InterfaceType> it;
    {
      ServiceBuilder sb(sd);
      it = sb.createReference(name, mesh, properties);
    }
    return it;
  }

  void getServicesNames(Array<String>& names) const
  {
    m_service_finder.getServicesNames(names);
  }
 
 public:

  ARCCORE_DEPRECATED_2019("use createAllInstances(Array<Ref<InterfaceType>>) instead")
  void createAllInstances(Array<InterfaceType*>& instances)
  {
    m_service_finder.createAll(instances);
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  InterfaceType* createInstance(const String& name, eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* mf = m_service_finder.create(name);
    if (!mf) {
      if (properties & SB_AllowNull)
        return 0;
      _throwFatal(name, properties);
    }
    return mf;
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  static InterfaceType*
  createInstance(ISubDomain* sd, const String& name,
                 eServiceBuilderProperties properties = SB_None)
  {
    return createInstance(sd, name, 0, properties);
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  InterfaceType* createInstance(const String& name, IMesh* mesh,
                                eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* mf = m_service_finder.create(name, mesh);
    if (!mf) {
      if (properties & SB_AllowNull)
        return 0;
      _throwFatal(name, properties);
    }
    return mf;
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  static InterfaceType* createInstance(ISession* session, const String& name,
                                       eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* it = 0;
    {
      ServiceBuilder sb(session);
      it = sb.createInstance(name, properties);
    }
    return it;
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  static InterfaceType* createInstance(IApplication* app, const String& name,
                                       eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* it = 0;
    {
      ServiceBuilder sb(app);
      it = sb.createInstance(name, properties);
    }
    return it;
  }

  ARCCORE_DEPRECATED_2019("Use createReference() instead")
  static InterfaceType* createInstance(ISubDomain* sd, const String& name, IMesh* mesh,
                                       eServiceBuilderProperties properties = SB_None)
  {
    InterfaceType* it = 0;
    {
      ServiceBuilder sb(sd);
      it = sb.createInstance(name, mesh, properties);
    }
    return it;
  }
 
 private:
 
  Internal::ServiceFinderBase2T<InterfaceType> m_service_finder;
 
 private:
 
  String _getErrorMessage(String wanted_name)
  {
    StringUniqueArray valid_names;
    m_service_finder.getServicesNames(valid_names);
    if (valid_names.size() != 0)
      return String::format("no service named '{0}' found (valid values = {1})",
                            wanted_name, String::join(", ", valid_names));
    // No service available
    return String::format("no service named '{0}' found and no implementation available",
                          wanted_name);
  }
 
  void _throwFatal(const String& name, eServiceBuilderProperties properties)
  {
    String err_msg = _getErrorMessage(name);
    if (properties & SB_Collective)
      throw ParallelFatalErrorException(A_FUNCINFO, err_msg);
    else
      throw FatalErrorException(A_FUNCINFO, err_msg);
  }
  void _throwFatal(eServiceBuilderProperties properties)
  {
    String err_msg = "No singleton service found for that interface";
    if (properties & SB_Collective)
      throw ParallelFatalErrorException(A_FUNCINFO, err_msg);
    else
      throw FatalErrorException(A_FUNCINFO, err_msg);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ServiceBuilderWithOptionsBase
{
 protected:
 
  ServiceBuilderWithOptionsBase(ICaseMng* cm)
  : m_case_mng(cm)
  {
  }
 
 protected:
 
  ReferenceCounter<ICaseOptions> _buildCaseOptions(const AxlOptionsBuilder::Document& options_doc) const;
  IApplication* _application() const;
  void _readOptions(ICaseOptions* opt) const;
 
 protected:
 
  ICaseMng* m_case_mng = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename InterfaceType>
class ServiceBuilderWithOptions
: private ServiceBuilderWithOptionsBase
{
 public:
 
  ServiceBuilderWithOptions(ICaseMng* cm)
  : ServiceBuilderWithOptionsBase(cm)
  {}
 
 public:
 
  Ref<InterfaceType>
  createReference(const String& service_name, const AxlOptionsBuilder::Document& options_doc,
                  eServiceBuilderProperties properties = SB_None)
  {
    ReferenceCounter<ICaseOptions> opt(_buildCaseOptions(options_doc));
    ServiceBuilder<InterfaceType> sbi(_application(), opt.get());
    Ref<InterfaceType> s = sbi.createReference(service_name, properties);
    if (s.get()) {
      _readOptions(opt.get());
    }
    return s;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif