TreeFiller/interface/AssociationMap.h

//--------------------------------------------------------------------------------------------------
// $Id: AssociationMap.h,v 1.9 2009/03/15 11:20:40 loizides Exp $
//
// AssociationMap
//
// Wrapper for std::map, used to resolve links during tree filling.
//
// Authors: C.Paus, J.Bendavid, C.Loizides
//--------------------------------------------------------------------------------------------------

#ifndef MITPROD_TREEFILLER_ASSOCIATIONMAP_H
#define MITPROD_TREEFILLER_ASSOCIATIONMAP_H

#include <map>
#include <TObject.h>
#include "FWCore/MessageLogger/interface/MessageLogger.h"

namespace mithep
{
  template <class EdmClass, class MitClass> class AssociationMap : public TObject
  { 
  public:
    typedef std::map<EdmClass, MitClass> fwdMapType;
    typedef std::map<MitClass, EdmClass> revMapType;
    
    AssociationMap() : edmProductId_(0) {}
    ~AssociationMap() {}
    
    void              Add(EdmClass edmObj, MitClass mitObj);
    EdmClass          GetEdm(MitClass mitObj)    const;
    Int_t             GetEdmProductId()          const { return edmProductId_;  }
    Int_t             GetEntries()               const { return fwdMap_.size(); }
    MitClass          GetMit(EdmClass edmObj)    const;
    const char       *GetBrName()                const { return brname_.c_str();           }
    bool              HasMit(EdmClass edmObj)    const;
    void              Reset()                          { fwdMap_.clear(); revMap_.clear(); }
    void              SetEdmProductId(Int_t id)        { edmProductId_ = id;               }
    void              SetBrName(const std::string &n)  { brname_ = n;                      }
    void              SetBrName(const char *n)         { brname_ = n;                      }
    const fwdMapType &FwdMap()                   const { return fwdMap_;                   }
    const revMapType &RevMap()                   const { return revMap_;                   }
    
  protected:
    fwdMapType   fwdMap_;       //map between edm ref and mit ptr 
    revMapType   revMap_;       //map between mit ptr and edm ref
    Int_t        edmProductId_; //product id for consistency check
    std::string  brname_;       //branch name of MIT objects 
  };
}

//--------------------------------------------------------------------------------------------------
template <class EdmClass, class MitClass>
inline void mithep::AssociationMap<EdmClass,MitClass>::Add(EdmClass edmObj, MitClass mitObj) 
{
  fwdMap_[edmObj]=mitObj;
  revMap_.insert(std::pair<MitClass, EdmClass>(mitObj,edmObj));
}

//--------------------------------------------------------------------------------------------------
template <class EdmClass, class MitClass>
inline MitClass mithep::AssociationMap<EdmClass,MitClass>::GetMit(EdmClass edmObj) const
{
  typename fwdMapType::const_iterator iter = fwdMap_.find(edmObj);

  if (iter != fwdMap_.end())
    return iter->second;
  else throw edm::Exception(edm::errors::Configuration, "AssociationMap::GetMit()\n")
         << "Error! EDM Object (" << typeid(edmObj).name() 
         << ") not found in AssociationMap (" << typeid(*this).name() << ")." << std::endl;
}
      
//--------------------------------------------------------------------------------------------------
template <class EdmClass, class MitClass>
inline EdmClass mithep::AssociationMap<EdmClass,MitClass>::GetEdm(MitClass mitObj) const
{
  typename revMapType::const_iterator iter = revMap_.find(mitObj);
  if (iter != revMap_.end())
    return iter->second;
  else throw edm::Exception(edm::errors::Configuration, "AssociationMap::GetEdm()\n")
         << "Error! MITHEP Object (" << typeid(mitObj).name() 
         << ") not found in AssociationMap (" << typeid(*this).name() << ")." << std::endl;
}

