MSHits_.hpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/* $Id$
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 */
 
/// @file MSHits_.hpp
/// Data storage class.
///
/// This file was generated by application DATATOOL
/// using the following specifications:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/omssa/omssa.asn">omssa.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/omssa/omssa.def">omssa.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_OMSSA_MSHITS_BASE_HPP
#define OBJECTS_OMSSA_MSHITS_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <list>
#include <string>
 
BEGIN_NCBI_SCOPE
 
#ifndef BEGIN_objects_SCOPE
#  define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
#  define END_objects_SCOPE END_SCOPE(objects)
#endif
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// forward declarations
class CMSMZHit;
class CMSModHit;
class CMSPepHit;
class CMSScoreSet;
 
 
// generated classes
 
 
/** @addtogroup dataspec_OMSSA
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
/// hits to a given spectrum
///
/// CMSHits_Base --
///
 
class NCBI_OMSSA_EXPORT CMSHits_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CMSHits_Base(void);
    // destructor
    virtual ~CMSHits_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    // types
    typedef double TEvalue;
    typedef double TPvalue;
    typedef int TCharge;
    typedef list< CRef< CMSPepHit > > TPephits;
    typedef list< CRef< CMSMZHit > > TMzhits;
    typedef string TPepstring;
    typedef int TMass;
    typedef list< CRef< CMSModHit > > TMods;
    typedef string TPepstart;
    typedef string TPepstop;
    typedef int TProtlength;
    typedef int TTheomass;
    typedef int TOid;
    typedef list< CRef< CMSScoreSet > > TScores;
    typedef string TLibaccession;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_evalue,
        e_pvalue,
        e_charge,
        e_pephits,
        e_mzhits,
        e_pepstring,
        e_mass,
        e_mods,
        e_pepstart,
        e_pepstop,
        e_protlength,
        e_theomass,
        e_oid,
        e_scores,
        e_libaccession
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 16> TmemberIndex;
 
    // getters
    // setters
 
    /// E-value (expect value)
    /// Check if a value has been assigned to Evalue data member.
    ///
    /// Data member Evalue is mandatory;
    /// its type is defined as 'typedef double TEvalue'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetEvalue(void) const;
 
    /// Check if it is safe to call GetEvalue method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetEvalue(void) const;
 
    /// Reset Evalue data member.
    void ResetEvalue(void);
 
    /// Get the Evalue member data.
    ///
    /// @return
    ///   Copy of the member data.
    TEvalue GetEvalue(void) const;
 
    /// Assign a value to Evalue data member.
    ///
    /// @param value
    ///   Value to assign
    void SetEvalue(TEvalue value);
 
    /// Assign a value to Evalue data member.
    ///
    /// @return
    ///   Reference to the data value.
    TEvalue& SetEvalue(void);
 
    /// P-value (probability value)
    /// Check if a value has been assigned to Pvalue data member.
    ///
    /// Data member Pvalue is mandatory;
    /// its type is defined as 'typedef double TPvalue'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPvalue(void) const;
 
    /// Check if it is safe to call GetPvalue method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPvalue(void) const;
 
    /// Reset Pvalue data member.
    void ResetPvalue(void);
 
    /// Get the Pvalue member data.
    ///
    /// @return
    ///   Copy of the member data.
    TPvalue GetPvalue(void) const;
 
    /// Assign a value to Pvalue data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPvalue(TPvalue value);
 
    /// Assign a value to Pvalue data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPvalue& SetPvalue(void);
 
    /// the charge state used in search.  -1 == not +1
    /// Check if a value has been assigned to Charge data member.
    ///
    /// Data member Charge is mandatory;
    /// its type is defined as 'typedef int TCharge'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetCharge(void) const;
 
    /// Check if it is safe to call GetCharge method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetCharge(void) const;
 
    /// Reset Charge data member.
    void ResetCharge(void);
 
    /// Get the Charge member data.
    ///
    /// @return
    ///   Copy of the member data.
    TCharge GetCharge(void) const;
 
    /// Assign a value to Charge data member.
    ///
    /// @param value
    ///   Value to assign
    void SetCharge(TCharge value);
 
    /// Assign a value to Charge data member.
    ///
    /// @return
    ///   Reference to the data value.
    TCharge& SetCharge(void);
 
    /// peptides that match this hit
    /// Check if a value has been assigned to Pephits data member.
    ///
    /// Data member Pephits is mandatory;
    /// its type is defined as 'typedef list< CRef< CMSPepHit > > TPephits'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPephits(void) const;
 
    /// Check if it is safe to call GetPephits method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPephits(void) const;
 
    /// Reset Pephits data member.
    void ResetPephits(void);
 
    /// Get the Pephits member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPephits& GetPephits(void) const;
 
    /// Assign a value to Pephits data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPephits& SetPephits(void);
 
    /// ions hit
    /// Check if a value has been assigned to Mzhits data member.
    ///
    /// Data member Mzhits is optional;
    /// its type is defined as 'typedef list< CRef< CMSMZHit > > TMzhits'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMzhits(void) const;
 
    /// Check if it is safe to call GetMzhits method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMzhits(void) const;
 
    /// Reset Mzhits data member.
    void ResetMzhits(void);
 
    /// Get the Mzhits member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TMzhits& GetMzhits(void) const;
 
    /// Assign a value to Mzhits data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMzhits& SetMzhits(void);
 
    /// the peptide sequence
    /// Check if a value has been assigned to Pepstring data member.
    ///
    /// Data member Pepstring is optional;
    /// its type is defined as 'typedef string TPepstring'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPepstring(void) const;
 
    /// Check if it is safe to call GetPepstring method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPepstring(void) const;
 
    /// Reset Pepstring data member.
    void ResetPepstring(void);
 
    /// Get the Pepstring member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPepstring& GetPepstring(void) const;
 
    /// Assign a value to Pepstring data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPepstring(const TPepstring& value);
    void SetPepstring(TPepstring&& value);
 
    /// Assign a value to Pepstring data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPepstring& SetPepstring(void);
 
    /// scaled experimental mass of peptide in Da
    /// Check if a value has been assigned to Mass data member.
    ///
    /// Data member Mass is optional;
    /// its type is defined as 'typedef int TMass'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMass(void) const;
 
    /// Check if it is safe to call GetMass method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMass(void) const;
 
    /// Reset Mass data member.
    void ResetMass(void);
 
    /// Get the Mass member data.
    ///
    /// @return
    ///   Copy of the member data.
    TMass GetMass(void) const;
 
    /// Assign a value to Mass data member.
    ///
    /// @param value
    ///   Value to assign
    void SetMass(TMass value);
 
    /// Assign a value to Mass data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMass& SetMass(void);
 
    /// modifications to sequence
    /// Check if a value has been assigned to Mods data member.
    ///
    /// Data member Mods is optional;
    /// its type is defined as 'typedef list< CRef< CMSModHit > > TMods'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMods(void) const;
 
    /// Check if it is safe to call GetMods method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMods(void) const;
 
    /// Reset Mods data member.
    void ResetMods(void);
 
    /// Get the Mods member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TMods& GetMods(void) const;
 
    /// Assign a value to Mods data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMods& SetMods(void);
 
    /// AA before the peptide (depricated)
    /// Check if a value has been assigned to Pepstart data member.
    ///
    /// Data member Pepstart is optional;
    /// its type is defined as 'typedef string TPepstart'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPepstart(void) const;
 
    /// Check if it is safe to call GetPepstart method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPepstart(void) const;
 
    /// Reset Pepstart data member.
    void ResetPepstart(void);
 
    /// Get the Pepstart member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPepstart& GetPepstart(void) const;
 
    /// Assign a value to Pepstart data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPepstart(const TPepstart& value);
    void SetPepstart(TPepstart&& value);
 
    /// Assign a value to Pepstart data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPepstart& SetPepstart(void);
 
    /// AA after the peptide (depricated)
    /// Check if a value has been assigned to Pepstop data member.
    ///
    /// Data member Pepstop is optional;
    /// its type is defined as 'typedef string TPepstop'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPepstop(void) const;
 
    /// Check if it is safe to call GetPepstop method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPepstop(void) const;
 
    /// Reset Pepstop data member.
    void ResetPepstop(void);
 
    /// Get the Pepstop member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPepstop& GetPepstop(void) const;
 
    /// Assign a value to Pepstop data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPepstop(const TPepstop& value);
    void SetPepstop(TPepstop&& value);
 
    /// Assign a value to Pepstop data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPepstop& SetPepstop(void);
 
    /// length of protein hit (depricated)
    /// Check if a value has been assigned to Protlength data member.
    ///
    /// Data member Protlength is optional;
    /// its type is defined as 'typedef int TProtlength'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetProtlength(void) const;
 
    /// Check if it is safe to call GetProtlength method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetProtlength(void) const;
 
    /// Reset Protlength data member.
    void ResetProtlength(void);
 
    /// Get the Protlength member data.
    ///
    /// @return
    ///   Copy of the member data.
    TProtlength GetProtlength(void) const;
 
    /// Assign a value to Protlength data member.
    ///
    /// @param value
    ///   Value to assign
    void SetProtlength(TProtlength value);
 
    /// Assign a value to Protlength data member.
    ///
    /// @return
    ///   Reference to the data value.
    TProtlength& SetProtlength(void);
 
    /// scaled theoretical mass of peptide hit
    /// Check if a value has been assigned to Theomass data member.
    ///
    /// Data member Theomass is optional;
    /// its type is defined as 'typedef int TTheomass'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetTheomass(void) const;
 
    /// Check if it is safe to call GetTheomass method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetTheomass(void) const;
 
    /// Reset Theomass data member.
    void ResetTheomass(void);
 
    /// Get the Theomass member data.
    ///
    /// @return
    ///   Copy of the member data.
    TTheomass GetTheomass(void) const;
 
    /// Assign a value to Theomass data member.
    ///
    /// @param value
    ///   Value to assign
    void SetTheomass(TTheomass value);
 
    /// Assign a value to Theomass data member.
    ///
    /// @return
    ///   Reference to the data value.
    TTheomass& SetTheomass(void);
 
    /// blast library oid (depricated) 
    /// Check if a value has been assigned to Oid data member.
    ///
    /// Data member Oid is optional;
    /// its type is defined as 'typedef int TOid'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetOid(void) const;
 
    /// Check if it is safe to call GetOid method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetOid(void) const;
 
    /// Reset Oid data member.
    void ResetOid(void);
 
    /// Get the Oid member data.
    ///
    /// @return
    ///   Copy of the member data.
    TOid GetOid(void) const;
 
    /// Assign a value to Oid data member.
    ///
    /// @param value
    ///   Value to assign
    void SetOid(TOid value);
 
    /// Assign a value to Oid data member.
    ///
    /// @return
    ///   Reference to the data value.
    TOid& SetOid(void);
 
    /// optional scores (for library search)
    /// Check if a value has been assigned to Scores data member.
    ///
    /// Data member Scores is optional;
    /// its type is defined as 'typedef list< CRef< CMSScoreSet > > TScores'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetScores(void) const;
 
    /// Check if it is safe to call GetScores method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetScores(void) const;
 
    /// Reset Scores data member.
    void ResetScores(void);
 
    /// Get the Scores member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TScores& GetScores(void) const;
 
    /// Assign a value to Scores data member.
    ///
    /// @return
    ///   Reference to the data value.
    TScores& SetScores(void);
 
    /// library search accesssion
    /// Check if a value has been assigned to Libaccession data member.
    ///
    /// Data member Libaccession is optional;
    /// its type is defined as 'typedef string TLibaccession'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetLibaccession(void) const;
 
    /// Check if it is safe to call GetLibaccession method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetLibaccession(void) const;
 
    /// Reset Libaccession data member.
    void ResetLibaccession(void);
 
    /// Get the Libaccession member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TLibaccession& GetLibaccession(void) const;
 
    /// Assign a value to Libaccession data member.
    ///
    /// @param value
    ///   Value to assign
    void SetLibaccession(const TLibaccession& value);
    void SetLibaccession(TLibaccession&& value);
 
    /// Assign a value to Libaccession data member.
    ///
    /// @return
    ///   Reference to the data value.
    TLibaccession& SetLibaccession(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CMSHits_Base(const CMSHits_Base&);
    CMSHits_Base& operator=(const CMSHits_Base&);
 
    // data
    Uint4 m_set_State[1];
    double m_Evalue;
    double m_Pvalue;
    int m_Charge;
    list< CRef< CMSPepHit > > m_Pephits;
    list< CRef< CMSMZHit > > m_Mzhits;
    string m_Pepstring;
    int m_Mass;
    list< CRef< CMSModHit > > m_Mods;
    string m_Pepstart;
    string m_Pepstop;
    int m_Protlength;
    int m_Theomass;
    int m_Oid;
    list< CRef< CMSScoreSet > > m_Scores;
    string m_Libaccession;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CMSHits_Base::IsSetEvalue(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CMSHits_Base::CanGetEvalue(void) const
{
    return IsSetEvalue();
}
 
inline
void CMSHits_Base::ResetEvalue(void)
{
    m_Evalue = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CMSHits_Base::TEvalue CMSHits_Base::GetEvalue(void) const
{
    if (!CanGetEvalue()) {
        ThrowUnassigned(0);
    }
    return m_Evalue;
}
 
inline
void CMSHits_Base::SetEvalue(CMSHits_Base::TEvalue value)
{
    m_Evalue = value;
    m_set_State[0] |= 0x3;
}
 
inline
CMSHits_Base::TEvalue& CMSHits_Base::SetEvalue(void)
{
#ifdef _DEBUG
    if (!IsSetEvalue()) {
        memset(&m_Evalue,UnassignedByte(),sizeof(m_Evalue));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Evalue;
}
 
inline
bool CMSHits_Base::IsSetPvalue(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CMSHits_Base::CanGetPvalue(void) const
{
    return IsSetPvalue();
}
 
inline
void CMSHits_Base::ResetPvalue(void)
{
    m_Pvalue = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CMSHits_Base::TPvalue CMSHits_Base::GetPvalue(void) const
{
    if (!CanGetPvalue()) {
        ThrowUnassigned(1);
    }
    return m_Pvalue;
}
 
inline
void CMSHits_Base::SetPvalue(CMSHits_Base::TPvalue value)
{
    m_Pvalue = value;
    m_set_State[0] |= 0xc;
}
 
inline
CMSHits_Base::TPvalue& CMSHits_Base::SetPvalue(void)
{
#ifdef _DEBUG
    if (!IsSetPvalue()) {
        memset(&m_Pvalue,UnassignedByte(),sizeof(m_Pvalue));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Pvalue;
}
 
inline
bool CMSHits_Base::IsSetCharge(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CMSHits_Base::CanGetCharge(void) const
{
    return IsSetCharge();
}
 
inline
void CMSHits_Base::ResetCharge(void)
{
    m_Charge = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CMSHits_Base::TCharge CMSHits_Base::GetCharge(void) const
{
    if (!CanGetCharge()) {
        ThrowUnassigned(2);
    }
    return m_Charge;
}
 
inline
void CMSHits_Base::SetCharge(CMSHits_Base::TCharge value)
{
    m_Charge = value;
    m_set_State[0] |= 0x30;
}
 
inline
CMSHits_Base::TCharge& CMSHits_Base::SetCharge(void)
{
#ifdef _DEBUG
    if (!IsSetCharge()) {
        memset(&m_Charge,UnassignedByte(),sizeof(m_Charge));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Charge;
}
 
inline
bool CMSHits_Base::IsSetPephits(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CMSHits_Base::CanGetPephits(void) const
{
    return true;
}
 
inline
const CMSHits_Base::TPephits& CMSHits_Base::GetPephits(void) const
{
    return m_Pephits;
}
 
inline
CMSHits_Base::TPephits& CMSHits_Base::SetPephits(void)
{
    m_set_State[0] |= 0x40;
    return m_Pephits;
}
 
inline
bool CMSHits_Base::IsSetMzhits(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CMSHits_Base::CanGetMzhits(void) const
{
    return true;
}
 
inline
const CMSHits_Base::TMzhits& CMSHits_Base::GetMzhits(void) const
{
    return m_Mzhits;
}
 
inline
CMSHits_Base::TMzhits& CMSHits_Base::SetMzhits(void)
{
    m_set_State[0] |= 0x100;
    return m_Mzhits;
}
 
inline
bool CMSHits_Base::IsSetPepstring(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CMSHits_Base::CanGetPepstring(void) const
{
    return IsSetPepstring();
}
 
inline
const CMSHits_Base::TPepstring& CMSHits_Base::GetPepstring(void) const
{
    if (!CanGetPepstring()) {
        ThrowUnassigned(5);
    }
    return m_Pepstring;
}
 
inline
void CMSHits_Base::SetPepstring(const CMSHits_Base::TPepstring& value)
{
    m_Pepstring = value;
    m_set_State[0] |= 0xc00;
}
 
inline
void CMSHits_Base::SetPepstring(CMSHits_Base::TPepstring&& value)
{
    m_Pepstring = std::forward<CMSHits_Base::TPepstring>(value);
    m_set_State[0] |= 0xc00;
}
 
inline
CMSHits_Base::TPepstring& CMSHits_Base::SetPepstring(void)
{
#ifdef _DEBUG
    if (!IsSetPepstring()) {
        m_Pepstring = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400;
    return m_Pepstring;
}
 
inline
bool CMSHits_Base::IsSetMass(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CMSHits_Base::CanGetMass(void) const
{
    return IsSetMass();
}
 
inline
void CMSHits_Base::ResetMass(void)
{
    m_Mass = 0;
    m_set_State[0] &= ~0x3000;
}
 
inline
CMSHits_Base::TMass CMSHits_Base::GetMass(void) const
{
    if (!CanGetMass()) {
        ThrowUnassigned(6);
    }
    return m_Mass;
}
 
inline
void CMSHits_Base::SetMass(CMSHits_Base::TMass value)
{
    m_Mass = value;
    m_set_State[0] |= 0x3000;
}
 
inline
CMSHits_Base::TMass& CMSHits_Base::SetMass(void)
{
#ifdef _DEBUG
    if (!IsSetMass()) {
        memset(&m_Mass,UnassignedByte(),sizeof(m_Mass));
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_Mass;
}
 
inline
bool CMSHits_Base::IsSetMods(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CMSHits_Base::CanGetMods(void) const
{
    return true;
}
 
inline
const CMSHits_Base::TMods& CMSHits_Base::GetMods(void) const
{
    return m_Mods;
}
 
inline
CMSHits_Base::TMods& CMSHits_Base::SetMods(void)
{
    m_set_State[0] |= 0x4000;
    return m_Mods;
}
 
inline
bool CMSHits_Base::IsSetPepstart(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CMSHits_Base::CanGetPepstart(void) const
{
    return IsSetPepstart();
}
 
inline
const CMSHits_Base::TPepstart& CMSHits_Base::GetPepstart(void) const
{
    if (!CanGetPepstart()) {
        ThrowUnassigned(8);
    }
    return m_Pepstart;
}
 
inline
void CMSHits_Base::SetPepstart(const CMSHits_Base::TPepstart& value)
{
    m_Pepstart = value;
    m_set_State[0] |= 0x30000;
}
 
inline
void CMSHits_Base::SetPepstart(CMSHits_Base::TPepstart&& value)
{
    m_Pepstart = std::forward<CMSHits_Base::TPepstart>(value);
    m_set_State[0] |= 0x30000;
}
 
inline
CMSHits_Base::TPepstart& CMSHits_Base::SetPepstart(void)
{
#ifdef _DEBUG
    if (!IsSetPepstart()) {
        m_Pepstart = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_Pepstart;
}
 
inline
bool CMSHits_Base::IsSetPepstop(void) const
{
    return ((m_set_State[0] & 0xc0000) != 0);
}
 
inline
bool CMSHits_Base::CanGetPepstop(void) const
{
    return IsSetPepstop();
}
 
inline
const CMSHits_Base::TPepstop& CMSHits_Base::GetPepstop(void) const
{
    if (!CanGetPepstop()) {
        ThrowUnassigned(9);
    }
    return m_Pepstop;
}
 
inline
void CMSHits_Base::SetPepstop(const CMSHits_Base::TPepstop& value)
{
    m_Pepstop = value;
    m_set_State[0] |= 0xc0000;
}
 
inline
void CMSHits_Base::SetPepstop(CMSHits_Base::TPepstop&& value)
{
    m_Pepstop = std::forward<CMSHits_Base::TPepstop>(value);
    m_set_State[0] |= 0xc0000;
}
 
inline
CMSHits_Base::TPepstop& CMSHits_Base::SetPepstop(void)
{
#ifdef _DEBUG
    if (!IsSetPepstop()) {
        m_Pepstop = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40000;
    return m_Pepstop;
}
 
inline
bool CMSHits_Base::IsSetProtlength(void) const
{
    return ((m_set_State[0] & 0x300000) != 0);
}
 
inline
bool CMSHits_Base::CanGetProtlength(void) const
{
    return IsSetProtlength();
}
 
inline
void CMSHits_Base::ResetProtlength(void)
{
    m_Protlength = 0;
    m_set_State[0] &= ~0x300000;
}
 
inline
CMSHits_Base::TProtlength CMSHits_Base::GetProtlength(void) const
{
    if (!CanGetProtlength()) {
        ThrowUnassigned(10);
    }
    return m_Protlength;
}
 
inline
void CMSHits_Base::SetProtlength(CMSHits_Base::TProtlength value)
{
    m_Protlength = value;
    m_set_State[0] |= 0x300000;
}
 
inline
CMSHits_Base::TProtlength& CMSHits_Base::SetProtlength(void)
{
#ifdef _DEBUG
    if (!IsSetProtlength()) {
        memset(&m_Protlength,UnassignedByte(),sizeof(m_Protlength));
    }
#endif
    m_set_State[0] |= 0x100000;
    return m_Protlength;
}
 
inline
bool CMSHits_Base::IsSetTheomass(void) const
{
    return ((m_set_State[0] & 0xc00000) != 0);
}
 
inline
bool CMSHits_Base::CanGetTheomass(void) const
{
    return IsSetTheomass();
}
 
inline
void CMSHits_Base::ResetTheomass(void)
{
    m_Theomass = 0;
    m_set_State[0] &= ~0xc00000;
}
 
inline
CMSHits_Base::TTheomass CMSHits_Base::GetTheomass(void) const
{
    if (!CanGetTheomass()) {
        ThrowUnassigned(11);
    }
    return m_Theomass;
}
 
inline
void CMSHits_Base::SetTheomass(CMSHits_Base::TTheomass value)
{
    m_Theomass = value;
    m_set_State[0] |= 0xc00000;
}
 
inline
CMSHits_Base::TTheomass& CMSHits_Base::SetTheomass(void)
{
#ifdef _DEBUG
    if (!IsSetTheomass()) {
        memset(&m_Theomass,UnassignedByte(),sizeof(m_Theomass));
    }
#endif
    m_set_State[0] |= 0x400000;
    return m_Theomass;
}
 
inline
bool CMSHits_Base::IsSetOid(void) const
{
    return ((m_set_State[0] & 0x3000000) != 0);
}
 
inline
bool CMSHits_Base::CanGetOid(void) const
{
    return IsSetOid();
}
 
inline
void CMSHits_Base::ResetOid(void)
{
    m_Oid = 0;
    m_set_State[0] &= ~0x3000000;
}
 
inline
CMSHits_Base::TOid CMSHits_Base::GetOid(void) const
{
    if (!CanGetOid()) {
        ThrowUnassigned(12);
    }
    return m_Oid;
}
 
inline
void CMSHits_Base::SetOid(CMSHits_Base::TOid value)
{
    m_Oid = value;
    m_set_State[0] |= 0x3000000;
}
 
inline
CMSHits_Base::TOid& CMSHits_Base::SetOid(void)
{
#ifdef _DEBUG
    if (!IsSetOid()) {
        memset(&m_Oid,UnassignedByte(),sizeof(m_Oid));
    }
#endif
    m_set_State[0] |= 0x1000000;
    return m_Oid;
}
 
inline
bool CMSHits_Base::IsSetScores(void) const
{
    return ((m_set_State[0] & 0xc000000) != 0);
}
 
inline
bool CMSHits_Base::CanGetScores(void) const
{
    return true;
}
 
inline
const CMSHits_Base::TScores& CMSHits_Base::GetScores(void) const
{
    return m_Scores;
}
 
inline
CMSHits_Base::TScores& CMSHits_Base::SetScores(void)
{
    m_set_State[0] |= 0x4000000;
    return m_Scores;
}
 
inline
bool CMSHits_Base::IsSetLibaccession(void) const
{
    return ((m_set_State[0] & 0x30000000) != 0);
}
 
inline
bool CMSHits_Base::CanGetLibaccession(void) const
{
    return IsSetLibaccession();
}
 
inline
const CMSHits_Base::TLibaccession& CMSHits_Base::GetLibaccession(void) const
{
    if (!CanGetLibaccession()) {
        ThrowUnassigned(14);
    }
    return m_Libaccession;
}
 
inline
void CMSHits_Base::SetLibaccession(const CMSHits_Base::TLibaccession& value)
{
    m_Libaccession = value;
    m_set_State[0] |= 0x30000000;
}
 
inline
void CMSHits_Base::SetLibaccession(CMSHits_Base::TLibaccession&& value)
{
    m_Libaccession = std::forward<CMSHits_Base::TLibaccession>(value);
    m_set_State[0] |= 0x30000000;
}
 
inline
CMSHits_Base::TLibaccession& CMSHits_Base::SetLibaccession(void)
{
#ifdef _DEBUG
    if (!IsSetLibaccession()) {
        m_Libaccession = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000000;
    return m_Libaccession;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_OMSSA_MSHITS_BASE_HPP