CollectionProxy.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H

// LArSoft libraries
#include "larcorealg/CoreUtils/ContainerMeta.h" // util::collection_value_t, ...
#include "lardata/RecoBaseProxy/ProxyBase/CollectionProxyElement.h"
#include "lardata/RecoBaseProxy/ProxyBase/MainCollectionProxy.h"
#include "lardata/Utilities/TupleLookupByTag.h" // util::type_with_tag_t, ...

// C/C++ standard
#include <cstdlib> // std::size_t
#include <limits>  // std::numeric_limits<>
#include <tuple>
#include <utility> // std::move()
#include <vector>

namespace proxy {

  namespace details {

    template <typename Cont>
    class IndexBasedIterator;

    template <template <typename, typename...> class F, typename...>
    struct TemplateAdaptorOnePlus;

  } // namespace details

  // --- BEGIN Collection proxy infrastructure ---------------------------------
  //----------------------------------------------------------------------------
  template <template <typename CollProxy> class Element, typename MainColl, typename... AuxColls>
  class CollectionProxyBase : public details::MainCollectionProxy<MainColl>, public AuxColls... {
    using collection_proxy_t = CollectionProxyBase<Element, MainColl, AuxColls...>;

    using main_collection_proxy_t = details::MainCollectionProxy<MainColl>;

  public:
    using typename main_collection_proxy_t::main_element_t;

    using typename main_collection_proxy_t::main_collection_t;

    using element_proxy_t = Element<collection_proxy_t>;

    using aux_collections_t = std::tuple<AuxColls...>;

    using value_type = element_proxy_t;

    using const_iterator = details::IndexBasedIterator<collection_proxy_t>;

    using iterator = const_iterator;

    CollectionProxyBase(main_collection_t const& main, AuxColls&&... aux)
      : main_collection_proxy_t(main), AuxColls(std::move(aux))...
    {}

    element_proxy_t const operator[](std::size_t i) const
    {
      return details::makeCollectionProxyElement<element_proxy_t>(
        i, getMainAt(i), aux<AuxColls>().operator[](i)...);
    }

    const_iterator begin() const { return makeIterator(0U); }

    const_iterator end() const { return makeIterator(size()); }

    bool empty() const { return main().empty(); }

    std::size_t size() const { return main().size(); }

    template <typename AuxTag>
    auto get() const -> decltype(auto)
    {
      return auxByTag<AuxTag>();
    }

    template <typename Tag, typename T = std::vector<Tag> const&>
    [[deprecated("Use C++17 constexpr if instead and get() instead")]] auto getIf() const
      -> decltype(auto);

    template <typename Tag>
    static constexpr bool has()
    {
      return util::has_tag_v<Tag, aux_collections_t>;
    }

  protected:
    using main_collection_proxy_t::getMainAt;
    using main_collection_proxy_t::main;
    using main_collection_proxy_t::mainProxy;

    template <typename AuxColl>
    AuxColl const& aux() const
    {
      return static_cast<AuxColl const&>(*this);
    }

    template <typename AuxTag>
    auto auxByTag() const -> decltype(auto)
    {
      return aux<util::type_with_tag_t<AuxTag, aux_collections_t>>();
    }

    template <typename Tag, typename>
    auto getIfHas(std::bool_constant<true>) const -> decltype(auto);
    template <typename Tag, typename T>
    [[noreturn]] auto getIfHas(std::bool_constant<false>) const -> T;

    const_iterator makeIterator(std::size_t i) const { return {*this, i}; }

    static_assert(!util::has_duplicate_tags<aux_collections_t>(),
                  "Some auxiliary data collections share the same tag. They should not.");

  }; // struct CollectionProxyBase

  //----------------------------------------------------------------------------
  template <typename MainColl, typename... AuxColls>
  using CollectionProxy = CollectionProxyBase<CollectionProxyElement, MainColl, AuxColls...>;

  // this joke is necessary because expanding directly CollectionProxy<Args...>
  // into CollectionProxy<Main, Aux...>  template arguments does not work
  template <typename... Args>
  using CollectionProxyFromArgs =
    typename details::TemplateAdaptorOnePlus<CollectionProxy, Args...>::type;

  // --- END Collection proxy infrastructure -----------------------------------

  //----------------------------------------------------------------------------
  namespace details {

    //--------------------------------------------------------------------------
    template <template <typename...> class CollProxy, typename MainColl, typename... AuxColl>
    auto createCollectionProxy(MainColl const& main, AuxColl&&... aux)
    {
      return CollProxy<MainColl, AuxColl...>(main, std::forward<AuxColl>(aux)...);
    }

    //--------------------------------------------------------------------------
    template <typename MainColl, typename... AuxColl>
    auto makeCollectionProxy(MainColl const& main, AuxColl&&... aux)
    {
      return createCollectionProxy<CollectionProxy>(main, std::forward<AuxColl>(aux)...);
    }

    //--------------------------------------------------------------------------
    template <typename Cont>
    class IndexBasedIterator {

    public:
      using container_t = Cont;

      using value_type = util::collection_value_t<container_t>;
      using const_iterator = IndexBasedIterator;

      IndexBasedIterator() = default;

      IndexBasedIterator(container_t const& cont, std::size_t index = 0)
        : fCont(&cont), fIndex(index)
      {}

      auto operator*() const -> decltype(auto) { return fCont->operator[](fIndex); }

      const_iterator& operator++()
      {
        ++fIndex;
        return *this;
      }

      bool operator!=(const_iterator const& other) const
      {
        return (other.fIndex != fIndex) || (other.fCont != fCont);
      }

    protected:
      container_t const* fCont = nullptr; 

      std::size_t fIndex = std::numeric_limits<std::size_t>::max();

    }; // IndexBasedIterator<>

  } // namespace details

} // namespace proxy

//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
namespace proxy {

  namespace details {

    //--------------------------------------------------------------------------
    template <template <typename, typename...> class F, typename First, typename... Others>
    struct TemplateAdaptorOnePlus<F, First, Others...> {
      using type = F<First, Others...>;
    };

  } // namespace details

  //----------------------------------------------------------------------------
  //---  CollectionProxyBase
  //----------------------------------------------------------------------------
  template <template <typename CollProxy> class Element, typename MainColl, typename... AuxColls>
  template <typename Tag, typename T>
  auto CollectionProxyBase<Element, MainColl, AuxColls...>::getIf() const -> decltype(auto)
  {
    return getIfHas<Tag, T>(std::bool_constant<has<Tag>()>{});
  }

  template <template <typename CollProxy> class Element, typename MainColl, typename... AuxColls>
  template <typename Tag, typename>
  auto CollectionProxyBase<Element, MainColl, AuxColls...>::getIfHas(std::bool_constant<true>) const
    -> decltype(auto)
  {
    return get<Tag>();
  }

  template <template <typename CollProxy> class Element, typename MainColl, typename... AuxColls>
  template <typename Tag, typename T>
  auto CollectionProxyBase<Element, MainColl, AuxColls...>::getIfHas(
    std::bool_constant<false>) const -> T
  {
    throw std::logic_error("Tag '" + lar::debug::demangle<Tag>() + "' not available.");
  }

  //----------------------------------------------------------------------------

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H