AnnotatedMSRun.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: David Voigt, Timo Sachsenberg $
// -------------------------------------------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OpenMSConfig.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <boost/range/combine.hpp>
 
#include <vector>
 
namespace OpenMS
{
  class PeptideIdentification;
 
  class MSSpectrum;
 
  class OPENMS_DLLAPI AnnotatedMSRun
  {
  public:
    using SpectrumIdRef = std::pair<MSSpectrum&, PeptideIdentification&>;
    using ConstSpectrumIdRef = std::pair<const MSSpectrum&, const PeptideIdentification&>;
    using SpectrumType = MSExperiment::SpectrumType;
    using ChromatogramType = MSExperiment::ChromatogramType;
 
 
    AnnotatedMSRun() = default;
 
    explicit AnnotatedMSRun(MSExperiment&& experiment) : data(std::move(experiment))
    {};
 
    AnnotatedMSRun(AnnotatedMSRun&&) = default;
 
    AnnotatedMSRun(const AnnotatedMSRun&) = default;
    AnnotatedMSRun& operator=(const AnnotatedMSRun&) = default;
    AnnotatedMSRun& operator=(AnnotatedMSRun&&) = default;
 
    ~AnnotatedMSRun() = default;
 
    std::vector<ProteinIdentification>& getProteinIdentifications()
    {
      return protein_ids_;
    }
 
    const std::vector<ProteinIdentification>& getProteinIdentifications() const
    {
      return protein_ids_;
    }
 
    std::vector<PeptideIdentification>& getPeptideIdentifications();
    
    const std::vector<PeptideIdentification>& getPeptideIdentifications() const;
 
    void setPeptideIdentifications(std::vector<PeptideIdentification>&& ids);
 
    void setPeptideIdentifications(const std::vector<PeptideIdentification>& ids);
 
    MSExperiment& getMSExperiment();
    
    const MSExperiment& getMSExperiment() const;
 
    void setMSExperiment(MSExperiment&& experiment);
 
    void setMSExperiment(const MSExperiment& experiment);
 
    inline auto cbegin() const
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().cbegin(), peptide_ids_.cbegin());
    }
 
    inline auto begin()
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().begin(), peptide_ids_.begin());
    }
 
    inline auto begin() const
    {
      checkPeptideIdSize_(OPENMS_PRETTY_FUNCTION);
      return PairIterator(data.getSpectra().cbegin(), peptide_ids_.cbegin());
    }
 
    inline auto end()
    {
      return PairIterator(data.getSpectra().end(), peptide_ids_.end());
    }
 
    inline auto end() const
    {
      return PairIterator(data.getSpectra().end(), peptide_ids_.end());
    }
 
    inline auto cend() const
    {
      return PairIterator(data.getSpectra().cend(), peptide_ids_.cend());
    }
 
    inline SpectrumIdRef operator[](size_t idx)
    {
      if (idx >= peptide_ids_.size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, peptide_ids_.size());
      }
      if (idx >= data.getSpectra().size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, data.getSpectra().size());
      }      
      return {data.getSpectra()[idx], peptide_ids_[idx]};
    }
 
    inline ConstSpectrumIdRef operator[](size_t idx) const
    {
      if (idx >= peptide_ids_.size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, peptide_ids_.size());
      }
      if (idx >= data.getSpectra().size())
      {
        throw Exception::IndexOverflow(__FILE__, __LINE__,
          OPENMS_PRETTY_FUNCTION,
          idx, data.getSpectra().size());
      }
      return {data.getSpectra()[idx], peptide_ids_[idx]};
    }
 
    template<typename T1, typename T2>
    struct PairIterator
    {     
      using iterator_category = std::forward_iterator_tag;
      using difference_type = std::ptrdiff_t;
 
      PairIterator(T1 ptr1, T2 ptr2) : m_ptr1(ptr1), m_ptr2(ptr2)
      {}
 
      PairIterator& operator++()
      {
        ++m_ptr1;
        ++m_ptr2;
        return *this;
      }
 
      PairIterator operator++(int)
      {
        auto tmp(*this);
        ++(*this);
        return tmp;
      }
 
      auto operator*()
      {
        return std::make_pair(std::ref(*m_ptr1), std::ref(*m_ptr2));
      }
 
      inline friend bool operator==(const PairIterator& a, const PairIterator& b)
      {
        return a.m_ptr1 == b.m_ptr1 && a.m_ptr2 == b.m_ptr2;
      }
 
      inline friend bool operator!=(const PairIterator& a, const PairIterator& b)
      {
        return !(a == b);
      }
 
    private:
      T1 m_ptr1;
      T2 m_ptr2;
    };
 
    typedef AnnotatedMSRun::PairIterator<std::vector<MSSpectrum>::iterator, std::vector<PeptideIdentification>::iterator> Iterator;
    typedef AnnotatedMSRun::PairIterator<std::vector<MSSpectrum>::const_iterator, std::vector<PeptideIdentification>::const_iterator> ConstIterator;
 
  private:
 
    // Helper to enforce invariant
    void checkPeptideIdSize_(const char* function_name) const;
 
    std::vector<PeptideIdentification> peptide_ids_;
    std::vector<ProteinIdentification> protein_ids_;
    MSExperiment data;
  };
}