ParallelData.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATA_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_PARALLELDATA_H

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

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



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