OSWData.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Chris Bielow $
// $Authors: Chris Bielow $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/String.h>
 
#include <map>
#include <vector>
 
namespace OpenMS
{
    class MSExperiment;
 
    struct OPENMS_DLLAPI OSWHierarchy
    {
      enum Level
      {
        PROTEIN,
        PEPTIDE,
        FEATURE,
        TRANSITION,
        SIZE_OF_VALUES
      };
      static const char* LevelName[SIZE_OF_VALUES];
    };
 
    struct OPENMS_DLLAPI OSWIndexTrace
    {
      int idx_prot = -1;
      int idx_pep = -1;
      int idx_feat = -1;
      int idx_trans = -1;
      OSWHierarchy::Level lowest = OSWHierarchy::Level::SIZE_OF_VALUES;
 
      bool isSet() const
      {
        return lowest != OSWHierarchy::Level::SIZE_OF_VALUES;
      }
 
    };
 
    struct OPENMS_DLLAPI OSWTransition
    {
      public:
        OSWTransition() = default;
        OSWTransition(const String& annotation, const UInt32 id, const float product_mz, const char type, const bool is_decoy);
        OSWTransition(const OSWTransition& rhs) = default;
        OSWTransition& operator=(const OSWTransition& rhs) = default;
        OSWTransition(OSWTransition&& rhs) = default;
        OSWTransition& operator=(OSWTransition&& rhs) = default;
        ~OSWTransition() = default;
 
        const String& getAnnotation() const
        {
          return annotation_;
        }
        UInt32 getID() const
        {
          return id_;
        }
        float getProductMZ() const
        {
          return product_mz_;
        }
        char getType() const
        {
          return type_;
        }
        bool isDecoy() const
        {
          return is_decoy_;
        }
 
      private:
        String annotation_; 
        UInt32 id_;         
        float product_mz_;  
        char type_;         
        bool is_decoy_;     
    };
 
    class OPENMS_DLLAPI OSWPeakGroup
    {
      public:
        static constexpr float QVALUE_MISSING = -1;
 
        OSWPeakGroup() = default;
        
        OSWPeakGroup(const float rt_experimental, const float rt_left_width, const float rt_right_width, const float rt_delta, std::vector<UInt32>&& transition_ids, const float q_value = -1);
        
        OSWPeakGroup(const OSWPeakGroup& rhs) = default;
        
        OSWPeakGroup& operator=(const OSWPeakGroup& rhs) = default;
 
        OSWPeakGroup(OSWPeakGroup&& rhs) = default;
        
        OSWPeakGroup& operator=(OSWPeakGroup&& rhs) = default;
 
        float getRTExperimental() const
        {
          return rt_experimental_;
        }
        float getRTLeftWidth() const
        {
          return rt_left_width_;
        }
        float getRTRightWidth() const
        {
          return rt_right_width_;
        }
        float getRTDelta() const
        {
          return rt_delta_;
        }
        float getQValue() const
        {
          return q_value_;
        }
        const std::vector<UInt32>& getTransitionIDs() const
        {
          return transition_ids_;
        }
 
      private:
        float rt_experimental_{ 0 }; 
        float rt_left_width_{ 0 };   
        float rt_right_width_{ 0 };  
        float rt_delta_{ 0 };        
        float q_value_{ -1 };        
        std::vector<UInt32> transition_ids_; 
    };
 
    class OPENMS_DLLAPI OSWPeptidePrecursor
    {
      public:
        OSWPeptidePrecursor() = default;
        OSWPeptidePrecursor(const String& seq, const short charge, const bool decoy, const float precursor_mz, std::vector<OSWPeakGroup>&& features);
        OSWPeptidePrecursor(const OSWPeptidePrecursor& rhs) = default;
        OSWPeptidePrecursor& operator=(const OSWPeptidePrecursor& rhs) = default;
        OSWPeptidePrecursor(OSWPeptidePrecursor&& rhs) = default;
        OSWPeptidePrecursor& operator=(OSWPeptidePrecursor&& rhs) = default;
 
        const String& getSequence() const
        {
          return seq_;
        }
        short getCharge() const
        {
          return charge_;
        }
        bool isDecoy() const
        {
          return decoy_;
        }
        float getPCMz() const
        {
          return precursor_mz_;
        }
        const std::vector<OSWPeakGroup>& getFeatures() const
        {
          return features_;
        }
 
      private:
        String seq_;
        short charge_{0};
        bool decoy_{false};
        float precursor_mz_{0};
        std::vector<OSWPeakGroup> features_;
    };
 
    class OPENMS_DLLAPI OSWProtein
    {
      public:
        OSWProtein() = default;
        OSWProtein(const String& accession, const Size id, std::vector<OSWPeptidePrecursor>&& peptides);
        OSWProtein(const OSWProtein& rhs) = default;
        OSWProtein& operator=(const OSWProtein& rhs) = default;
        OSWProtein(OSWProtein&& rhs) = default;
        OSWProtein& operator=(OSWProtein&& rhs) = default;
 
        const String& getAccession() const
        {
          return accession_;
        }
 
        Size getID() const
        {
          return id_;
        }
 
        const std::vector<OSWPeptidePrecursor>& getPeptidePrecursors() const
        {
          return peptides_;
        }
 
      private:
        String accession_;
        Size id_;
        std::vector<OSWPeptidePrecursor> peptides_;
    };
 
 
    class OPENMS_DLLAPI OSWData
    {
      public:
        void addTransition(const OSWTransition& tr)
        {
          transitions_.emplace(tr.getID(), tr);
        }
 
        void addTransition(OSWTransition&& tr)
        {
          UInt32 id = tr.getID();
          transitions_.emplace(id, std::move(tr));
        }
 
        void addProtein(OSWProtein&& prot);
 
        const std::vector<OSWProtein>& getProteins() const
        {
          return proteins_;
        }
 
        void setProtein(const Size index, OSWProtein&& protein)
        {
          checkTransitions_(protein);
          proteins_[index] = std::move(protein);
        }
 
        Size transitionCount() const
        {
          return transitions_.size();
        }
 
        const OSWTransition& getTransition(const UInt32 id) const
        {
          return transitions_.at(id);
        }
        
        const std::map<UInt32, OSWTransition>& getTransitions() const
        {
          return transitions_;
        }
 
        void setSqlSourceFile(const String& filename)
        {
          source_file_ = filename;
        }
 
        const String& getSqlSourceFile() const
        {
          return source_file_;
        }
 
        void setRunID(const UInt64 run_id)
        {
          run_id_ = run_id;
        }
 
        UInt64 getRunID() const
        {
          return run_id_;
        }
 
        void clear();
 
        void clearProteins();
 
        void buildNativeIDResolver(const MSExperiment& chrom_traces);
 
        UInt fromNativeID(int transition_id) const;
 
      protected:
        void checkTransitions_(const OSWProtein& prot) const;
 
      private:
        std::map<UInt32, OSWTransition> transitions_;
        std::vector<OSWProtein> proteins_;
        String source_file_;                        
        UInt64 run_id_;                             
        std::map<UInt32, UInt32> transID_to_index_; 
    };
    
 
} // namespace OpenMS