EcalContainer.h

Go to the documentation of this file.

#ifndef ECALDETID_ECALCONTAINER_H
#define ECALDETID_ECALCONTAINER_H

#include "DataFormats/DetId/interface/DetId.h"
#include <vector>
#include <utility>
#include <algorithm>

// #include <iostream>



/* a generic container for ecal items
 * provides access by hashedIndex and by DetId...
 */

template<typename DetId, typename T>
class EcalContainer {

        public:

                typedef EcalContainer<DetId, T> self;
                typedef T Item;
                typedef Item value_type;
                typedef typename std::vector<Item> Items; 
                typedef typename std::vector<Item>::const_iterator const_iterator;
                typedef typename std::vector<Item>::iterator iterator;

                   
                EcalContainer() {checkAndResize();}

                void insert(std::pair<uint32_t, Item> const &a) {
                        (*this)[a.first] = a.second;
                }

                inline const Item & item(size_t hashid) const {
                        return m_items[hashid];
                }

                inline const Items & items() const {
                        return m_items;
                }

                inline Item & operator[](uint32_t rawId) {
          checkAndResize();
          static Item dummy;
          DetId id(rawId);
          if ( !isValidId(id) ) return dummy;
          return m_items[id.hashedIndex()];
                }


        void checkAndResize() {
          if (m_items.empty()) {
            //          std::cout << "resizing to " << DetId::kSizeForDenseIndexing << std::endl;
            m_items.resize(DetId::kSizeForDenseIndexing);
          }
        }


        void checkAndResize( size_t priv_size ) {
          // this method allows to resize the vector to a specific size forcing a specific value
          if (m_items.empty()) {
            //          std::cout << "resizing to " << priv_size << std::endl;
            m_items.resize(priv_size);
          }
        }

                inline Item const & operator[](uint32_t rawId) const {
          //                        if (m_items.size()==0) {
          //      std::cout << "resizing to " << DetId::kSizeForDenseIndexing << std::endl;
                  //              m_items.resize((size_t) DetId::kSizeForDenseIndexing);
                  //      }
                        DetId id(rawId);
                        if ( !isValidId(id) ) return dummy_item();
                        return m_items[id.hashedIndex()];
                }

                inline const_iterator find(uint32_t rawId) const {
                        DetId ib(rawId);
                        if ( !isValidId(ib) ) return m_items.end();
                        return m_items.begin() + ib.hashedIndex();
                }

                inline const_iterator begin() const {
                        return m_items.begin();
                }

                inline const_iterator end() const {
                        return m_items.end();
                }

                inline size_t size() const {
                        return m_items.size();
                }

                void setItems(const std::vector<Item> & items) {
                    m_items = items;
                }
        private:

        //Cint can't parse the new C++11 initialization syntax
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)

        static const Item& dummy_item() {
          static const Item s_dummy{};
          return s_dummy;
        }
#else
        static const Item& dummy_item();
#endif
                // not protected on EB <--> EE swap -- FIXME?
                inline bool isValidId(const DetId id) const {
                        return id.det() == ::DetId::Ecal;
                };

                std::vector<Item> m_items;

};



#endif // ECALCONTAINER