CollectionProxy.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H

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

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


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&>
    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::main;
    using main_collection_proxy_t::mainProxy;
    using main_collection_proxy_t::getMainAt;
    
    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(util::bool_constant<true>) const -> decltype(auto);
    template <typename Tag, typename T>
    [[noreturn]] auto getIfHas(util::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>(util::bool_constant<has<Tag>()>{}); }
  
  
  template <
    template <typename CollProxy> class Element,
    typename MainColl,
    typename... AuxColls
    >
  template <typename Tag, typename>
  auto CollectionProxyBase<Element, MainColl, AuxColls...>::getIfHas
    (util::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
    (util::bool_constant<false>) const -> T
    {
      throw std::logic_error
        ("Tag '" + lar::debug::demangle<Tag>() + "' not available."); 
    }
  
  
  //----------------------------------------------------------------------------
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXY_H