/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/DataFormats/Common/interface/OneToMany.h

Go to the documentation of this file.

#ifndef DataFormats_Common_OneToMany_h
#define DataFormats_Common_OneToMany_h
#include "DataFormats/Common/interface/AssociationMapHelpers.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/RefProd.h"
#include <map>
#include <vector>

namespace edm {
  template<typename CKey, typename CVal, typename index = unsigned int>
  class OneToMany {
    typedef edm::RefProd<CKey> KeyRefProd;
    typedef edm::RefProd<CVal> ValRefProd;
    typedef std::vector<index> map_assoc;
  public:
    typedef edm::RefVector<CVal> val_type;
    typedef edm::Ref<CKey> key_type;
    typedef edm::Ref<CVal> data_type;
    typedef index index_type;
    typedef std::map<index_type, map_assoc > map_type;
    typedef helpers::KeyVal<KeyRefProd, ValRefProd> ref_type;
    typedef std::map<const typename CKey::value_type *,
                     std::vector<const typename CVal::value_type *> 
                    > transient_map_type;
    typedef std::vector<const typename CKey::value_type *> transient_key_vector;
    typedef std::vector<std::vector<const typename CVal::value_type *> > transient_val_vector;
    static void insert(ref_type & ref, map_type & m,
                        const key_type & k, const data_type & v) {
      if (k.isNull() || v.isNull())
        Exception::throwThis(errors::InvalidReference,
          "can't insert null references in AssociationMap");
      if (ref.key.isNull()) {
        ref.key = KeyRefProd(k);
        ref.val = ValRefProd(v);
      }
      helpers::checkRef(ref.key, k); helpers::checkRef(ref.val, v);
      index_type ik = index_type(k.key()), iv = index_type(v.key());
      m[ ik ].push_back(iv);
    }
    static void insert(ref_type & ref, map_type & m, const key_type & k, const val_type & v) {
      for(typename val_type::const_iterator i = v.begin(), iEnd = v.end(); i != iEnd; ++i)
      insert(ref, m, k, *i);
    }
    static val_type val(const ref_type & ref, const map_assoc & iv) {
      val_type v;
      for(typename map_assoc::const_iterator idx = iv.begin(), idxEnd = iv.end(); idx != idxEnd; ++idx)
        v.push_back(edm::Ref<CVal>(ref.val, *idx));
      return v;
    }
    static typename map_type::size_type size(const map_assoc & v) { return v.size(); }
    static void sort(map_type &) { }
    static transient_map_type transientMap(const ref_type & ref, const map_type & map) {
      transient_map_type m;
      const CKey & ckey = * ref.key;
      const CVal & cval = * ref.val;
      for(typename map_type::const_iterator i = map.begin(); i != map.end(); ++ i) {
        const map_assoc & a = i->second;
        const typename CKey::value_type * k = & ckey[ i->first ];
        std::vector<const typename CVal::value_type *> v;
        for(typename map_assoc::const_iterator j = a.begin(); j != a.end(); ++j) {
          const typename CVal::value_type * val = & cval[ *j ];
          v.push_back(val);
        }
        m.insert(std::make_pair(k, v));
      }
      return m;
    }
    static transient_key_vector transientKeyVector(const ref_type & ref, const map_type & map) {
      transient_key_vector m;
      const CKey & ckey = * ref.key;
      for(typename map_type::const_iterator i = map.begin(); i != map.end(); ++ i)
        m.push_back(& ckey[i->first]);
      return m;
    }
    static transient_val_vector transientValVector(const ref_type & ref, const map_type & map) {
      transient_val_vector m;
      const CVal & cval = * ref.val;
      for(typename map_type::const_iterator i = map.begin(); i != map.end(); ++ i) {
        const map_assoc & a = i->second;
        std::vector<const typename CVal::value_type *> v;
        m.push_back(v);
        for(typename map_assoc::const_iterator j = a.begin(); j != a.end(); ++j)
          m.back().push_back(& cval[ *j ]);
      }
      return m;
    }
  };
}

#endif