AreaIterator.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2022.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $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 std::iterator<std::forward_iterator_tag, ValueT>
    {
public:
      typedef double CoordinateType;
      typedef ValueT PeakType;
      typedef SpectrumIteratorT SpectrumIteratorType;
      typedef PeakIteratorT PeakIteratorType;

      class Param
      {
        friend AreaIterator;   // allow access to private members (avoids writing get-accessors)
      public:
        Param(SpectrumIteratorType first, SpectrumIteratorType begin, SpectrumIteratorType end)
          : first_(first), current_scan_(begin), end_scan_(end)
        {
          // if begin is dereferencable ...
          if (begin != end)
          {
            ms_level_ = begin->getMSLevel();
          }
          else
          {
            ms_level_ = 1;
          }
        }

        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 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();
      }

      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_;
    };

  }
}