//--------------------------------------------------------------------------------------------------
template <class EdmClass, class MitClass>
inline bool mithep::AssociationMap<EdmClass,MitClass>::HasMit(EdmClass edmObj) const
{
  typename fwdMapType::const_iterator iter = fwdMap_.find(edmObj);

  if (iter != fwdMap_.end())
    return true;
  else 
    return false;
}
#endif
Revision:	1.9.2.1
Committed:	Tue May 15 23:31:20 2012 UTC (12 years, 11 months ago) by paus
Content type:	text/plain
Branch:	Mit_025c_branch
CVS Tags:	Mit_025c_branch2, Mit_025c_branch1, Mit_025c_branch0
Changes since 1.9:	+25 -23 lines
Log Message:	Backporting from 5x.
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	paus	1.9.2.1	// $Id: AssociationMap.h,v 1.9 2009/03/15 11:20:40 loizides Exp $
3	loizides	1.1	//
4	loizides	1.9	// AssociationMap
5	loizides	1.1	//
6	loizides	1.2	// Wrapper for std::map, used to resolve links during tree filling.
7	loizides	1.1	//
8	paus	1.9.2.1	// Authors: C.Paus, J.Bendavid, C.Loizides
9	loizides	1.1	//--------------------------------------------------------------------------------------------------
10
11	loizides	1.6	#ifndef MITPROD_TREEFILLER_ASSOCIATIONMAP_H
12			#define MITPROD_TREEFILLER_ASSOCIATIONMAP_H
13	loizides	1.1
14			#include <map>
15			#include <TObject.h>
16	bendavid	1.3	#include "FWCore/MessageLogger/interface/MessageLogger.h"
17	loizides	1.1
18			namespace mithep
19			{
20			template <class EdmClass, class MitClass> class AssociationMap : public TObject
21			{
22	paus	1.9.2.1	public:
23	loizides	1.1	typedef std::map<EdmClass, MitClass> fwdMapType;
24			typedef std::map<MitClass, EdmClass> revMapType;
25
26	paus	1.9.2.1	AssociationMap() : edmProductId_(0) {}
27			~AssociationMap() {}
28
29			void Add(EdmClass edmObj, MitClass mitObj);
30			EdmClass GetEdm(MitClass mitObj) const;
31			Int_t GetEdmProductId() const { return edmProductId_; }
32			Int_t GetEntries() const { return fwdMap_.size(); }
33			MitClass GetMit(EdmClass edmObj) const;
34			const char *GetBrName() const { return brname_.c_str(); }
35			bool HasMit(EdmClass edmObj) const;
36			void Reset() { fwdMap_.clear(); revMap_.clear(); }
37			void SetEdmProductId(Int_t id) { edmProductId_ = id; }
38			void SetBrName(const std::string &n) { brname_ = n; }
39			void SetBrName(const char *n) { brname_ = n; }
40			const fwdMapType &FwdMap() const { return fwdMap_; }
41			const revMapType &RevMap() const { return revMap_; }
42
43			protected:
44			fwdMapType fwdMap_; //map between edm ref and mit ptr
45			revMapType revMap_; //map between mit ptr and edm ref
46			Int_t edmProductId_; //product id for consistency check
47			std::string brname_; //branch name of MIT objects
48	loizides	1.2	};
49			}
50
51			//--------------------------------------------------------------------------------------------------
52			template <class EdmClass, class MitClass>
53			inline void mithep::AssociationMap<EdmClass,MitClass>::Add(EdmClass edmObj, MitClass mitObj)
54			{
55			fwdMap_[edmObj]=mitObj;
56			revMap_.insert(std::pair<MitClass, EdmClass>(mitObj,edmObj));
57			}
58
59			//--------------------------------------------------------------------------------------------------
60			template <class EdmClass, class MitClass>
61			inline MitClass mithep::AssociationMap<EdmClass,MitClass>::GetMit(EdmClass edmObj) const
62			{
63			typename fwdMapType::const_iterator iter = fwdMap_.find(edmObj);
64
65			if (iter != fwdMap_.end())
66			return iter->second;
67	bendavid	1.3	else throw edm::Exception(edm::errors::Configuration, "AssociationMap::GetMit()\n")
68	loizides	1.4	<< "Error! EDM Object (" << typeid(edmObj).name()
69			<< ") not found in AssociationMap (" << typeid(*this).name() << ")." << std::endl;
70	loizides	1.2	}
71	loizides	1.1
72	loizides	1.2	//--------------------------------------------------------------------------------------------------
73			template <class EdmClass, class MitClass>
74	loizides	1.4	inline EdmClass mithep::AssociationMap<EdmClass,MitClass>::GetEdm(MitClass mitObj) const
75	loizides	1.2	{
76			typename revMapType::const_iterator iter = revMap_.find(mitObj);
77			if (iter != revMap_.end())
78			return iter->second;
79	loizides	1.4	else throw edm::Exception(edm::errors::Configuration, "AssociationMap::GetEdm()\n")
80			<< "Error! MITHEP Object (" << typeid(mitObj).name()
81			<< ") not found in AssociationMap (" << typeid(*this).name() << ")." << std::endl;
82	loizides	1.1	}
83	sixie	1.5
84			//--------------------------------------------------------------------------------------------------
85			template <class EdmClass, class MitClass>
86			inline bool mithep::AssociationMap<EdmClass,MitClass>::HasMit(EdmClass edmObj) const
87			{
88			typename fwdMapType::const_iterator iter = fwdMap_.find(edmObj);
89
90			if (iter != fwdMap_.end())
91			return true;
92			else
93			return false;
94			}
95	loizides	1.1	#endif