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 <cstdlib>     // std::size_t
#include <iterator>    // std::cbegin(), std::cend()
#include <tuple>       // std::tuple_element_t<>, std::get()
#include <type_traits> // std::is_convertible<>
#include <utility>     // std::move()
#include <vector>

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