AssociationMap.h

Go to the documentation of this file.

#ifndef DataFormats_Common_AssociationMap_h
#define DataFormats_Common_AssociationMap_h

#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/OneToValue.h"
#include "DataFormats/Common/interface/OneToOne.h"
#include "DataFormats/Common/interface/OneToMany.h"
#include "DataFormats/Common/interface/OneToManyWithQuality.h"

#include <utility>
#include "oneapi/tbb/concurrent_unordered_map.h"

namespace edm {

  class EDProductGetter;

  template <typename Tag>
  class AssociationMap {
    typedef typename Tag::val_type internal_val_type;

  public:
    typedef AssociationMap<Tag> self;
    typedef typename Tag::index_type index_type;
    typedef typename Tag::key_type key_type;
    typedef typename Tag::data_type data_type;
    typedef typename Tag::ref_type ref_type;
    typedef typename Tag::map_type map_type;
    typedef typename map_type::size_type size_type;
    typedef helpers::KeyVal<key_type, internal_val_type> value_type;
    typedef typename value_type::value_type result_type;
    typedef typename oneapi::tbb::concurrent_unordered_map<index_type, value_type> internal_transient_map_type;

    struct const_iterator {
      typedef typename self::value_type value_type;
      typedef ptrdiff_t difference_type;
      typedef value_type* pointer;
      typedef value_type& reference;
      typedef typename map_type::const_iterator::iterator_category iterator_category;
      const_iterator() : map_(nullptr) {}
      const_iterator(const self* map, typename map_type::const_iterator mi) : map_(map), i(mi) {}
      const_iterator& operator++() {
        ++i;
        return *this;
      }
      const_iterator operator++(int) {
        const_iterator ci = *this;
        ++i;
        return ci;
      }
      const_iterator& operator--() {
        --i;
        return *this;
      }
      const_iterator operator--(int) {
        const_iterator ci = *this;
        --i;
        return ci;
      }
      bool operator==(const const_iterator& ci) const { return i == ci.i; }
      bool operator!=(const const_iterator& ci) const { return i != ci.i; }
      const value_type& operator*() const { return map_->get(i->first); }
      const value_type* operator->() const { return &operator*(); }

    private:
      const self* map_;
      typename map_type::const_iterator i;
    };

    AssociationMap() {}

    // You will see better performance if you use other constructors.
    // Use this when the arguments the other constructors require are
    // not easily available.
    explicit AssociationMap(EDProductGetter const* getter) : ref_(getter) {}

    // It is rare for this to be useful
    explicit AssociationMap(const ref_type& ref) : ref_(ref) {}

    // In most cases this is the best constructor to use.
    // This constructor should be passed 2 arguments, except in the
    // case where the template parameter is OneToValue where it should
    // be passed 1 argument. In most cases, the arguments will be valid
    // Handle's to the containers. Internally, the AssociationMap holds
    // a RefProd for each container. An argument passed here is forwarded
    // to a RefProd constructor. Alternatively, you can pass in
    // a RefProd or anything else a RefProd can be constructed from.
    // The exceptional case is when the container template argument
    // is a View (For your peace of mind, I suggest you stop reading
    // this comment here if you are not dealing with the View case).
    // Usually one would not pass a Handle argument in the View
    // case. Then internally AssociationMap holds a RefToBaseProd
    // for each container instead of a RefProd and one would pass a
    // RefToBaseProd as an argument in that case. Also see the comments
    // at the top of this file that are relevant to the View case.
    // In the View case, the code would sometimes look similar to
    // the following:
    //
    //   typedef edm::AssociationMap<edm::OneToOne<edm::View<X>, edm::View<Y> > > AssocOneToOneView;
    //   edm::Handle<edm::View<X> > inputView1;
    //   event.getByToken(inputToken1V_, inputView1);
    //   edm::Handle<edm::View<Y> > inputView2;
    //   event.getByToken(inputToken2V_, inputView2);
    //   // If you are certain the Views are not empty!
    //   std::unique_ptr<AssocOneToOneView> assoc8(new AssocOneToOneView(
    //     edm::makeRefToBaseProdFrom(inputView1->refAt(0), event),
    //     edm::makeRefToBaseProdFrom(inputView2->refAt(0), event)
    //   ));

