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"

namespace edm {
  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_)[ i->first ]; }
      const value_type * operator->() const { return &operator *(); }
    private:
      const self * map_;
      typename map_type::const_iterator i;
    };

    AssociationMap() { }
    explicit
    AssociationMap(const ref_type & ref) : ref_(ref) { }
    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 operator[](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);
    }
    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 & operator[](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