ProFormaParser.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: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CHEMISTRY/ProFormaData.h>
#include <OpenMS/CHEMISTRY/ProFormaError.h>
#include <OpenMS/CHEMISTRY/ProFormaTokenizer.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/OpenMSConfig.h>
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace OpenMS
{
 
  // Forward declarations
  class AASequence;
  class MSSpectrum;
 
  class OPENMS_DLLAPI ProFormaParser
  {
  public:
    static Peptidoform parse(const String& input);
 
    static PeptidoformIon parseIon(const String& input);
 
    static String toString(const Peptidoform& pf,
                           ProFormaWriteMode mode = ProFormaWriteMode::LOSSLESS);
 
    static String toString(const PeptidoformIon& pfi,
                           ProFormaWriteMode mode = ProFormaWriteMode::LOSSLESS);
 
    // ---- AASequence Conversion Methods ----
 
    static void resolveModifications(Peptidoform& pf);
 
    static AASequence toAASequence(
      const Peptidoform& pf,
      AASequenceConversionPolicy policy = AASequenceConversionPolicy::FAIL_ON_LOSS);
 
    static Peptidoform fromAASequence(const AASequence& seq);
 
    static bool isRepresentableAsAASequence(const Peptidoform& pf);
 
    static std::vector<ConversionIssue> getAASequenceConversionIssues(const Peptidoform& pf);
 
    // ---- Mass Calculation Methods ----
 
    static bool canCalculateMass(const Peptidoform& pf);
 
    static bool canCalculateMass(const PeptidoformIon& pfi);
 
    static std::vector<ConversionIssue> getMassCalculationIssues(const Peptidoform& pf);
 
    static std::vector<ConversionIssue> getMassCalculationIssues(const PeptidoformIon& pfi);
 
    static double getMonoWeight(const Peptidoform& pf);
 
    static double getMonoWeight(const PeptidoformIon& pfi);
 
    static double getMZ(const PeptidoformIon& pfi);
 
    static double getMZ(const Peptidoform& pf, int charge);
 
    // ---- Non-throwing variants (single-pass, efficient) ----
 
    static std::optional<double> tryGetMonoWeight(const Peptidoform& pf);
 
    static std::optional<double> tryGetMonoWeight(const Peptidoform& pf,
                                                   std::vector<ConversionIssue>& issues_out);
 
    static std::optional<double> tryGetMonoWeight(const PeptidoformIon& pfi);
 
    static std::optional<double> tryGetMonoWeight(const PeptidoformIon& pfi,
                                                   std::vector<ConversionIssue>& issues_out);
 
    static std::optional<double> tryGetMZ(const Peptidoform& pf, int charge);
 
    static std::optional<double> tryGetMZ(const Peptidoform& pf, int charge,
                                           std::vector<ConversionIssue>& issues_out);
 
    static std::optional<double> tryGetMZ(const PeptidoformIon& pfi);
 
    static std::optional<double> tryGetMZ(const PeptidoformIon& pfi,
                                           std::vector<ConversionIssue>& issues_out);
 
    // ---- Theoretical Spectrum Generation ----
 
    static bool canGenerateSpectrum(const Peptidoform& pf);
 
    static bool canGenerateSpectrum(const PeptidoformIon& pfi);
 
    static std::vector<ConversionIssue> getSpectrumGenerationIssues(const Peptidoform& pf);
 
    static std::vector<ConversionIssue> getSpectrumGenerationIssues(const PeptidoformIon& pfi);
 
    static MSSpectrum generateSpectrum(
      const Peptidoform& pf,
      int min_charge = 1,
      int max_charge = 1,
      const std::string& ion_types = "by",
      bool add_losses = false,
      bool add_metainfo = true);
 
    static MSSpectrum generateSpectrum(
      const PeptidoformIon& pfi,
      int min_charge = 1,
      int max_charge = 1,
      const std::string& ion_types = "by",
      bool add_losses = false,
      bool add_metainfo = true);
 
  private:
    explicit ProFormaParser(std::string_view input);
 
    // ---- High-level parsing methods ----
 
    PeptidoformIon parsePeptidoformIon_();
 
    Peptidoform parsePeptidoform_();
 
    Peptidoform parsePeptidoformWithCharge_(bool is_chimeric_context);
 
    std::vector<GlobalModEntry> parseGlobalMods_();
 
    GlobalModEntry parseGlobalModEntry_();
 
    IsotopeReplacement parseIsotopeReplacement_();
 
    GlobalModification parseGlobalModification_();
 
    std::vector<UnlocalisedMod> parseUnlocalisedMods_();
 
    std::vector<LabileModification> parseLabileModifications_();
 
    std::vector<SequenceSection> parseSequence_();
 
    SequenceElement parseSequenceElement_();
 
    AmbiguousRegion parseAmbiguousRegion_();
 
    ModifiedRange parseModifiedRange_();
 
    std::vector<Modification> parseTerminalMods_();
 
    // ---- Modification parsing ----
 
    std::vector<Modification> parseModificationList_();
 
    Modification parseModification_();
 
    std::pair<ModificationTag, std::optional<Label>> parseModificationTagWithLabel_();
 
    ModificationTag parseModificationTag_();
 
    NamedMod parseNamedMod_();
 
    NamedMod parseNamedMod_(char cv_hint);
 
    CvAccession parseCvAccession_();
 
    MassDelta parseMassDelta_();
 
    FormulaTag parseFormulaTag_();
 
    GlycanComposition parseGlycanComposition_();
 
    InfoTag parseInfoTag_();
 
    PositionConstraint parsePositionConstraint_();
 
    Label parseLabel_();
 
    // ---- Charge state parsing ----
 
    std::optional<ChargeState> parseChargeState_();
 
    std::vector<AdductIon> parseAdductIons_();
 
    AdductIon parseAdductIon_();
 
    // ---- Helper methods ----
 
    ProFormaTokenizer::Token current_();
 
    ProFormaTokenizer::Token peek_();
 
    ProFormaTokenizer::Token advance_();
 
    bool check_(ProFormaTokenizer::TokenType type);
 
    bool match_(ProFormaTokenizer::TokenType type);
 
    ProFormaTokenizer::Token expect_(ProFormaTokenizer::TokenType type, const char* expected_desc);
 
    bool isAtEnd_();
 
    [[noreturn]] void error_(ProFormaErrorCode code, const char* message);
 
    [[noreturn]] void errorAt_(ProFormaErrorCode code, size_t pos, const char* message);
 
    std::optional<CvDatabase> parseCvDatabasePrefix_(const std::string_view& id);
 
    static bool isAminoAcid_(char c);
 
    bool looksLikeModificationTagContent_();
 
    bool hasNTerminalModPattern_();
 
    ProFormaTokenizer createLookahead_() const;
 
    // ---- Member variables ----
 
    ProFormaTokenizer tokenizer_;
 
    std::string input_;
 
    ProFormaTokenizer::Token current_token_;
 
    bool has_current_ = false;
  };
 
} // namespace OpenMS