CollectionProxyElement.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H

// LArSoft libraries
#include "lardata/Utilities/TupleLookupByTag.h" // util::index_of_tag_v, ...
#include "larcorealg/CoreUtils/MetaUtils.h" // util::always_true_type, ...
#include "larcorealg/CoreUtils/DebugUtils.h" // lar::debug::demangle()

// C/C++ standard 
#include <tuple> // also std::tuple_element_t<>, std::get()
#include <utility> // std::move()
#include <stdexcept> // std::logic_error
#include <type_traits> // std::integral_constant<>
#include <cstdlib> // std::size_t



namespace proxy {
  
  
  namespace details {
    
    template <typename AuxCollTuple>
    struct SubstituteWithAuxList;
    
  } // namespace details
  
  
  //--- BEGIN Proxy element infrastructure -------------------------------------
  //----------------------------------------------------------------------------
  template <typename CollProxy>
  struct CollectionProxyElement {
    
      public:
    using collection_proxy_t = CollProxy;
    using main_element_t = typename collection_proxy_t::main_element_t;
    
    using aux_elements_t = typename details::SubstituteWithAuxList
      <typename collection_proxy_t::aux_collections_t>::type;
    
    CollectionProxyElement
      (std::size_t index, main_element_t const& main, aux_elements_t&& auxData)
      : fIndex(index), fMain(&main) , fAuxData(std::move(auxData))
      {}
    
    main_element_t const* operator->() const { return fMain; }
    
    main_element_t const& operator*() const { return *fMain; }
    
    std::size_t index() const { return fIndex; };
    
    template <typename Tag>
    auto get() const -> decltype(auto)
      { return std::get<util::index_of_tag_v<Tag, aux_elements_t>>(fAuxData); }
    
    
    template <typename Tag, typename T = Tag const&>
    auto getIf() const -> decltype(auto);
    
    
    template <typename Tag>
    static constexpr bool has() { return util::has_tag_v<Tag, aux_elements_t>; }
    
      private:
    
    std::size_t fIndex; 
    main_element_t const* fMain; 
    
    // note that the auxiliary data is not tagged, we need to learn which
    // the tags are from the collection.
    aux_elements_t fAuxData; 
    
    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;
    
  }; // CollectionProxyElement<>


  //--- END Proxy element infrastructure ---------------------------------------
  
  
  //----------------------------------------------------------------------------
  namespace details {
    
    //--------------------------------------------------------------------------
    //---  Stuff for the whole collection proxy
    //--------------------------------------------------------------------------
    template <typename ProxyElement, typename... AuxData>
    auto makeCollectionProxyElement(
      std::size_t index,
      typename ProxyElement::main_element_t const& main,
      AuxData&&... auxData
    ) {
      return ProxyElement(
        index, main,
        typename ProxyElement::aux_elements_t(std::forward<AuxData>(auxData)...)
        );
    } // makeCollectionProxyElement()
    
    
    //--------------------------------------------------------------------------
    
  } // namespace details
  
} // namespace proxy


//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
namespace proxy {
  
  namespace details {
    
    //--------------------------------------------------------------------------
    //--- stuff for auxiliary data
    //--------------------------------------------------------------------------
    // Trait replacing each element of the specified tuple with its
    // `auxiliary_data_t`
    template <typename Tuple>
    struct SubstituteWithAuxList {
      static_assert
        (util::always_true_type<Tuple>(), "Template argument must be a tuple");
    }; // SubstituteWithAuxList<>
    
    template <typename... T>
    struct SubstituteWithAuxList<std::tuple<T...>> {
      using type = std::tuple<typename T::auxiliary_data_t...>;
    }; // SubstituteWithAuxList<tuple>
    
    //--------------------------------------------------------------------------
    
  } // namespace details
  
  
  //----------------------------------------------------------------------------
  //---  CollectionProxyElement
  //----------------------------------------------------------------------------
  template <typename CollProxy>
  template <typename Tag, typename T>
  auto CollectionProxyElement<CollProxy>::getIf() const -> decltype(auto)
    { return getIfHas<Tag, T>(util::bool_constant<has<Tag>()>{}); }
  
  
  //----------------------------------------------------------------------------
  template <typename CollProxy>
  template <typename Tag, typename>
  auto CollectionProxyElement<CollProxy>::getIfHas
    (util::bool_constant<true>) const -> decltype(auto)
    { return get<Tag>(); }
  
  template <typename CollProxy>
  template <typename Tag, typename T>
  auto CollectionProxyElement<CollProxy>::getIfHas
    (util::bool_constant<false>) const -> T
    {
      throw std::logic_error
        ("Tag '" + lar::debug::demangle<Tag>() + "' not available."); 
    }
  
  
  //----------------------------------------------------------------------------
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H