Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages

DPeakConstReferenceArray.h (Maintainer: Eva Lange)

Go to the documentation of this file.
00001 // -*- Mode: C++; tab-width: 2; -*-
00002 // vi: set ts=2:
00003 //
00004 // --------------------------------------------------------------------------
00005 //                   OpenMS Mass Spectrometry Framework
00006 // --------------------------------------------------------------------------
00007 //  Copyright (C) 2003-2008 -- Oliver Kohlbacher, Knut Reinert
00008 //
00009 //  This library is free software; you can redistribute it and/or
00010 //  modify it under the terms of the GNU Lesser General Public
00011 //  License as published by the Free Software Foundation; either
00012 //  version 2.1 of the License, or (at your option) any later version.
00013 //
00014 //  This library is distributed in the hope that it will be useful,
00015 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 //  Lesser General Public License for more details.
00018 //
00019 //  You should have received a copy of the GNU Lesser General Public
00020 //  License along with this library; if not, write to the Free Software
00021 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 //
00023 // --------------------------------------------------------------------------
00024 // $Maintainer: Eva Lange $
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   //  Implementation of the inline / template functions
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 } // namespace OpenMS
00833 
00834 #endif // OPENMS_KERNEL_DPEAKCONSTREFERENCEARRAY_H
00835 

Generated Tue Apr 1 15:36:33 2008 -- using doxygen 1.5.4 OpenMS / TOPP 1.1