CMS 3D CMS Logo

/data/refman/pasoursint/CMSSW_5_3_3/src/CondFormats/EcalObjects/interface/EcalCondObjectContainer.h

Go to the documentation of this file.
00001 #ifndef ECAL_COND_OBJECT_CONTAINER_HH
00002 #define ECAL_COND_OBJECT_CONTAINER_HH
00003 
00004 #include "DataFormats/EcalDetId/interface/EcalContainer.h"
00005 #include "DataFormats/EcalDetId/interface/EBDetId.h"
00006 #include "DataFormats/EcalDetId/interface/EEDetId.h"
00007 
00008 template < typename T >
00009 class EcalCondObjectContainer {
00010         public:
00011                 typedef T Item;
00012                 typedef Item value_type;
00013                 typedef EcalCondObjectContainer<T> self;
00014                 typedef typename std::vector<Item> Items;
00015                 typedef typename std::vector<Item>::const_iterator const_iterator; 
00016                 typedef typename std::vector<Item>::iterator iterator;
00017 
00018                 EcalCondObjectContainer() {};
00019                 ~EcalCondObjectContainer() {};
00020 
00021                 inline
00022                 const Items & barrelItems() const { return eb_.items(); };
00023 
00024                 inline
00025                 const Items & endcapItems() const { return ee_.items(); };
00026 
00027                 inline
00028                 const Item & barrel( size_t hashedIndex ) const {
00029                         return eb_.item(hashedIndex);
00030                 }
00031                 
00032                 inline
00033                 const Item & endcap( size_t hashedIndex ) const {
00034                         return ee_.item(hashedIndex);
00035                 }
00036 
00037                 inline
00038                 void insert( std::pair<uint32_t, Item> const &a ) {
00039                         DetId id(a.first);
00040                         switch (id.subdetId()) {
00041                                 case EcalBarrel :
00042                                         { 
00043                                                 eb_.insert(a);
00044                                         }
00045                                         break;
00046                                 case EcalEndcap :
00047                                         { 
00048                                                 ee_.insert(a);
00049                                         }
00050                                         break;
00051                                 default:
00052                                         // FIXME (add throw)
00053                                         return;
00054                         }
00055                 }
00056                 
00057                 inline
00058                 const_iterator find( uint32_t rawId ) const {
00059                         DetId id(rawId);
00060                         switch (id.subdetId()) {
00061                                 case EcalBarrel :
00062                                         { 
00063                                                 const_iterator it = eb_.find(rawId);
00064                                                 if ( it != eb_.end() ) {
00065                                                         return it;
00066                                                 } else {
00067                                                         return ee_.end();
00068                                                 }
00069                                         }
00070                                         break;
00071                                 case EcalEndcap :
00072                                         { 
00073                                                 return ee_.find(rawId);
00074                                         }
00075                                         break;
00076                                 default:
00077                                         // FIXME (add throw)
00078                                         return ee_.end();
00079                         }
00080                 }
00081 
00082                 inline
00083                 const_iterator begin() const {
00084                         return eb_.begin();
00085                 }
00086 
00087                 inline
00088                 const_iterator end() const {
00089                         return ee_.end();
00090                 }
00091 
00092                 inline
00093                 void setValue(const uint32_t id, const Item &item) {
00094                         (*this)[id] = item;
00095                 }
00096 
00097                 inline
00098                 const self & getMap() const {
00099                         return *this;
00100                 }
00101 
00102                 inline
00103                 size_t size() const {
00104                         return eb_.size() + ee_.size();
00105                 }
00106                 // add coherent operator++, not needed now -- FIXME
00107 
00108                 inline
00109                 Item & operator[]( uint32_t rawId ) {
00110                         DetId id(rawId);
00111                         static Item dummy;
00112                         switch (id.subdetId()) {
00113                                 case EcalBarrel :
00114                                         { 
00115                                                 return eb_[rawId];
00116                                         }
00117                                         break;
00118                                 case EcalEndcap :
00119                                         { 
00120                                                 return ee_[rawId];
00121                                         }
00122                                         break;
00123                                 default:
00124                                         // FIXME (add throw)
00125                                         return dummy;
00126                         }
00127                 }
00128                 
00129                 inline
00130                 Item const & operator[]( uint32_t rawId ) const {
00131                         DetId id(rawId);
00132                         static Item dummy;
00133                         switch (id.subdetId()) {
00134                                 case EcalBarrel :
00135                                         { 
00136                                                 return eb_[rawId];
00137                                         }
00138                                         break;
00139                                 case EcalEndcap :
00140                                         { 
00141                                                 return ee_[rawId];
00142                                         }
00143                                         break;
00144                                 default:
00145                                         // FIXME (add throw)
00146                                         return dummy;
00147                         }
00148                 }
00149                 
00150         private:
00151                 EcalContainer< EBDetId, Item > eb_;
00152                 EcalContainer< EEDetId, Item > ee_;
00153 };
00154 
00155 typedef EcalCondObjectContainer<float> EcalFloatCondObjectContainer;
00156 #endif