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>

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 std::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_(0) { }
      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() { }

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    // 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) { }
#endif

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

#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    // 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::auto_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)...) {}
#endif

    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_.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 :
      public std::binary_function<const self&, size_type, const value_type *> {
      typedef Find self;
      const value_type * operator()(typename self::first_argument_type c,
                     typename self::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;
    };
  }

}
#endif