OneTo01Data.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATA_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATA_H

// LArSoft libraries
#include "lardata/RecoBaseProxy/ProxyBase/AssnsTraits.h"
#include "lardata/Utilities/TupleLookupByTag.h" // util::add_tag_t(), ...

// framework libraries
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"

// C/C++ standard 
#include <vector>
#include <tuple> // std::tuple_element_t<>, std::get()
#include <iterator> // std::cbegin(), std::cend()
#include <utility> // std::move()
#include <type_traits> // std::is_convertible<>
#include <cstdlib> // std::size_t


namespace proxy {
  
  namespace details {
    
    template <
      typename Main, typename Aux, typename Metadata /* = void */,
      typename Tag /* = Aux */
      >
    class OneTo01Data {
      using This_t = OneTo01Data<Main, Aux, Metadata, Tag>; 
      
        public:
      using aux_t = Aux;
      
      using metadata_t = Metadata;
      
      using tag = Tag;
      
      using main_t = Main;
      
      using aux_ptr_t = art::Ptr<aux_t>;
      
      using auxiliary_data_t = util::add_tag_t<aux_ptr_t, tag>;
      
      using aux_coll_t = std::vector<aux_ptr_t>;
      
      using assns_t = art::Assns<main_t, aux_t>;
      
      
      OneTo01Data(aux_coll_t&& data): auxData(std::move(data)) {}
      
      bool has(std::size_t i) const
        { return get(i) == aux_ptr_t(); }
      
      auxiliary_data_t get(std::size_t i) const
        { return auxiliary_data_t(auxData[i]); }
      
      
      auto operator[] (std::size_t index) const -> decltype(auto)
        {
          static_assert(
            std::is_convertible<decltype(get(index)), auxiliary_data_t>(),
            "Inconsistent data types."
            );
          return get(index);
        }
      
        private:
      aux_coll_t auxData; 
      
    }; // class OneTo01Data<>
    
  } // namespace details
  
  

  template <typename Tag, typename Assns>
  auto makeOneTo01data(Assns const& assns, std::size_t minSize = 0);
  
  template <typename Assns>
  auto makeOneTo01data(Assns const& assns, std::size_t minSize = 0)
    { return makeOneTo01data<typename Assns::right_t>(assns, minSize); }
  

  template <typename Tag, typename MainColl, typename Assns>
  auto makeOneTo01data(MainColl const& mainColl, Assns const& assns)
    { return makeOneTo01data<Tag>(assns, mainColl.size()); }
  
  template <typename MainColl, typename Assns>
  auto makeOneTo01data(MainColl const& mainColl, Assns const& assns)
    { return makeOneTo01data<typename Assns::right_t>(mainColl, assns); }
  
} // namespace proxy


//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------
namespace proxy {
  
  namespace details {
    
    //--------------------------------------------------------------------------
    // Extends vector v with default-constructed data
    // and executes v[index]=value
    template <typename T>
    void extendAndAssign(
      std::vector<T>& v,
      typename std::vector<T>::size_type index, 
      typename std::vector<T>::value_type const& value
    ) {
      if (index >= v.size()) {
        v.reserve(index + 1);
        v.resize(index);
        v.push_back(value);
      }
      else v[index] = value;
    } // extendAndAssign()
    
    // Extends vector v with default-constructed data
    // and executes v[index]=move(value)
    template <typename T>
    void extendAndAssign(
      std::vector<T>& v,
      typename std::vector<T>::size_type index, 
      typename std::vector<T>::value_type&& value
    ) {
      if (index >= v.size()) {
        v.reserve(index + 1);
        v.resize(index);
        v.push_back(std::move(value));
      }
      else v[index] = std::move(value);
    } // extendAndAssign()
    
    
    //--------------------------------------------------------------------------
    template <std::size_t Key, std::size_t Data, typename Iter>
    auto associationOneToOneFullSequence(Iter begin, Iter end, std::size_t n) {
      //
      // Here we are actually not using the assumption that the keys are in
      // increasing order; which is just as good as long as we use a fast random
      // access container as STL vector.
      // We do assume the key side of the association to be valid, though.
      //
      using value_type = typename Iter::value_type;
      using data_t = std::tuple_element_t<Data, value_type>;
      std::vector<data_t> data(n); // all default-constructed
      for (auto it = begin; it != end; ++it) {
        auto const& keyPtr = std::get<Key>(*it);
        extendAndAssign(data, keyPtr.key(), std::get<Data>(*it));
      }
      return data;
    } // associationOneToOneFullSequence(Iter, Iter, std::size_t)
    
  } // namespace details
  
  
  //----------------------------------------------------------------------------
  //--- makeOneTo01data() implementation
  //----------------------------------------------------------------------------
  template <typename Tag, typename Assns>
  auto makeOneTo01data(Assns const& assns, std::size_t minSize /* = 0 */)
  {
    using Main_t = typename Assns::left_t;
    using Aux_t = typename Assns::right_t;
    using Metadata_t = lar::util::assns_metadata_t<Assns>;
    using AssociatedData_t
      = details::OneTo01Data<Main_t, Aux_t, Metadata_t, Tag>;
    
    using std::cbegin;
    using std::cend;
    return AssociatedData_t(
      details::associationOneToOneFullSequence<0U, 1U>
        (cbegin(assns), cend(assns), minSize)
      );
  } // makeOneTo01data(assns)
  
  //----------------------------------------------------------------------------
  
} // namespace proxy


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_ONETO01DATA_H