ms_quant_quality.hpp

/*
##############################################################################
# file: ms_quant_quality.hpp                                                 #
# 'msparser' toolkit                                                         #
# Encapsulates quality-element from "quantitation.xml"-file                  #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2006 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
 * @(#)$Source: parser/inc/ms_quant_quality.hpp $
 * @(#)$Revision: 23deec178247eb6704b4c85e1ed5642a21d26ed1 | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $
 * @(#)$Date: 2021-08-10 17:22:38 +0100 $
##############################################################################
 */
 
#ifndef MS_QUANT_QUALITY_HPP
#define MS_QUANT_QUALITY_HPP
 
 
#include <string>
#include <vector>
 
// forward declarations
namespace msparser_internal {
    class ms_quant_xmlloader;
}
 
namespace matrix_science {
 
    class ms_xml_schema; // forward declaration
 
    class MS_MASCOTRESFILE_API ms_quant_quality: public ms_quant_parameters
    {
        friend class msparser_internal::ms_quant_xmlloader;
    public:
        ms_quant_quality();
 
        ms_quant_quality(const ms_quant_quality& src);
 
        virtual ~ms_quant_quality();
 
        void defaultValues();
 
        void copyFrom(const ms_quant_quality* right);
 
#ifndef SWIG
        ms_quant_quality& operator=(const ms_quant_quality& right);
#endif
        virtual std::string getSchemaType() const;
 
        virtual std::string validateShallow(const ms_xml_schema *pSchemaFileObj) const;
 
        virtual std::string validateDeep(const ms_xml_schema *pSchemaFileObj) const;
 
 
        bool haveMinPrecursorCharge() const;
 
        int getMinPrecursorCharge() const;
 
        void setMinPrecursorCharge(const int value);
 
        void dropMinPrecursorCharge();
 
        std::string getMinPrecursorChargeSchemaType() const;
 
 
        bool haveIsolatedPrecursor() const;
 
        bool isIsolatedPrecursor() const;
 
        void setIsolatedPrecursor(const bool value);
 
        void dropIsolatedPrecursor();
 
        std::string getIsolatedPrecursorSchemaType() const;
 
 
        bool haveMinimumA1() const;
 
        std::string getMinimumA1() const;
 
        void setMinimumA1(const char* value);
 
        void dropMinimumA1();
 
        std::string getMinimumA1SchemaType() const;
 
 
        bool havePepThresholdType() const;
 
        std::string getPepThresholdType() const;
 
        void setPepThresholdType(const char* value);
 
        void dropPepThresholdType();
 
        std::string getPepThresholdTypeSchemaType() const;
 
 
        bool havePepThresholdValue() const;
 
        std::string getPepThresholdValue() const;
 
        void setPepThresholdValue(const char* value);
 
        void dropPepThresholdValue();
 
        std::string getPepThresholdValueSchemaType() const;
 
 
        bool haveUniquePepseq() const;
 
        bool isUniquePepseq() const;
 
        void setUniquePepseq(bool value);
 
        void dropUniquePepseq();
 
        std::string getUniquePepseqSchemaType() const;
 
 
        bool haveIsolatedPrecursorThreshold() const;
 
        std::string getIsolatedPrecursorThreshold() const;
 
        void setIsolatedPrecursorThreshold(const char * value);
 
        void dropIsolatedPrecursorThreshold();
 
        std::string getIsolatedPrecursorThresholdSchemaType() const;
 
        bool haveTotalIntensity() const;
 
        bool isTotalIntensity() const;
 
        void setTotalIntensity(bool value);
 
        void dropTotalIntensity();
 
        std::string getTotalIntensitySchemaType() const;
 
        bool haveTotalIntensityThreshold() const;
 
        std::string getTotalIntensityThreshold() const;
 
        void setTotalIntensityThreshold(std::string value);
 
        void dropTotalIntensityThreshold();
 
        std::string getTotalIntensityThresholdSchemaType() const;
    private:
 
        int _minPrecursorCharge;
        bool _minPrecursorCharge_set;
 
        bool _isolatedPrecursor;
        bool _isolatedPrecursor_set;
 
        std::string _minimumA1;
        bool _minimumA1_set;
 
        std::string _pepThresholdType;
        bool _pepThresholdType_set;
 
        std::string _pepThresholdValue;
        bool _pepThresholdValue_set;
 
        bool _uniquePepseq;
        bool _uniquePepseq_set;
 
        std::string _isolatedPrecursorThreshold;
        bool _isolatedPrecursorThreshold_set;
 
        bool _totalIntensity;
        bool _totalIntensity_set;
 
        std::string _totalIntensityThreshold;
        bool _totalIntensityThreshold_set;
    }; // class ms_quant_quality
 // end of config_group
 
} // namespace matrix_science
 
#endif // MS_QUANT_QUALITY_HPP
 
/*------------------------------- End of File -------------------------------*/