ms_modfile.hpp

/*
##############################################################################
# file: ms_modfile.hpp                                                       #
# 'msparser' toolkit                                                         #
# Encapsulates "mod_file"-file that defines amino acid modifications         #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2003 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /Mowse/ms_mascotresfile/include/ms_modfile.hpp             $ #
#     $Author: robertog@matrixscience.com $ #
#       $Date: 2024-04-30 14:29:58 +0100 $ #
#   $Revision: 514b75f28c7f9636ba624f627dd5cb3f4e495b2e | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#ifndef MS_MODFILE_HPP
#define MS_MODFILE_HPP
 
 
#include <string>
#include <vector>
#include <memory>
 
namespace msparser_internal {
    class ms_modification_impl;
}
 
namespace matrix_science {
 
    class ms_masses;
    class ms_umod_modification;
 
    enum MOD_TYPES
    {
        MOD_TYPE_RESIDUE        = 0, 
        MOD_TYPE_N_TERM         = 1, 
        MOD_TYPE_C_TERM         = 2, 
        MOD_TYPE_N_PROTEIN      = 3, 
        MOD_TYPE_C_PROTEIN      = 4, 
        MOD_TYPE_N_TERM_RESIDUE = 5, 
        MOD_TYPE_C_TERM_RESIDUE = 6, 
        MOD_TYPE_N_PROTEIN_RESIDUE= 7, 
        MOD_TYPE_C_PROTEIN_RESIDUE= 8, 
        MOD_TYPE_______LAST     = 9     // This must always be last....
    };
 
 
    enum MASS_TYPE
    {
        MASS_TYPE_MONO = 0x0000,  
        MASS_TYPE_AVE  = 0x0001   
    };
 
 
    enum 
    { 
        MAX_VAR_MODS = 'W' -'A' + 10  
    };
 
    typedef std::vector<double> ms_vectorDouble;
    typedef std::vector< bool > ms_vectorBool;
 
 
    class MS_MASCOTRESFILE_API ms_modification: public ms_customproperty
    {
        friend class ms_modfile;
        friend class ms_modvector;
    public:
 
        ms_modification(const ms_masses* massFile = NULL);
 
        ms_modification(const ms_modification& src);
 
        ~ms_modification();
 
        void defaultValues();
 
        void copyFrom(const ms_modification* src);
 
#ifndef SWIG
        ms_modification& operator=(const ms_modification& right);
#endif
 
        std::string getClassification() const;
 
        bool getFromUnimod(const char* modName, const ms_umod_configfile *umod_file);
 
        void setMassFile(const ms_masses* massFile);
 
        const ms_masses* getMassFile() const;
 
        void copyMassFile(const ms_masses* massFile);
 
        std::string getTitle() const;
 
        void setTitle(const char* value);
 
        int getModificationType() const;
 
        void setModificationType(const int type);
 
        bool isHidden() const;
 
        void setHidden(const bool value);
 
        bool inShortList() const;
 
        void setInShortList(const bool value);
 
        bool inLongList() const;
 
        void setInLongList(const bool value);
 
        bool inErrorTolerant() const;
 
        void setInErrorTolerant(const bool value);
 
        bool isSubstitution() const;
 
        double getDelta(const MASS_TYPE massType) const;
 
        void setDelta(const double massMono, const double massAve);
 
        ms_vectorDouble getNeutralLoss(const MASS_TYPE massType) const;
 
        ms_vectorBool getNeutralLossRequired() const;
 
        //std::vector< double > getNeutralLossFrequencies() const;
 
        void setNeutralLoss(const ms_vectorDouble massMono, const ms_vectorDouble massAve, const ms_vectorBool required);
 
        int getNumberOfModifiedResidues() const;
 
        char getModifiedResidue(const int n) const;
 
        bool isResidueModified(const char residue) const;
 
        double getResidueMass(const MASS_TYPE massType, const char residue) const;
 
        void clearModifiedResidues();
 
        void appendModifiedResidue(const char residue, const double massMono, const double massAve);
 
        double getNTerminusMass(const MASS_TYPE massType) const;
 
        void setNTerminusMass(const double massMono, const double massAve);
 
        double getCTerminusMass(const MASS_TYPE massType) const;
 
        void setCTerminusMass(const double massMono, const double massAve);
 
        int getNumberOfIgnoreMasses() const;
 
        double getIgnoreMass(const MASS_TYPE massType, const int idx) const;
 
        void clearIgnoreMasses();
 
        void appendIgnoreMass(const double massMono, const double massAve);
 
        ms_vectorDouble getReqPepNeutralLoss(const MASS_TYPE massType) const;
 
        void setReqPepNeutralLoss(const ms_vectorDouble valuesMono, const ms_vectorDouble valuesAve);
 
        ms_vectorDouble getPepNeutralLoss(const MASS_TYPE massType) const;
 
        void setPepNeutralLoss(const ms_vectorDouble valuesMono, const ms_vectorDouble valuesAve);
 
        bool isGeneratedMonoLinker() const;
 
        bool isLoopLinker() const;
 
        std::string getCode() const;
 
        std::string getPairsWith() const;
 
        std::string getMonoLinkTitle() const;
 
        bool isCrossLinker() const;
 
        void setIsCrossLinker(const bool value);
 
        void setIsGeneratedMonoLinker(const bool value);
 
        void setIsLoopLinker(const bool value);
 
        int getPositionInUnimodAsNeutralLoss() const;
 
        void setPositionInUnimodAsNeutralLoss(const int value);
 
        void setCode(std::string code);
 
        void setPairsWith(std::string pairsWith);
 
        void setTitleSource(const char *unimodName, const char *specString);
 
#ifdef SUPPRESS_MS_CUSTOMPROPERTY_INHERITANCE
#include "suppress_ms_customproperty.hpp"
#endif
 
    private:
        void setCustomProperty();
 
        msparser_internal::ms_modification_impl * m_pImpl;
    }; // ms_modification
 
    class MS_MASCOTRESFILE_API ms_modvector
    {
        friend class ms_modfile;
    public:
        ms_modvector();
 
        ms_modvector(const ms_modvector& src);
 
        ms_modvector(const ms_umod_modification &src, const ms_umod_configfile &umod_file);
 
        ~ms_modvector();
 
        void copyFrom(const ms_modvector* right);
 
        void copyFrom(const ms_umod_modification* right, const ms_umod_configfile *umod_file);
 
#ifndef SWIG
        ms_modvector& operator=(const ms_modvector& right);
#endif
 
        int getNumberOfModifications() const;
 
        void clearModifications();
 
        void appendModification(const ms_modification* item);
 
        void appendModifications(ms_modvector &right);
 
        const ms_modification * getModificationByNumber(const int numMod) const;
 
        const ms_modification * getModificationByName(const std::string &name) const;
 
    private:
        typedef std::vector<ms_modification* > mod_vector;
 
        mod_vector  entries_;
    }; // class ms_modvector
 
 
    class MS_MASCOTRESFILE_API ms_modfile: public ms_errors
    {
    public:
        ms_modfile();
 
        ms_modfile(const ms_modfile& src);
 
 
        ms_modfile(const ms_umod_configfile& src,
            const unsigned int flags = ms_umod_configfile::MODFILE_FLAGS_ALL);
 
        ms_modfile(const char* filename, 
                   const ms_masses* massFile, 
                   const bool fromSubstitutions = false,
                   const ms_connection_settings * cs = 0);
 
        ~ms_modfile();
 
        void defaultValues();
 
        void copyFrom(const ms_modfile* right);
 
        void copyFrom(const ms_umod_configfile* right,
                      const unsigned int flags = ms_umod_configfile::MODFILE_FLAGS_ALL);
 
#ifndef SWIG
        ms_modfile& operator=(const ms_modfile& right);
#endif
        void setFileName(const char* name);
 
        std::string getFileName() const;
 
        void setConnectionSettings(const ms_connection_settings & cs);
 
        ms_connection_settings getConnectionSettings() const;
 
        void setMassFile(const ms_masses* massFile);
 
        const ms_masses* getMassFile() const;
 
        bool isFromSubstitutions() const;
 
        void setFromSubstitutions(const bool value);
 
        void read_file();
 
        void save_file();
#ifndef SWIG
        void saveToString(std::string & modfileAsStr);
#else // SWIG Multiple return values
        void saveToString(std::string & OUTPUT);
#endif
        void sortModifications();
 
        int getNumberOfModifications() const;
 
        void clearModifications();
 
        void appendModification(const ms_modification* item);
 
        const ms_modification * getModificationByNumber(const int numMod) const;
 
        const ms_modification * getModificationByName(const char* nameMod) const;
 
        bool updateModificationByNumber(const int num, const ms_modification mod);
 
        bool updateModificationByName(const char* name, const ms_modification mod);
 
        bool deleteModificationByNumber(const int num);
 
        bool deleteModificationByName(const char* name);
 
    private:
        void read_text();
        void save_text();
        void applyVisibility(const ms_session *session);
 
        typedef std::vector<ms_modification* > entries_vector;
        entries_vector  entries;
 
        std::string     filename_;
        std::unique_ptr<ms_masses> m_massFile;
        std::vector< std::string > comments_;
        bool            bFromSubstitutions_;
        ms_connection_settings cs_;
 
    }; // ms_modfile // end of config_group
} // namespace matrix_science
 
#endif // MS_MODFILE_HPP
 
/*------------------------------- End of File -------------------------------*/