ServiceProviderWrappers.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_SERVICEPROVIDERWRAPPERS_H
#define LARCORE_COREUTILS_SERVICEPROVIDERWRAPPERS_H 1


// LArSoft libraries
#include "larcore/CoreUtils/ServiceUtil.h" // lar::providerFrom() (for includers)

// framework and support libraries
#include "art/Framework/Services/Registry/ServiceTable.h"
#include "art/Framework/Services/Registry/ServiceMacros.h" // (for includers)

// C/C++ standard libraries
#include <memory> // std::unique_ptr<>


// forward declarations
namespace art { class ActivityRegistry; }
namespace fhicl { class ParameterSet; }


namespace lar {
   
   template <class PROVIDER>
   class SimpleServiceProviderWrapper {
      
         public:
      using provider_type = PROVIDER; 
      
      using Parameters = art::ServiceTable<typename provider_type::Config>;
      
      
      SimpleServiceProviderWrapper
         (Parameters const& config, art::ActivityRegistry&)
         : prov(std::make_unique<provider_type>(config()))
         {}
         
      
      provider_type const* provider() const { return prov.get(); }
      
      
         private:
      
      std::unique_ptr<provider_type> prov; 
      
   }; // SimpleServiceProviderWrapper<>
   
   
   
   template <class PROVIDER>
   class ServiceProviderInterfaceWrapper {
      
         public:
      using provider_type = PROVIDER; 
      
      virtual ~ServiceProviderInterfaceWrapper() = default;
      
      
      provider_type const* provider() const { return do_provider(); }
      
      
         protected:
      
      virtual provider_type const* do_provider() const = 0;
      
   }; // ServiceProviderInterfaceWrapper<>
   
   

   template <typename PROVIDER, typename INTERFACE>
   class ServiceProviderImplementationWrapper: public INTERFACE {
      
         public:
      using concrete_provider_type = PROVIDER;
      
      using service_interface_type = INTERFACE;
      
      using provider_type = typename service_interface_type::provider_type;
      
      using Parameters
        = art::ServiceTable<typename concrete_provider_type::Config>;
      
      
      ServiceProviderImplementationWrapper
         (Parameters const& config, art::ActivityRegistry&)
         : prov(std::make_unique<concrete_provider_type>(config()))
         {}
      
      
         private:
      std::unique_ptr<concrete_provider_type> prov; 
      
      virtual provider_type const* do_provider() const override
         { return prov.get(); }
      
   }; // ServiceProviderImplementationWrapper
   
   
} // namespace lar


#endif // LARCORE_COREUTILS_SERVICEPROVIDERWRAPPERS_H