ms_fragmentvector.hpp

/*
##############################################################################
# File: ms_fragmentvector.hpp                                                #
# Mascot Parser toolkit                                                      #
# Encapsulates a list (vector) of single fragment ions                       #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2006 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Source: parser/inc/ms_fragmentvector.hpp $
#    $Author: villek@matrixscience.com $ 
#      $Date: 2023-10-31 16:08:54 +0000 $ 
#  $Revision: 925ec81070097410ba470a308ccae6c56aa345b2 | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $
##############################################################################
*/
 
#if !defined(ms_fragmentvector_INCLUDED_)
#define ms_fragmentvector_INCLUDED_
 
 
// Includes from the standard template library
#include <string>
#include <set>
#include <vector>
#include <map>
 
 
namespace matrix_science {
     class ms_mascotresfilebase;
 
 
    class MS_MASCOTRESFILE_API ms_fragmentvector
    {
    public:
 
 
        enum MATCH_PEAKS 
        { 
 
            MATCH_MOST_INTENSE_PEAK  = 0x0000, 
            MATCH_CLOSEST_PEAK       = 0x0001  
        };
 
 
        enum TOLERANCE_UNIT
        {
            TOLERANCE_DALTON,  
            TOLERANCE_MMU,     
            TOLERANCE_PERCENT, 
            TOLERANCE_PPM      
        };
 
        ms_fragmentvector();
 
        ms_fragmentvector(const ms_fragmentvector& src);
 
        virtual ~ms_fragmentvector();
 
        void copyFrom(const ms_fragmentvector* right);
 
#ifndef SWIG
        ms_fragmentvector& operator=(const ms_fragmentvector& right);
#endif
        int getNumberOfFragments() const;
 
        void clearFragments();
 
        void appendFragment(const ms_fragment * item);
 
        const ms_fragment * getFragmentByNumber(const unsigned int numFrag) const;
 
        typedef std::vector<ms_fragment> frag_vector;
 
#if !defined(SWIGJAVA) && !defined(SWIGCSHARP)
        frag_vector * getVector();
#endif        
        const frag_vector * getVector() const;
 
        bool addExperimentalData(const std::string & peakList, 
                                 const int           numPeaks, 
                                 const double        tolerance, 
                                 const std::string & toleranceUnits,
                                 const bool          updateMatchList = true);
 
        bool addExperimentalData(const ms_mascotresfilebase * resfile,
                                 const int query,
                                 const int flags = MATCH_MOST_INTENSE_PEAK,
                                 const int peaksUsedFromIons1 = -1,
                                 const int peaksUsedFromIons2 = -1,
                                 const int peaksUsedFromIons3 = -1);
 
        typedef std::map<double, double> peaklist_t;  // Mass, intensity
 
        bool addExperimentalData(const peaklist_t &  peakList, 
                                 const double        tolerance, 
                                 const std::string & toleranceUnits,
                                 const bool          updateMatchList = true);
 
#ifndef SWIG
        static void getMassesWithinTolerance(const double mass, 
                                             const double toleranceValue, 
                                             const TOLERANCE_UNIT toleranceUnit,
                                             double & minMass, 
                                             double & maxMass);
#else // SWIG Multiple return values
        static void getMassesWithinTolerance(const double mass, 
                                             const double toleranceValue, 
                                             const TOLERANCE_UNIT toleranceUnit,
                                             double & OUTPUT, 
                                             double & OUTPUT);
#endif
 
    private:
        frag_vector  entries_;
        peaklist_t experimentalData_;
        void matchFragments();
        double   matchingTol_; 
        std::string matchingTolUnits_;
    }; // class ms_fragmentvector // end of mass_calculation_group
} // matrix_science
 
#endif // !defined(ms_fragmentvector_INCLUDED_)