CollectionProxyElement.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H

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

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

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&>
    [[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_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(std::bool_constant<true>) const -> decltype(auto);

    template <typename Tag, typename T>
    [[noreturn]] auto getIfHas(std::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>(std::bool_constant<has<Tag>()>{});
  }

  //----------------------------------------------------------------------------
  template <typename CollProxy>
  template <typename Tag, typename>
  auto CollectionProxyElement<CollProxy>::getIfHas(std::bool_constant<true>) const -> decltype(auto)
  {
    return get<Tag>();
  }

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

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

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_COLLECTIONPROXYELEMENT_H