ServiceUtil.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_SERVICEUTIL_H
#define LARCORE_COREUTILS_SERVICEUTIL_H

// LArSoft libraries
#include "larcorealg/CoreUtils/ProviderPack.h"
#include "larcorealg/CoreUtils/UncopiableAndUnmovableClass.h"

// framework libraries
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Utilities/Exception.h"
#include "cetlib_except/demangle.h"

// C/C++ standard libraries
#include <type_traits> // std::decay<>, std::is_same<>, std::add_const_t<>
#include <typeinfo>

namespace lar {

  namespace details {
    template <typename PROVIDER>
    struct ServiceRequirementsChecker;

    template <typename... Services>
    struct ProviderPackExtractor;

  } // namespace details

  template <typename T>
  typename T::provider_type const* providerFrom()
  {
    using Service_t = std::add_const_t<T>;
    using Provider_t = typename Service_t::provider_type;

    (void)details::ServiceRequirementsChecker<Service_t>();

    // retrieve the provider
    art::ServiceHandle<Service_t> h;
    Provider_t const* const pProvider{h->provider()};
    if (!pProvider) {
      throw art::Exception(art::errors::NotFound)
        << "ServiceHandle <" << cet::demangle_symbol(typeid(Service_t).name())
        << "> offered a null provider";
    }

    return pProvider;

  } // providerFrom()

  template <typename... Services>
  auto providersFrom()
  {
    return details::ProviderPackExtractor<Services...>::parameterPack();
  }

  template <typename... Services>
  using providersFrom_t = lar::ProviderPack<typename Services::provider_type...>;

  //----------------------------------------------------------------------------
  namespace details {
    template <typename PROVIDER>
    struct ServiceProviderRequirementsChecker {

      using provider_type = PROVIDER;

      // static checks on provider class: not copiable nor movable
      static_assert(!std::is_copy_constructible<provider_type>::value,
                    "Service provider classes must not be copiable");
      static_assert(!std::is_copy_assignable<provider_type>::value,
                    "Service provider classes must not be copiable");
      static_assert(!std::is_move_constructible<provider_type>::value,
                    "Service provider classes must not be movable");
      static_assert(!std::is_move_assignable<provider_type>::value,
                    "Service provider classes must not be movable");

    }; // ServiceProviderRequirementsChecker

    template <typename SERVICE>
    struct ServiceRequirementsChecker {

      // require SERVICE::provider_type to be a type
      using provider_type = typename SERVICE::provider_type;

      // expected type for SERVICE::provider() method
      using provider_func_type = provider_type const* (SERVICE::*)() const;

      ServiceProviderRequirementsChecker<provider_type> provider_checker;

      // check the provider() method
      static_assert(std::is_same<decltype(&SERVICE::provider), provider_func_type>::value,
                    "provider() method has unsupported signature");

    }; // ServiceRequirementsChecker

    //--------------------------------------------------------------------------
    template <typename First, typename... Others>
    struct ProviderPackExtractor<First, Others...> {
      static ProviderPack<typename First::provider_type, typename Others::provider_type...>
      parameterPack()
      {
        return {ProviderPackExtractor<Others...>::parameterPack(), lar::providerFrom<First>()};
      }
    };

    template <typename Service>
    struct ProviderPackExtractor<Service> {
      static auto parameterPack() { return lar::makeProviderPack(lar::providerFrom<Service>()); }
    };

  } // namespace details

} // namespace lar

#endif //#LARCORE_COREUTILS_SERVICEUTIL_H