CollectionProxyMaker.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYMAKER_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYMAKER_H

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

// 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