ParallelData.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATA_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATA_H

// LArSoft libraries
#include "larcorealg/CoreUtils/ContainerMeta.h" // util::collection_value_t, ...
#include "lardata/Utilities/TupleLookupByTag.h" // util::makeTagged(), ...

// C/C++ standard
#include <cstdlib>     // std::size_t
#include <type_traits> // std::is_convertible<>, ...
#include <utility>     // std::declval()

namespace proxy {

  // --- BEGIN LArSoftProxiesParallelData --------------------------------------

  template <typename AuxColl, typename Aux = util::collection_value_t<AuxColl>, typename Tag = Aux>
  auto makeParallelData(AuxColl const& data);

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

    template <typename AuxColl,
              typename Aux /* = util::collection_value_t<AuxColl> */,
              typename Tag /* = Aux */
              >
    class ParallelData {
      using This_t = ParallelData<AuxColl, Aux, Tag>; 

      using parallel_data_t = AuxColl;

      using aux_t = Aux; // unused

      using aux_element_t = util::collection_value_constant_access_t<AuxColl>;

      using parallel_data_iterator_t = typename parallel_data_t::const_iterator;

    public:
      using tag = Tag; 

      using auxiliary_data_t = decltype(util::makeTagged<tag>(std::declval<aux_element_t>()));

      ParallelData(parallel_data_t const& data) : fData(&data) {}

      auto begin() const -> decltype(auto) { return fData->begin(); }

      auto end() const -> decltype(auto) { return fData->end(); }

      auto operator[](std::size_t index) const -> decltype(auto)
      {
        static_assert(std::is_convertible<decltype(getElement(index)), auxiliary_data_t>(),
                      "Inconsistent data types.");
        return getElement(index);
      }

      template <typename TestTag>
      static constexpr bool hasTag()
      {
        return std::is_same<TestTag, tag>();
      }

      parallel_data_t const* data() const { return fData; }

      parallel_data_t const& dataRef() const { return *(data()); }

    private:
      parallel_data_t const* fData; 

      auto getElement(std::size_t index) const -> decltype(auto)
      {
        return util::makeTagged<tag>(fData->operator[](index));
      }

    }; // class ParallelData<>

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

  } // namespace details

  // --- END LArSoftProxiesParallelData ----------------------------------------

} // namespace proxy

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

  //----------------------------------------------------------------------------
  //--- makeParallelData() implementations
  //----------------------------------------------------------------------------
  template <typename AuxColl,
            typename Aux /* = util::collection_value_t<AuxColl>*/,
            typename Tag /* = Aux */
            >
  auto makeParallelData(AuxColl const& data)
  {

    // Ahh, simplicity.
    return details::ParallelData<AuxColl, Aux, Tag>(data);

  } // makeParallelData(AuxColl)

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

} // namespace proxy

#endif // LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATA_H