MuonDigiCollection.h

Go to the documentation of this file.

#ifndef DataFormats_MuonDigiCollection_h
#define DataFormats_MuonDigiCollection_h

#include <vector>
#include <map>
#include <iterator>
#include "FWCore/Utilities/interface/GCC11Compatibility.h"


template <typename IndexType, typename DigiType>
  class DigiContainerIterator {
  public:
    typedef typename std::vector<DigiType>::const_iterator  DigiRangeIterator;
    typedef std::map<IndexType, std::vector<DigiType> >     BaseContainer;
    typedef typename BaseContainer::const_iterator          BaseIterator;

    typedef std::pair<IndexType,
              std::pair<DigiRangeIterator,
                DigiRangeIterator> >        value_type;
    typedef value_type                                      reference;
    typedef void                                            pointer;
    typedef typename DigiRangeIterator::difference_type     difference_type;
    typedef typename DigiRangeIterator::iterator_category   iterator_category;

    DigiContainerIterator (void) {}
    DigiContainerIterator (BaseIterator i) : base_ (i) {}
    // implicit copy constructor
    // implicit assignment operator
    // implicit destructor

    DigiContainerIterator operator++ (int)
    { return DigiContainerIterator (base_++); }
    
    DigiContainerIterator &operator++ (void)
    { ++base_; return *this; }

    bool operator== (const DigiContainerIterator &x) const
    { return x.base_ == base_; }

    bool operator!= (const DigiContainerIterator &x) const
    { return x.base_ != base_; }

    value_type operator* (void) const
    {
      return std::make_pair(base_->first,
                std::make_pair(base_->second.begin(), 
                       base_->second.end()));
    }


  private:
    BaseIterator base_;
  };




template <typename IndexType, 
      typename DigiType>
class MuonDigiCollection {
  
public:

  MuonDigiCollection(){}

//  void swap(MuonDigiCollection<IndexType,DigiType> & rh) { std::swap(data_,rh.data_);}
  void swap(MuonDigiCollection & rh) { std::swap(data_,rh.data_);}

  typedef typename std::vector<DigiType>::const_iterator const_iterator;
  typedef typename std::pair<const_iterator,const_iterator> Range;
  
  
  void insertDigi(const IndexType& index, const DigiType& digi){
    std::vector<DigiType> &digis = data_[index];
    digis.push_back(digi);
  }
  
  void put(Range range, const IndexType& index){
    std::vector<DigiType> &digis = data_[index];
    digis.reserve (digis.size () + (range.second - range.first));
    std::copy (range.first, range.second, std::back_inserter (digis));
    
  }
 
#ifndef CMS_NOCXX11
  template<typename IRange>
  void move(IRange range, const IndexType& index){
    std::vector<DigiType> &digis = data_[index];
    digis.reserve (digis.size () + (range.second - range.first));
    digis.insert(digis.end(),std::make_move_iterator(range.first), std::make_move_iterator(range.second));    
  }
#endif


  Range get(const IndexType& index) const{
    typename container::const_iterator it = data_.find(index);
    if (it==data_.end()) {
      // if data_ is empty there is no other way to get an empty range
      static const std::vector<DigiType> empty;
      return std::make_pair(empty.end(),empty.end());
    } 
    const std::vector<DigiType>& digis = (*it).second;
    return std::make_pair(digis.begin(),digis.end());
  }
  
  typedef DigiContainerIterator<IndexType,DigiType> DigiRangeIterator;
  
  DigiRangeIterator begin() const { 
    return data_.begin();}
  
  DigiRangeIterator end() const {
    return data_.end();}
  
  
private:

  typedef  std::map<IndexType,std::vector<DigiType> > container;  
  container data_;
  

}; // MuonDigiCollection

template <typename IndexType,
          typename DigiType>
inline
void swap(MuonDigiCollection<IndexType,DigiType> & rh,
          MuonDigiCollection<IndexType,DigiType> & lh){ rh.swap(lh);}

#endif