ServiceUtil.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_SERVICEUTIL_H
#define LARCORE_COREUTILS_SERVICEUTIL_H

// LArSoft libraries
#include "larcorealg/CoreUtils/UncopiableAndUnmovableClass.h"
#include "larcorealg/CoreUtils/ProviderPack.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<>
#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()
    {
      details::ServiceRequirementsChecker<T>(); // instantiate a temporary...
      
      // retrieve the provider
      art::ServiceHandle<T> h;
      typename T::provider_type const* pProvider = h->provider();
      if (!pProvider) {
        throw art::Exception(art::errors::NotFound)
          << "Service <" << cet::demangle_symbol(typeid(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