MuonDigiCollection.h

Go to the documentation of this file.

#ifndef DataFormats_MuonDigiCollection_h
#define DataFormats_MuonDigiCollection_h
 
#include <vector>
#include <map>
#include <iterator>
 
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