00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef OPENMS_KERNEL_DPEAKCONSTREFERENCEARRAY_H
00028 #define OPENMS_KERNEL_DPEAKCONSTREFERENCEARRAY_H
00029
00030 #include <OpenMS/config.h>
00031 #include <OpenMS/CONCEPT/Types.h>
00032 #include <OpenMS/CONCEPT/Exception.h>
00033 #include <OpenMS/KERNEL/ComparatorUtils.h>
00034 #include <OpenMS/CONCEPT/Macros.h>
00035
00036 #include <vector>
00037
00038 namespace OpenMS
00039 {
00040
00052 template <typename MapT>
00053 class DPeakConstReferenceArray
00054 {
00055 public:
00056
00058 template <class IteratorPeakT>
00059 class DPeakConstReferenceArrayConstIterator
00060 {
00061
00062 friend class DPeakConstReferenceArray;
00063
00064 public:
00065 typedef IteratorPeakT IteratorPeakType;
00066 typedef IteratorPeakType value_type;
00067 typedef typename std::vector<IteratorPeakType*>::difference_type difference_type;
00068 typedef const value_type& reference;
00069 typedef const value_type* pointer;
00070 typedef std::random_access_iterator_tag iterator_category;
00071
00072 DPeakConstReferenceArrayConstIterator()
00073 {}
00074
00075 DPeakConstReferenceArrayConstIterator(const typename std::vector<IteratorPeakType*>* vec , unsigned int position)
00076 {
00077 vector_ = (typename std::vector<IteratorPeakType*>*)vec;
00078 position_ = position;
00079 }
00080
00081 DPeakConstReferenceArrayConstIterator(typename std::vector<IteratorPeakType*>* vec , unsigned int position)
00082 {
00083 vector_ = vec;
00084 position_ = position;
00085 }
00086
00087 DPeakConstReferenceArrayConstIterator(const DPeakConstReferenceArrayConstIterator& it)
00088 {
00089 vector_=it.vector_;
00090 position_=it.position_;
00091 }
00092
00093 ~DPeakConstReferenceArrayConstIterator()
00094 {}
00095
00096 DPeakConstReferenceArrayConstIterator& operator = (const DPeakConstReferenceArrayConstIterator& rhs)
00097 {
00098 if (this==&rhs) return *this;
00099
00100 vector_=rhs.vector_;
00101 position_=rhs.position_;
00102
00103 return *this;
00104 }
00105
00106 bool operator < (const DPeakConstReferenceArrayConstIterator& it) const
00107 {
00108 return position_ < it.position_;
00109 }
00110
00111 bool operator > (const DPeakConstReferenceArrayConstIterator& it) const
00112 {
00113 return position_ > it.position_;
00114 }
00115
00116 bool operator <= (const DPeakConstReferenceArrayConstIterator& it) const
00117 {
00118 return (position_ < it.position_ || position_ == it.position_);
00119 }
00120
00121 bool operator >= (const DPeakConstReferenceArrayConstIterator& it) const
00122 {
00123 return (position_ > it.position_ || position_ == it.position_);
00124 }
00125
00126 bool operator == (const DPeakConstReferenceArrayConstIterator& it) const
00127 {
00128 return position_ == it.position_ && vector_ == it.vector_;
00129 }
00130
00131 bool operator != (const DPeakConstReferenceArrayConstIterator& it) const
00132 {
00133 return position_ != it.position_ || vector_ != it.vector_;
00134 }
00135
00136 DPeakConstReferenceArrayConstIterator& operator ++ ()
00137 {
00138 position_ += 1;
00139 return *this;
00140 }
00141
00142 DPeakConstReferenceArrayConstIterator operator ++ (int)
00143 {
00144 DPeakConstReferenceArrayConstIterator tmp(*this);
00145 ++(*this);
00146 return tmp;
00147 }
00148
00149 DPeakConstReferenceArrayConstIterator& operator -- ()
00150 {
00151 position_-=1;
00152 return *this;
00153 }
00154
00155 DPeakConstReferenceArrayConstIterator operator -- (int)
00156 {
00157 DPeakConstReferenceArrayConstIterator tmp(*this);
00158 --(*this);
00159 return tmp;
00160 }
00161
00162 DPeakConstReferenceArrayConstIterator operator - (difference_type n) const
00163 {
00164 DPeakConstReferenceArrayConstIterator tmp(*this);
00165 tmp.position_ -= n;
00166 return tmp;
00167 }
00168
00169 DPeakConstReferenceArrayConstIterator operator + (difference_type n) const
00170 {
00171 DPeakConstReferenceArrayConstIterator tmp(*this);
00172 tmp.position_ += n;
00173 return tmp;
00174 }
00175
00176 DPeakConstReferenceArrayConstIterator& operator += (difference_type n)
00177 {
00178 position_ += n;
00179 return *this;
00180 }
00181
00182 DPeakConstReferenceArrayConstIterator& operator -= (difference_type n)
00183 {
00184 position_ -= n;
00185 return *this;
00186 }
00187
00188 friend difference_type operator - ( const DPeakConstReferenceArrayConstIterator& i1, const DPeakConstReferenceArrayConstIterator& i2 )
00189 {
00190 return (i1.position_ - i2.position_);
00191 }
00192
00193 friend DPeakConstReferenceArrayConstIterator operator + ( difference_type n, const DPeakConstReferenceArrayConstIterator& i )
00194 {
00195 DPeakConstReferenceArrayConstIterator tmp(i);
00196 tmp.position_ += n;
00197 return tmp;
00198 }
00199
00200 reference operator * ()
00201 {
00202 return *((*vector_)[position_]);
00203 }
00204
00205 pointer operator -> ()
00206 {
00207 return (*vector_)[position_];
00208 }
00209
00210 pointer operator -> () const
00211 {
00212 return (*vector_)[position_];
00213 }
00214
00215
00216 protected:
00217
00218 typename std::vector<IteratorPeakType*>* vector_;
00219 unsigned int position_;
00220 };
00221
00222
00224 template <class IteratorPeakT>
00225 class DPeakConstReferenceArrayIterator : public DPeakConstReferenceArrayConstIterator<IteratorPeakT>
00226 {
00227 friend class DPeakConstReferenceArray;
00228
00229 public:
00230 typedef IteratorPeakT IteratorPeakType;
00231 typedef typename DPeakConstReferenceArrayConstIterator<IteratorPeakType>::value_type& reference;
00232 typedef typename DPeakConstReferenceArrayConstIterator<IteratorPeakType>::value_type* pointer;
00233
00234 using DPeakConstReferenceArrayConstIterator<IteratorPeakType>::vector_;
00235 using DPeakConstReferenceArrayConstIterator<IteratorPeakType>::position_;
00236
00237
00238 DPeakConstReferenceArrayIterator()
00239 {}
00240
00241 DPeakConstReferenceArrayIterator(typename std::vector<IteratorPeakType*>* vec, unsigned int position): DPeakConstReferenceArrayConstIterator<IteratorPeakType>(vec,position)
00242 {}
00243
00244 DPeakConstReferenceArrayIterator(const DPeakConstReferenceArrayIterator<IteratorPeakType>& it): DPeakConstReferenceArrayConstIterator<IteratorPeakType>(it)
00245 {}
00246
00247 ~DPeakConstReferenceArrayIterator()
00248 {}
00249
00250 reference operator * ()
00251 {
00252 return *((*vector_)[position_]);
00253 }
00254
00255 pointer operator -> ()
00256 {
00257 return (*vector_)[position_];
00258 }
00259
00260 const pointer operator -> () const
00261 {
00262 return (*vector_)[position_];
00263 }
00264
00265
00266 DPeakConstReferenceArrayIterator& operator ++ ()
00267 {
00268 DPeakConstReferenceArrayConstIterator<IteratorPeakType>::position_+=1;
00269 return *this;
00270 }
00271
00272 DPeakConstReferenceArrayIterator operator ++ (int)
00273 {
00274 DPeakConstReferenceArrayIterator tmp(*this);
00275 ++(*this);
00276 return tmp;
00277 }
00278
00279 DPeakConstReferenceArrayIterator& operator -- ()
00280 {
00281 DPeakConstReferenceArrayConstIterator<IteratorPeakType>::position_-=1;
00282 return *this;
00283 }
00284
00285 DPeakConstReferenceArrayIterator operator -- (int)
00286 {
00287 DPeakConstReferenceArrayIterator tmp(*this);
00288 --(*this);
00289 return tmp;
00290 }
00291
00292 DPeakConstReferenceArrayIterator operator - (typename DPeakConstReferenceArrayIterator::difference_type n) const
00293 {
00294 DPeakConstReferenceArrayIterator tmp(*this);
00295 tmp.position_ -= n;
00296 return tmp;
00297 }
00298
00299 DPeakConstReferenceArrayIterator operator + (typename DPeakConstReferenceArrayIterator::difference_type n) const
00300 {
00301 DPeakConstReferenceArrayIterator tmp(*this);
00302 tmp.position_ += n;
00303 return tmp;
00304 }
00305
00306 friend DPeakConstReferenceArrayIterator operator + (typename DPeakConstReferenceArrayIterator::difference_type n, const DPeakConstReferenceArrayIterator& i )
00307 {
00308 DPeakConstReferenceArrayIterator tmp(i);
00309 tmp.position_ += n;
00310 return tmp;
00311 }
00312
00313 DPeakConstReferenceArrayIterator& operator += (typename DPeakConstReferenceArrayIterator::difference_type n)
00314 {
00315 DPeakConstReferenceArrayConstIterator<IteratorPeakType>::position_ += n;
00316 return *this;
00317 }
00318
00319 DPeakConstReferenceArrayIterator& operator -= (typename DPeakConstReferenceArrayIterator::difference_type n)
00320 {
00321 DPeakConstReferenceArrayConstIterator<IteratorPeakType>::position_ -= n;
00322 return *this;
00323 }
00324
00325 friend void swap(DPeakConstReferenceArrayIterator& i1, DPeakConstReferenceArrayIterator& i2)
00326 {
00327 unsigned int tmp = i1.position_;
00328 i1.position_ = i2.position_;
00329 i2.position_ = tmp;
00330 }
00331
00332 protected:
00333
00334 };
00335
00340 typedef MapT BaseMapType;
00341 typedef typename BaseMapType::value_type PeakType;
00342 enum { DIMENSION=PeakType::DIMENSION };
00343 typedef DPeakConstReferenceArrayIterator<const PeakType> Iterator;
00344 typedef DPeakConstReferenceArrayConstIterator<const PeakType> ConstIterator;
00345 typedef std::reverse_iterator<Iterator> ReverseIterator;
00346 typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
00347 typedef typename std::vector<PeakType>::value_type value_type;
00348 typedef typename std::vector<PeakType>::size_type size_type;
00349 typedef typename std::vector<PeakType>::difference_type difference_type;
00350 typedef typename std::vector<PeakType>::reference reference;
00351 typedef typename std::vector<PeakType>::const_reference const_reference;
00352 typedef typename std::vector<PeakType>::pointer pointer;
00353 typedef Iterator iterator;
00354 typedef ConstIterator const_iterator;
00355 typedef ReverseIterator reverse_iterator;
00356 typedef ConstReverseIterator const_reverse_iterator;
00358
00359
00361 void push_back(const PeakType& x)
00362 {
00363 const PeakType* element = &x;
00364 vector_.push_back(element);
00365 }
00366
00368 void pop_back()
00369 {
00370 vector_.pop_back();
00371 }
00372
00374 size_type size() const
00375 {
00376 return vector_.size();
00377 }
00378
00380 size_type capacity() const
00381 {
00382 return std::max(vector_.size(),capacity_);
00383 }
00384
00386 void reserve(size_type n)
00387 {
00388 size_type cap = capacity();
00389
00390 if (n>cap)
00391 {
00392 vector_.reserve(n);
00393 capacity_ = n;
00394 }
00395 }
00396
00398 size_type max_size() const
00399 {
00400 return vector_.max_size();
00401 }
00402
00404 Iterator begin()
00405 {
00406 return Iterator((std::vector<const PeakType*>*)&vector_,(unsigned int)0);
00407 }
00408
00410 Iterator end()
00411 {
00412 return Iterator((std::vector<const PeakType*>*)&vector_,(unsigned int)(vector_.size()));
00413 }
00414
00416 ConstIterator begin() const
00417 {
00418 return ConstIterator((const std::vector<const PeakType*>*)&vector_,(unsigned int)0);
00419 }
00420
00422 ConstIterator end() const
00423 {
00424 return ConstIterator((const std::vector< const PeakType*>*)&vector_,(unsigned int)(vector_.size()));
00425 }
00426
00428 ReverseIterator rbegin()
00429 {
00430 return ReverseIterator(end());
00431 }
00432
00434 ReverseIterator rend()
00435 {
00436 return ReverseIterator(begin());
00437 }
00438
00440 ConstReverseIterator rbegin() const
00441 {
00442 return ConstReverseIterator(end());
00443 }
00444
00446 ConstReverseIterator rend() const
00447 {
00448 return ConstReverseIterator(begin());
00449 }
00450
00452 void resize(size_type new_size)
00453 {
00454 vector_.resize(new_size);
00455 capacity_ = vector_.capacity();
00456 }
00457
00459 void resize(size_type new_size, const PeakType& t)
00460 {
00461 vector_.resize(new_size,&t);
00462 capacity_ = vector_.capacity();
00463 }
00464
00466 const_reference front() const
00467 {
00468 return *(begin());
00469 }
00470
00472 const_reference back() const
00473 {
00474 return *(end()-1);
00475 }
00476
00478 void clear()
00479 {
00480 vector_.clear();
00481 }
00482
00484 bool empty() const
00485 {
00486 return vector_.empty();
00487 }
00488
00490 const_reference operator [](size_type n) const
00491 {
00492 return *(vector_[n]);
00493 }
00494
00496 bool operator == (const DPeakConstReferenceArray& array) const
00497 {
00498 if (base_container_ptr_ != array.base_container_ptr_)
00499 {
00500 return false;
00501 }
00502 if (size()!=array.size())
00503 {
00504 return false;
00505 }
00506 for (unsigned int i=0;i<size();i++)
00507 {
00508 if (typeid(*(vector_[i]))!=typeid(*(array.vector_[i])))
00509 {
00510 return false;
00511 }
00512 if ( vector_[i]->operator!=(*array.vector_[i]) )
00513 {
00514 return false;
00515 }
00516 }
00517 return true;
00518 }
00519
00521 bool operator !=(const DPeakConstReferenceArray& array) const
00522 {
00523 return !(operator==(array));
00524 }
00525
00527 bool operator < (const DPeakConstReferenceArray& array) const
00528 {
00529 return size() < array.size();
00530 }
00531
00533 bool operator > (const DPeakConstReferenceArray& array) const
00534 {
00535 return size() > array.size();
00536 }
00537
00539 bool operator <= (const DPeakConstReferenceArray& array) const
00540 {
00541 return operator<(array) || operator==(array);
00542 }
00543
00545 bool operator >= (const DPeakConstReferenceArray& array) const
00546 {
00547 return operator>(array) || operator==(array);
00548 }
00549
00551 void swap(DPeakConstReferenceArray& array)
00552 {
00553 vector_.swap(array.vector_);
00554 }
00555
00557 friend void swap(DPeakConstReferenceArray& a1, DPeakConstReferenceArray& a2)
00558 {
00559 a1.vector_.swap(a2.vector_);
00560 }
00561
00563 Iterator insert(Iterator pos, const PeakType& element)
00564 {
00565 const PeakType* pointer = &element;
00566 vector_.insert(vector_.begin()+pos.position_,pointer);
00567 return pos;
00568 }
00569
00571 void insert(Iterator pos, size_type n, const PeakType& element)
00572 {
00573 const PeakType* pointer;
00574 std::vector<const PeakType*> tmp;
00575 for (size_type i=0;i<n;i++)
00576 {
00577 pointer = &element;
00578 tmp.push_back(pointer);
00579 }
00580 vector_.insert(vector_.begin()+pos.position_,tmp.begin(),tmp.end());
00581 }
00582
00584 template <class InputIterator>
00585 void insert(Iterator pos, InputIterator f, InputIterator l)
00586 {
00587 const PeakType* pointer;
00588 std::vector<const PeakType*> tmp;
00589 for (InputIterator it=f;it!=l;++it)
00590 {
00591 pointer = &(*it);
00592 tmp.push_back(pointer);
00593 }
00594 vector_.insert(vector_.begin()+pos.position_,tmp.begin(),tmp.end());
00595 }
00596
00598 Iterator erase(Iterator pos)
00599 {
00600 vector_.erase(vector_.begin()+pos.position_);
00601 return pos;
00602 }
00603
00605 Iterator erase(Iterator first,Iterator last)
00606 {
00607 vector_.erase(vector_.begin()+first.position_,vector_.begin()+last.position_);
00608 return first;
00609 }
00610
00614
00615 void setBaseContainer(const BaseMapType& base_map) { base_container_ptr_ = &base_map; }
00617 void setBaseContainerPointer(const BaseMapType* base_map_pointer) { base_container_ptr_ = base_map_pointer; }
00619 const BaseMapType* getBaseContainerPointer() const { return base_container_ptr_; }
00621 const BaseMapType& getBaseContainer() const { return *base_container_ptr_; }
00623
00624
00628
00629 DPeakConstReferenceArray()
00630 : capacity_(0),
00631 base_container_ptr_(0) {}
00632
00634 DPeakConstReferenceArray(size_type n)
00635 : capacity_(0),
00636 base_container_ptr_(0)
00637 {
00638 vector_=std::vector<const PeakType*>(n);
00639 }
00641 DPeakConstReferenceArray(size_type n, const PeakType& element)
00642 : capacity_(0),
00643 base_container_ptr_(0)
00644 {
00645 vector_=std::vector<const PeakType*>(n,&element);
00646 }
00648 DPeakConstReferenceArray(const DPeakConstReferenceArray& p)
00649 : capacity_(0),
00650 base_container_ptr_(p.base_container_ptr_)
00651 {
00652 const PeakType* element;
00653 for (ConstIterator it=p.begin(); it!=p.end();++it)
00654 {
00655 element = &(*it);
00656 vector_.push_back(element);
00657 }
00658 }
00660 template <class InputIterator>
00661 DPeakConstReferenceArray(InputIterator f, InputIterator l)
00662 : capacity_(0),
00663 base_container_ptr_(0)
00664 {
00665 const PeakType* pointer;
00666 for (InputIterator it=f;it!=l;++it)
00667 {
00668 pointer = &(*it);
00669 vector_.push_back(pointer);
00670 }
00671 }
00673 DPeakConstReferenceArray(BaseMapType& p)
00674 : capacity_(0),
00675 base_container_ptr_(&p)
00676 {
00677 const PeakType* element;
00678 for (typename BaseMapType::iterator it = p.begin(); it != p.end(); ++it)
00679 {
00680 element = &(*it);
00681 vector_.push_back(element);
00682 }
00683 }
00684
00686 ~DPeakConstReferenceArray()
00687 {}
00689
00691 DPeakConstReferenceArray& operator = (const DPeakConstReferenceArray& rhs)
00692 {
00693 if (this==&rhs) return *this;
00694
00695 base_container_ptr_ = rhs.base_container_ptr_;
00696 clear();
00697 reserve(rhs.size());
00698 const PeakType* element;
00699 for (ConstIterator it=rhs.begin(); it!=rhs.end();++it)
00700 {
00701 element = &(*it);
00702 vector_.push_back(element);
00703 }
00704
00705 return *this;
00706 }
00707
00709 template <class InputIterator>
00710 void assign(InputIterator f , InputIterator l)
00711 {
00712 clear();
00713 insert(end(),f,l);
00714 }
00715
00717 void assign(size_type n , const PeakType& x)
00718 {
00719 clear();
00720 insert(end(),n,x);
00721 }
00722
00729
00731 void sortByIntensity()
00732 {
00733 std::sort(vector_.begin(), vector_.end(), PointerComparator < typename PeakType::IntensityLess > () );
00734 }
00735
00737 void sortByPosition()
00738 {
00739 std::sort(vector_.begin(), vector_.end(), PointerComparator<typename PeakType::PositionLess>() );
00740 }
00741
00747 void sortByNthPosition(UInt i) throw (Exception::NotImplemented);
00748
00750
00764 template < typename ComparatorType >
00765 void sortByComparator ( ComparatorType const & comparator )
00766 {
00767 std::sort(vector_.begin(), vector_.end(), PointerComparator < ComparatorType > ( comparator ) );
00768 }
00769 template < typename ComparatorType >
00770 void sortByComparator ()
00771 {
00772 std::sort(vector_.begin(), vector_.end(), PointerComparator< ComparatorType >() );
00773 }
00775
00776
00777
00778 protected:
00779
00781 std::vector<const PeakType*> vector_;
00783 size_type capacity_;
00785 const BaseMapType* base_container_ptr_;
00786 };
00787
00789 template <typename MapT>
00790 std::ostream& operator << (std::ostream& os, const DPeakConstReferenceArray<MapT>& array)
00791 {
00792 os << "-- DFEATUREARRAY BEGIN --"<<std::endl;
00793 for (typename DPeakConstReferenceArray<MapT>::const_iterator it = array.begin();
00794 it!=array.end();
00795 ++it
00796 )
00797 {
00798 os << *it << std::endl;
00799 }
00800 os << "-- DFEATUREARRAY END --"<<std::endl;
00801 return os;
00802 }
00803
00804
00805
00806
00807
00808 template <typename MapT>
00809 void DPeakConstReferenceArray<MapT>::sortByNthPosition(UInt i)
00810 throw (Exception::NotImplemented)
00811 {
00812 OPENMS_PRECONDITION(i < Int(PeakType::DIMENSION), "illegal dimension")
00813 if (i==0)
00814 {
00815 std::sort(vector_.begin(), vector_.end(), PointerComparator< typename PeakType::template NthPositionLess<0> >() );
00816 }
00817 else if (i==1)
00818 {
00819 std::sort(vector_.begin(), vector_.end(), PointerComparator< typename PeakType::template NthPositionLess<1> >() );
00820 }
00821 else if (i==2)
00822 {
00823 std::sort(vector_.begin(), vector_.end(), PointerComparator< typename PeakType::template NthPositionLess<2> >() );
00824 }
00825 else
00826 {
00827 throw Exception::NotImplemented(__FILE__,__LINE__,__FUNCTION__);
00828 }
00829 }
00830
00831
00832 }
00833
00834 #endif // OPENMS_KERNEL_DPEAKCONSTREFERENCEARRAY_H
00835