CollectionProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYMAKER_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/CollectionProxy.h"
#include "larcorealg/CoreUtils/ContainerMeta.h" // util::collection_value_t, ...
#include "larcorealg/CoreUtils/MetaUtils.h" // util::always_true_type

// framework libraries
#include "canvas/Utilities/InputTag.h"

// C/C++ standard 
#include <vector>


namespace proxy {
  
  // --- BEGIN Collection proxy infrastructure ---------------------------------
  
  //----------------------------------------------------------------------------
  template <typename Proxy, typename Selector = Proxy>
  struct CollectionProxyMakerTraits {
    static_assert
      (util::always_true_type<Proxy>(), "This class requires specialization.");
  };
  
  
  //----------------------------------------------------------------------------
  template <typename CollProxy>
  struct CollectionProxyMakerBase {
    
    using traits_t = CollectionProxyMakerTraits<CollProxy>;
    
    using main_collection_proxy_t = typename traits_t::main_collection_proxy_t;
    
    using main_element_t = typename traits_t::main_element_t;
    
    using main_collection_t = typename traits_t::main_collection_t;
    
    template <typename Event, typename... WithArgs>
    static auto make
      (Event const& event, art::InputTag const& tag, WithArgs&&... withArgs);
    
  }; // struct CollectionProxyMakerBase<>
  
  
  //----------------------------------------------------------------------------
  template <typename CollProxy>
  struct CollectionProxyMaker: CollectionProxyMakerBase<CollProxy> {};
  
  
  // --- END Collection proxy infrastructure -----------------------------------
  
  
  //----------------------------------------------------------------------------
  //--- specializations of CollectionProxyMakerTraits
  //----------------------------------------------------------------------------
  
  template <typename T>
  struct CollectionProxyMakerTraits<std::vector<T>> {
    
    using main_collection_t = std::vector<T>;
    
    using main_element_t = util::collection_value_t<main_collection_t>;
    
    using main_collection_proxy_t
      = details::MainCollectionProxy<main_collection_t>;
    
  }; // CollectionProxyMakerTraits<std::vector<T>>
  
  
  template <typename MainColl>
  struct CollectionProxyMakerTraits<CollectionProxy<MainColl>> {
    using main_collection_proxy_t = CollectionProxy<MainColl>;
    
    using main_element_t = typename main_collection_proxy_t::main_element_t;
    
    using main_collection_t
      = typename main_collection_proxy_t::main_collection_t;
    
  }; // CollectionProxyMakerTraits<CollectionProxy>
  
  
  // ---------------------------------------------------------------------------
  
} // namespace proxy



// -----------------------------------------------------------------------------
// ---  Template implementation
// -----------------------------------------------------------------------------
namespace proxy {
  
  namespace details {
    
    // -------------------------------------------------------------------------
    //
    // We need to discover whether the trait class contains a
    // `collection_proxy_impl_t` type. Unfortunately, that is not a plain type
    // but rather a template type (it is expected to take the same template
    // arguments as `proxy::CollectionProxy`).
    // 
    // Since Gianluca is not able to detect the presence of a templated type in
    // a class, but only of fully specified type, the following machinery is in
    // place. At the time we need to know the `collection_proxy_impl_t` type, we
    // are trying to create one and therefore we know the full argument set for
    // it already (let's call it `Args...`, that is `MainColl` plus
    // `AuxColls...`). Then, we test the presence of
    // `collection_proxy_impl_t<Args...>` instead of just
    // `collection_proxy_impl_t`.
    // An additional complication is the presence of a parameter pack, that
    // impedes the usual pattern of having `std::enable_if_t` as the last,
    // optional template parameter (`Args` must be the last). So we give up the
    // elegant feature of having a default value, and we force the caller to
    // explicitly spell it: `void` (always that one).
    // We absorb this ugliness and the need for the usual and cumbersome
    // `typename ...::type` in the definition of
    // `CollectionProxyImplFromTraits_t`, which should be the only access point
    // to this machinery.
    // About the naming: a "collection proxy" is the final proxy class.
    // `CollectionProxy` is also the name, already taken, of the class we
    // provide as reference for that role. So I have called the role an
    // "implementation" of the "collection proxy" idea, and `CollectionProxy` is
    // in fact an implementation (the "standard" one) of that idea.
    // The name of that idea in the proxy traits is `collection_proxy_impl_t`.
    // `CollectionProxyImpl` is supposed to be a generic name for that concept,
    // and the utility `CollectionProxyImplFromTraits` is in charge of
    // extracting it from the traits. This utility also needs an implementation,
    // hence the second "Impl": `CollectionProxyImplFromTraitsImpl`. Urgh.
    // 
    // I don't know whether to be worried that the explanation of this code is
    // longer than the code itself...
    //
    template <typename Traits, typename, typename... Args>
    struct CollectionProxyImplFromTraitsImpl {
      using type = CollectionProxyFromArgs<Args...>;
    };
    
    template <typename Traits, typename... Args>
    struct CollectionProxyImplFromTraitsImpl<
      Traits,
      std::enable_if_t<util::always_true_v
        <typename Traits::template collection_proxy_impl_t<Args...>>
        >,
      Args...
      >
    {
      using type = typename Traits::template collection_proxy_impl_t<Args...>;
    };
    
    template <typename Traits, typename... Args>
    using CollectionProxyImplFromTraits_t
      = typename CollectionProxyImplFromTraitsImpl<Traits, void, Args...>::type;
    
    
    // -------------------------------------------------------------------------
    template <typename Traits, typename... Args>
    auto createCollectionProxyFromTraits(Args&&... args) {
      using collection_proxy_impl_t
        = CollectionProxyImplFromTraits_t<Traits, std::decay_t<Args>...>;
      return collection_proxy_impl_t(std::forward<Args>(args)...);
    } // createCollectionProxyFromTraits()
    
    
    // -------------------------------------------------------------------------
    
  } // namespace details
  
  
  // ---------------------------------------------------------------------------
  // ---  CollectionProxyMakerBase implementation
  // ---------------------------------------------------------------------------
  template <typename CollProxy>
  template <typename Event, typename... WithArgs>
  auto CollectionProxyMakerBase<CollProxy>::make
    (Event const& event, art::InputTag const& tag, WithArgs&&... withArgs)
  {
    auto mainHandle = event.template getValidHandle<main_collection_t>(tag);
    
    // The actual type of collection proxy implementation is extracted from
    // the traits of the proxy (`collection_proxy_impl_t`), but if that is not
    // provided a default implementation, `proxy::CollectionProxy`, is used:
    return details::createCollectionProxyFromTraits<traits_t>(
      *mainHandle,
      withArgs.template createAuxProxyMaker<main_collection_proxy_t>
        (event, mainHandle, tag)...
      );
  } // CollectionProxyMakerBase<>::make<>()
  
  
  // ---------------------------------------------------------------------------
  
} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYMAKER_H