ProFormaData.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/DATASTRUCTURES/String.h>
#include <OpenMS/OpenMSConfig.h>
 
 
#include <optional>
#include <utility>
#include <variant>
#include <vector>
 
namespace OpenMS
{
 
  // Forward declaration for resolved modification pointer
  class ResidueModification;
 
  enum class AASequenceConversionPolicy
  {
    FAIL_ON_LOSS,      
    DROP_UNLOCALISED,  
    BEST_EFFORT        
  };
 
 
  enum class ConversionIssueType
  {
    UNRESOLVED_MOD,      
    UNLOCALISED_MOD,     
    LABILE_MOD,          
    GLOBAL_MOD,          
    AMBIGUOUS_MOD,       
    AMBIGUOUS_REGION,    
    MODIFIED_RANGE,      
    CROSS_LINK,          
    MULTIPLE_CHAINS,     
    ALTERNATIVE_MODS,    
    UNSUPPORTED_FEATURE  
  };
 
 
  struct OPENMS_DLLAPI ConversionIssue
  {
    ConversionIssueType type;   
    String description;         
    size_t position;            
  };
 
 
  enum class ProFormaWriteMode
  {
    LOSSLESS,   
    CANONICAL   
  };
 
 
  enum class CvDatabase
  {
    UNIMOD, 
    MOD,    
    RESID,  
    XLMOD,  
    GNO     
  };
 
 
  struct OPENMS_DLLAPI CvAccession
  {
    CvDatabase database;  
    String accession;     
  };
 
 
  struct OPENMS_DLLAPI NamedMod
  {
    std::optional<CvDatabase> cv_hint;  
    String name;                        
  };
 
 
  struct OPENMS_DLLAPI MassDelta
  {
    enum class Source
    {
      NONE,  
      OBS,   
      U,     
      M,     
      R,     
      X,     
      G      
    };
 
    Source source = Source::NONE;  
    double mass;                   
    String original_text;          
  };
 
 
  struct OPENMS_DLLAPI FormulaTag
  {
    String formula_string;        
    std::optional<int> charge;    
  };
 
 
  struct OPENMS_DLLAPI GlycanComposition
  {
    using Monosaccharide = std::variant<String, FormulaTag>;
 
    std::vector<std::pair<Monosaccharide, int>> components;  
  };
 
 
  struct OPENMS_DLLAPI InfoTag
  {
    String text;  
  };
 
 
  struct OPENMS_DLLAPI PositionConstraint
  {
    std::vector<char> residues;  
    bool n_term = false;         
    bool c_term = false;         
  };
 
 
  using ModificationTag = std::variant<
    CvAccession,
    NamedMod,
    MassDelta,
    FormulaTag,
    GlycanComposition,
    InfoTag,
    PositionConstraint
  >;
 
 
  struct OPENMS_DLLAPI Label
  {
    enum class Type
    {
      CROSSLINK,  
      BRANCH,     
      AMBIGUOUS   
    };
 
    Type type;                        
    String identifier;                
    std::optional<double> score;      
  };
 
 
  struct OPENMS_DLLAPI Modification
  {
    std::vector<std::pair<ModificationTag, std::optional<Label>>> alternatives;
 
    const ResidueModification* resolved_mod = nullptr;
  };
 
 
  struct OPENMS_DLLAPI SequenceElement
  {
    char amino_acid;                          
    std::vector<Modification> modifications;  
  };
 
 
  struct OPENMS_DLLAPI AmbiguousRegion
  {
    std::vector<SequenceElement> elements;  
  };
 
 
  struct OPENMS_DLLAPI ModifiedRange
  {
    std::vector<SequenceElement> elements;    
    std::vector<Modification> modifications;  
  };
 
 
  using SequenceSection = std::variant<
    SequenceElement,
    AmbiguousRegion,
    ModifiedRange
  >;
 
 
  struct OPENMS_DLLAPI UnlocalisedMod
  {
    std::vector<Modification> modifications;  
    std::optional<int> occurrence;            
  };
 
 
  struct OPENMS_DLLAPI LabileModification
  {
    Modification modification;  
  };
 
 
  struct OPENMS_DLLAPI GlobalModification
  {
    Modification modification;        
    std::vector<String> locations;    
  };
 
 
  struct OPENMS_DLLAPI IsotopeReplacement
  {
    String isotope;  
  };
 
 
  using GlobalModEntry = std::variant<
    IsotopeReplacement,
    GlobalModification
  >;
 
 
  struct OPENMS_DLLAPI AdductIon
  {
    String formula;                   
    int charge;                       
    std::optional<int> occurrence;    
  };
 
 
  using ChargeState = std::variant<
    int,                       
    std::vector<AdductIon>     
  >;
 
 
  struct OPENMS_DLLAPI Peptidoform
  {
    std::optional<String> name;                       
    std::vector<GlobalModEntry> global_mods;          
    std::vector<UnlocalisedMod> unlocalised_mods;     
    std::vector<LabileModification> labile_mods;      
    std::vector<Modification> n_term_mods;            
    std::vector<SequenceSection> sequence;            
    std::vector<Modification> c_term_mods;            
    std::optional<ChargeState> charge;                
  };
 
 
  struct OPENMS_DLLAPI PeptidoformIon
  {
    std::optional<String> name;           
    std::vector<Peptidoform> chains;      
    std::optional<ChargeState> charge;    
    bool is_chimeric = false;             
  };
 
 
  struct OPENMS_DLLAPI CrossLinkGroup
  {
    String label;                                     
    std::vector<std::pair<size_t, size_t>> sites;     
  };
 
 
  //--------------------------------------------------------------------------
  // JSON serialization convenience functions (implementations in ProFormaDataJson.cpp)
  //--------------------------------------------------------------------------
 
 
  OPENMS_DLLAPI String toJSON(const Peptidoform& pf);
 
  OPENMS_DLLAPI Peptidoform peptidoformFromJSON(const String& json_str);
 
  OPENMS_DLLAPI String toJSON(const PeptidoformIon& pfi);
 
  OPENMS_DLLAPI PeptidoformIon peptidoformIonFromJSON(const String& json_str);
 
 
 
} // namespace OpenMS