    template <typename... Args>
    AssociationMap(Args... args) : ref_(std::forward<Args>(args)...) {}

    void clear() {
      map_.clear();
      transientMap_.clear();
    }
    size_type size() const { return map_.size(); }
    bool empty() const { return map_.empty(); }
    void insert(const key_type& k, const data_type& v) { Tag::insert(ref_, map_, k, v); }
    void insert(const value_type& kv) { Tag::insert(ref_, map_, kv.key, kv.val); }
    const_iterator begin() const { return const_iterator(this, map_.begin()); }
    const_iterator end() const { return const_iterator(this, map_.end()); }
    const_iterator find(const key_type& k) const {
      if (ref_.key.id() != k.id())
        return end();
      return find(k.key());
    }
    size_type erase(const key_type& k) {
      index_type i = k.key();
      transientMap_.unsafe_erase(i);
      return map_.erase(i);
    }
    const result_type& operator[](const key_type& k) const {
      helpers::checkRef(ref_.key, k);
      return get(k.key()).val;
    }

    template <typename K>
    const result_type& operator[](const K& k) const {
      helpers::checkRef(ref_.key, k);
      return get(k.key()).val;
    }

    size_type numberOfAssociations(const key_type& k) const {
      if (ref_.key.id() != k.id())
        return 0;
      typename map_type::const_iterator f = map_.find(k.key());
      if (f == map_.end())
        return 0;
      return Tag::size(f->second);
    }

    template <typename K>
    size_type numberOfAssociations(const K& k) const {
      if (ref_.key.id() != k.id())
        return 0;
      typename map_type::const_iterator f = map_.find(k.key());
      if (f == map_.end())
        return 0;
      return Tag::size(f->second);
    }

    const ref_type& refProd() const { return ref_; }

    typename Tag::transient_map_type map() { return Tag::transientMap(ref_, map_); }
    typename Tag::transient_key_vector keys() { return Tag::transientKeyVector(ref_, map_); }
    typename Tag::transient_val_vector values() { return Tag::transientValVector(ref_, map_); }
    void post_insert() { Tag::sort(map_); }

    // Find should be private!  However, generated reflex dictionaries do not compile
    // if Find is private.
    struct Find {
      using first_argument_type = const self&;
      using second_argument_type = size_type;
      using result_type = const value_type*;

      const result_type operator()(first_argument_type c, second_argument_type i) { return &(*c.find(i)); }
    };

    //Used by ROOT storage
    CMS_CLASS_VERSION(10)

  private:
    ref_type ref_;
    map_type map_;
    mutable internal_transient_map_type transientMap_;
    const_iterator find(size_type i) const {
      typename map_type::const_iterator f = map_.find(i);
      if (f == map_.end())
        return end();
      return const_iterator(this, f);
    }
    const value_type& get(size_type i) const {
      typename internal_transient_map_type::const_iterator tf = transientMap_.find(i);
      if (tf == transientMap_.end()) {
        typename map_type::const_iterator f = map_.find(i);
        if (f == map_.end())
          Exception::throwThis(edm::errors::InvalidReference, "can't find reference in AssociationMap at position ", i);
        value_type v(key_type(ref_.key, i), Tag::val(ref_, f->second));
        std::pair<typename internal_transient_map_type::const_iterator, bool> ins =
            transientMap_.insert(std::make_pair(i, v));
        return ins.first->second;
      } else {
        return tf->second;
      }
    }
    friend struct const_iterator;
    friend struct Find;
    friend struct refhelper::FindTrait<self, value_type>;
    template <typename, typename, typename>
    friend class OneToValue;
    template <typename, typename, typename>
    friend class OneToOne;
    template <typename, typename, typename>
    friend class OneToMany;
    template <typename, typename, typename, typename>
    friend class OneToManyWithQuality;
  };

  namespace refhelper {
    template <typename Tag>
    struct FindTrait<AssociationMap<Tag>, typename AssociationMap<Tag>::value_type> {
      typedef typename AssociationMap<Tag>::Find value;
    };
  }  // namespace refhelper

}  // namespace edm
#endif