AreaIterator.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg$
// $Authors: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
// OpenMS includes
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/KERNEL/PeakIndex.h>
#include <OpenMS/KERNEL/RangeManager.h>
 
// STL includes
#include <iterator>
 
namespace OpenMS
{
  namespace Internal
  {
    template<class ValueT, class ReferenceT, class PointerT, class SpectrumIteratorT, class PeakIteratorT>
    class AreaIterator
    {
    public:
      typedef double CoordinateType;
      typedef ValueT PeakType;
      typedef SpectrumIteratorT SpectrumIteratorType;
      typedef PeakIteratorT PeakIteratorType;
      using SpectrumT = typename std::iterator_traits<SpectrumIteratorType>::value_type;
 
      class Param
      {
        friend AreaIterator; // allow access to private members (avoids writing get-accessors)
      public:
        Param(SpectrumIteratorType first, SpectrumIteratorType begin, SpectrumIteratorType end, uint8_t ms_level) : first_(first), current_scan_(begin), end_scan_(end), ms_level_(ms_level)
        {
        }
 
        static Param end()
        {
          static Param p;
          p.is_end_ = true;
          return p;
        }
 
        Param& operator=(const Param& rhs) = default;
 
        Param& lowMZ(CoordinateType low_mz)
        {
          low_mz_ = low_mz;
          return *this;
        }
        Param& highMZ(CoordinateType high_mz)
        {
          high_mz_ = high_mz;
          return *this;
        }
        Param& lowIM(CoordinateType low_im)
        {
          low_im_ = low_im;
          return *this;
        }
        Param& highIM(CoordinateType high_im)
        {
          high_im_ = high_im;
          return *this;
        }
        Param& msLevel(int8_t ms_level)
        {
          ms_level_ = ms_level;
          return *this;
        }
 
      protected:
        SpectrumIteratorType first_;
        SpectrumIteratorType current_scan_;
        SpectrumIteratorType end_scan_;
        PeakIteratorType current_peak_;
        PeakIteratorType end_peak_;
        /* optional parameters */
        CoordinateType low_mz_ = std::numeric_limits<CoordinateType>::lowest();
        CoordinateType high_mz_ = std::numeric_limits<CoordinateType>::max();
        CoordinateType low_im_ = std::numeric_limits<CoordinateType>::lowest();
        CoordinateType high_im_ = std::numeric_limits<CoordinateType>::max();
        int8_t ms_level_ {};
        bool is_end_ = false;
 
      private:
        Param() = default;
      };
 
 
      typedef std::forward_iterator_tag iterator_category;
      typedef ValueT value_type;
      typedef ReferenceT reference;
      typedef PointerT pointer;
      typedef unsigned int difference_type;
 
      explicit AreaIterator(const Param& p) : p_(p)
      {
        nextScan_();
      }
 
      AreaIterator() : p_(Param::end())
      {
      }
 
      ~AreaIterator() = default;
 
      AreaIterator(const AreaIterator& rhs) = default;
 
      AreaIterator& operator=(const AreaIterator& rhs)
      {
        p_.is_end_ = rhs.p_.is_end_;
        // only copy iterators, if the assigned iterator is not the end iterator
        if (!p_.is_end_)
        {
          p_ = rhs.p_;
        }
 
        return *this;
      }
 
      bool operator==(const AreaIterator& rhs) const
      {
        // Both end iterators => equal
        if (p_.is_end_ && rhs.p_.is_end_)
          return true;
 
        // Normal and end iterator => not equal
        if (p_.is_end_ ^ rhs.p_.is_end_)
          return false;
 
        // Equality of pointed to peak addresses
        return &(*(p_.current_peak_)) == &(*(rhs.p_.current_peak_));
      }
 
      bool operator!=(const AreaIterator& rhs) const
      {
        return !(*this == rhs);
      }
 
      AreaIterator& operator++()
      {
        // no increment if this is the end iterator
        if (p_.is_end_)
          return *this;
 
        ++p_.current_peak_;
        // test whether we arrived at the end of the current scan
        if (p_.current_peak_ == p_.end_peak_)
        {
          ++p_.current_scan_;
          nextScan_();
        }
        return *this;
      }
 
      AreaIterator operator++(int)
      {
        AreaIterator tmp(*this);
        ++(*this);
        return tmp;
      }
 
      reference operator*() const
      {
        return p_.current_peak_.operator*();
      }
 
      pointer operator->() const
      {
        return p_.current_peak_.operator->();
      }
 
      CoordinateType getRT() const
      {
        return p_.current_scan_->getRT();
      }
 
      CoordinateType getDriftTime() const
      {
        return p_.current_scan_->getDriftTime();
      }
 
      const SpectrumT& getSpectrum() const
      {
        return *p_.current_scan_;
      }
 
      inline PeakIndex getPeakIndex() const
      {
        if (p_.is_end_)
        {
          return {};
        }
        else
        {
          return PeakIndex(p_.current_scan_ - p_.first_, p_.current_peak_ - p_.current_scan_->begin());
        }
      }
 
    private:
      void nextScan_()
      {
        using MSLevelType = decltype(p_.current_scan_->getMSLevel());
        RangeMobility mb {p_.low_im_, p_.high_im_};
        while (true)
        {
          // skip over invalid MS levels and Mobility
          while (p_.current_scan_ != p_.end_scan_ && (p_.current_scan_->getMSLevel() != (MSLevelType)p_.ms_level_ || !mb.containsMobility(p_.current_scan_->getDriftTime())))
          {
            ++p_.current_scan_;
          }
          if (p_.current_scan_ == p_.end_scan_)
          {
            p_.is_end_ = true;
            return;
          }
          p_.current_peak_ = p_.current_scan_->MZBegin(p_.low_mz_);
          p_.end_peak_ = p_.current_scan_->MZEnd(p_.high_mz_);
          if (p_.current_peak_ != p_.end_peak_)
          {
            return;
          }
          ++p_.current_scan_;
        }
      }
 
      Param p_;
    };
 
  } // namespace Internal
} // namespace OpenMS