Seq_id_.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 Seq_id_.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/seqloc/seqloc.asn">seqloc.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/seqloc/seqloc.def">seqloc.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_SEQLOC_SEQ_ID_BASE_HPP
#define OBJECTS_SEQLOC_SEQ_ID_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
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 CDbtag;
class CGiimport_id;
class CObject_id;
class CPDB_seq_id;
class CPatent_seq_id;
class CTextseq_id;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_Seqloc
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///*** Sequence identifiers ********************************
///*
///
/// CSeq_id_Base --
///
 
class NCBI_SEQLOC_EXPORT CSeq_id_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CSeq_id_Base(void);
    // destructor
    virtual ~CSeq_id_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
 
    /// Choice variants.
    enum E_Choice {
        e_not_set = 0,        ///< No variant selected
        e_Local,              ///< local use
        e_Gibbsq,             ///< Geninfo backbone seqid
        e_Gibbmt,             ///< Geninfo backbone moltype
        e_Giim,               ///< Geninfo import id
        e_Genbank,
        e_Embl,
        e_Pir,
        e_Swissprot,
        e_Patent,
        e_Other,              ///< for historical reasons, 'other' = 'refseq'
        e_General,            ///< for other databases
        e_Gi,                 ///< GenInfo Integrated Database
        e_Ddbj,               ///< DDBJ
        e_Prf,                ///< PRF SEQDB
        e_Pdb,                ///< PDB sequence
        e_Tpg,                ///< Third Party Annot/Seq Genbank
        e_Tpe,                ///< Third Party Annot/Seq EMBL
        e_Tpd,                ///< Third Party Annot/Seq DDBJ
        e_Gpipe,              ///< Internal NCBI genome pipeline processing ID
        e_Named_annot_track   ///< Internal named annotation tracking ID
    };
    /// Maximum+1 value of the choice variant enumerator.
    enum E_ChoiceStopper {
        e_MaxChoice = 21 ///< == e_Named_annot_track+1
    };
 
    /// Reset the whole object
    virtual void Reset(void);
 
    /// Reset the selection (set it to e_not_set).
    virtual void ResetSelection(void);
 
    /// Which variant is currently selected.
    ///
    /// @return
    ///   Choice state enumerator.
    E_Choice Which(void) const;
 
    /// Verify selection, throw exception if it differs from the expected.
    ///
    /// @param index
    ///   Expected selection.
    void CheckSelected(E_Choice index) const;
 
    /// Throw 'InvalidSelection' exception.
    ///
    /// @param index
    ///   Expected selection.
    NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
 
    /// Retrieve selection name (for diagnostic purposes).
    ///
    /// @param index
    ///   One of possible selection states.
    /// @return
    ///   Name string.
    static string SelectionName(E_Choice index);
 
    /// Select the requested variant if needed.
    ///
    /// @param index
    ///   New selection state.
    /// @param reset
    ///   Flag that defines the resetting of the variant data. The data will
    ///   be reset if either the current selection differs from the new one,
    ///   or the flag is set to eDoResetVariant.
    void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
    /// Select the requested variant if needed,
    /// allocating CObject variants from memory pool.
    void Select(E_Choice index,
                EResetVariant reset,
                CObjectMemoryPool* pool);
 
    // types
    typedef CObject_id TLocal;
    typedef int TGibbsq;
    typedef int TGibbmt;
    typedef CGiimport_id TGiim;
    typedef CTextseq_id TGenbank;
    typedef CTextseq_id TEmbl;
    typedef CTextseq_id TPir;
    typedef CTextseq_id TSwissprot;
    typedef CPatent_seq_id TPatent;
    typedef CTextseq_id TOther;
    typedef CDbtag TGeneral;
    typedef NCBI_NS_NCBI::TGi TGi;
    typedef CTextseq_id TDdbj;
    typedef CTextseq_id TPrf;
    typedef CPDB_seq_id TPdb;
    typedef CTextseq_id TTpg;
    typedef CTextseq_id TTpe;
    typedef CTextseq_id TTpd;
    typedef CTextseq_id TGpipe;
    typedef CTextseq_id TNamed_annot_track;
 
    // getters
    // setters
 
 
    /// Check if variant Local is selected.
    ///
    /// Local type is defined as 'typedef CObject_id TLocal'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsLocal(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TLocal& GetLocal(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TLocal& SetLocal(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetLocal(TLocal& value);
 
 
    /// Check if variant Gibbsq is selected.
    ///
    /// Gibbsq type is defined as 'typedef int TGibbsq'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGibbsq(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGibbsq GetGibbsq(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGibbsq& SetGibbsq(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGibbsq(TGibbsq value);
 
 
    /// Check if variant Gibbmt is selected.
    ///
    /// Gibbmt type is defined as 'typedef int TGibbmt'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGibbmt(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGibbmt GetGibbmt(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGibbmt& SetGibbmt(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGibbmt(TGibbmt value);
 
 
    /// Check if variant Giim is selected.
    ///
    /// Giim type is defined as 'typedef CGiimport_id TGiim'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGiim(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TGiim& GetGiim(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGiim& SetGiim(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetGiim(TGiim& value);
 
 
    /// Check if variant Genbank is selected.
    ///
    /// Genbank type is defined as 'typedef CTextseq_id TGenbank'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGenbank(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TGenbank& GetGenbank(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGenbank& SetGenbank(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetGenbank(TGenbank& value);
 
 
    /// Check if variant Embl is selected.
    ///
    /// Embl type is defined as 'typedef CTextseq_id TEmbl'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsEmbl(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TEmbl& GetEmbl(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TEmbl& SetEmbl(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetEmbl(TEmbl& value);
 
 
    /// Check if variant Pir is selected.
    ///
    /// Pir type is defined as 'typedef CTextseq_id TPir'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsPir(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TPir& GetPir(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TPir& SetPir(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetPir(TPir& value);
 
 
    /// Check if variant Swissprot is selected.
    ///
    /// Swissprot type is defined as 'typedef CTextseq_id TSwissprot'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsSwissprot(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TSwissprot& GetSwissprot(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TSwissprot& SetSwissprot(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetSwissprot(TSwissprot& value);
 
 
    /// Check if variant Patent is selected.
    ///
    /// Patent type is defined as 'typedef CPatent_seq_id TPatent'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsPatent(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TPatent& GetPatent(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TPatent& SetPatent(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetPatent(TPatent& value);
 
 
    /// Check if variant Other is selected.
    ///
    /// Other type is defined as 'typedef CTextseq_id TOther'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsOther(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TOther& GetOther(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TOther& SetOther(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetOther(TOther& value);
 
 
    /// Check if variant General is selected.
    ///
    /// General type is defined as 'typedef CDbtag TGeneral'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGeneral(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TGeneral& GetGeneral(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGeneral& SetGeneral(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetGeneral(TGeneral& value);
 
 
    /// Check if variant Gi is selected.
    ///
    /// Gi type is defined as 'typedef NCBI_NS_NCBI::TGi TGi'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGi(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGi GetGi(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGi& SetGi(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGi(TGi value);
 
 
    /// Check if variant Ddbj is selected.
    ///
    /// Ddbj type is defined as 'typedef CTextseq_id TDdbj'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsDdbj(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TDdbj& GetDdbj(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TDdbj& SetDdbj(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetDdbj(TDdbj& value);
 
 
    /// Check if variant Prf is selected.
    ///
    /// Prf type is defined as 'typedef CTextseq_id TPrf'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsPrf(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TPrf& GetPrf(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TPrf& SetPrf(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetPrf(TPrf& value);
 
 
    /// Check if variant Pdb is selected.
    ///
    /// Pdb type is defined as 'typedef CPDB_seq_id TPdb'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsPdb(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TPdb& GetPdb(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TPdb& SetPdb(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetPdb(TPdb& value);
 
 
    /// Check if variant Tpg is selected.
    ///
    /// Tpg type is defined as 'typedef CTextseq_id TTpg'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsTpg(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TTpg& GetTpg(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TTpg& SetTpg(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetTpg(TTpg& value);
 
 
    /// Check if variant Tpe is selected.
    ///
    /// Tpe type is defined as 'typedef CTextseq_id TTpe'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsTpe(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TTpe& GetTpe(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TTpe& SetTpe(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetTpe(TTpe& value);
 
 
    /// Check if variant Tpd is selected.
    ///
    /// Tpd type is defined as 'typedef CTextseq_id TTpd'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsTpd(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TTpd& GetTpd(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TTpd& SetTpd(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetTpd(TTpd& value);
 
 
    /// Check if variant Gpipe is selected.
    ///
    /// Gpipe type is defined as 'typedef CTextseq_id TGpipe'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGpipe(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TGpipe& GetGpipe(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGpipe& SetGpipe(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetGpipe(TGpipe& value);
 
 
    /// Check if variant Named_annot_track is selected.
    ///
    /// Named_annot_track type is defined as 'typedef CTextseq_id TNamed_annot_track'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsNamed_annot_track(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TNamed_annot_track& GetNamed_annot_track(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TNamed_annot_track& SetNamed_annot_track(void);
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Reference to the data.
    void SetNamed_annot_track(TNamed_annot_track& value);
 
 
private:
    // copy constructor and assignment operator
    CSeq_id_Base(const CSeq_id_Base& );
    CSeq_id_Base& operator=(const CSeq_id_Base& );
    // choice state
    E_Choice m_choice;
    // helper methods
    void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
 
    static const char* const sm_SelectionNames[];
    // data
    union {
        TGibbsq m_Gibbsq;
        TGibbmt m_Gibbmt;
        ncbi::TIntId m_Gi;
        NCBI_NS_NCBI::CSerialObject *m_object;
    };
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
CSeq_id_Base::E_Choice CSeq_id_Base::Which(void) const
{
    return m_choice;
}
 
inline
void CSeq_id_Base::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CSeq_id_Base::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CSeq_id_Base::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CSeq_id_Base::IsLocal(void) const
{
    return m_choice == e_Local;
}
 
inline
bool CSeq_id_Base::IsGibbsq(void) const
{
    return m_choice == e_Gibbsq;
}
 
inline
CSeq_id_Base::TGibbsq CSeq_id_Base::GetGibbsq(void) const
{
    CheckSelected(e_Gibbsq);
    return m_Gibbsq;
}
 
inline
CSeq_id_Base::TGibbsq& CSeq_id_Base::SetGibbsq(void)
{
    Select(e_Gibbsq, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Gibbsq;
}
 
inline
void CSeq_id_Base::SetGibbsq(CSeq_id_Base::TGibbsq value)
{
    Select(e_Gibbsq, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Gibbsq = value;
}
 
inline
bool CSeq_id_Base::IsGibbmt(void) const
{
    return m_choice == e_Gibbmt;
}
 
inline
CSeq_id_Base::TGibbmt CSeq_id_Base::GetGibbmt(void) const
{
    CheckSelected(e_Gibbmt);
    return m_Gibbmt;
}
 
inline
CSeq_id_Base::TGibbmt& CSeq_id_Base::SetGibbmt(void)
{
    Select(e_Gibbmt, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Gibbmt;
}
 
inline
void CSeq_id_Base::SetGibbmt(CSeq_id_Base::TGibbmt value)
{
    Select(e_Gibbmt, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Gibbmt = value;
}
 
inline
bool CSeq_id_Base::IsGiim(void) const
{
    return m_choice == e_Giim;
}
 
inline
bool CSeq_id_Base::IsGenbank(void) const
{
    return m_choice == e_Genbank;
}
 
inline
bool CSeq_id_Base::IsEmbl(void) const
{
    return m_choice == e_Embl;
}
 
inline
bool CSeq_id_Base::IsPir(void) const
{
    return m_choice == e_Pir;
}
 
inline
bool CSeq_id_Base::IsSwissprot(void) const
{
    return m_choice == e_Swissprot;
}
 
inline
bool CSeq_id_Base::IsPatent(void) const
{
    return m_choice == e_Patent;
}
 
inline
bool CSeq_id_Base::IsOther(void) const
{
    return m_choice == e_Other;
}
 
inline
bool CSeq_id_Base::IsGeneral(void) const
{
    return m_choice == e_General;
}
 
inline
bool CSeq_id_Base::IsGi(void) const
{
    return m_choice == e_Gi;
}
 
inline
CSeq_id_Base::TGi CSeq_id_Base::GetGi(void) const
{
    CheckSelected(e_Gi);
    return reinterpret_cast<const TGi&>(m_Gi);
}
 
inline
CSeq_id_Base::TGi& CSeq_id_Base::SetGi(void)
{
    Select(e_Gi, NCBI_NS_NCBI::eDoNotResetVariant);
    return reinterpret_cast<TGi&>(m_Gi);
}
 
inline
void CSeq_id_Base::SetGi(CSeq_id_Base::TGi value)
{
    Select(e_Gi, NCBI_NS_NCBI::eDoNotResetVariant);
    reinterpret_cast<TGi&>(m_Gi) = value;
}
 
inline
bool CSeq_id_Base::IsDdbj(void) const
{
    return m_choice == e_Ddbj;
}
 
inline
bool CSeq_id_Base::IsPrf(void) const
{
    return m_choice == e_Prf;
}
 
inline
bool CSeq_id_Base::IsPdb(void) const
{
    return m_choice == e_Pdb;
}
 
inline
bool CSeq_id_Base::IsTpg(void) const
{
    return m_choice == e_Tpg;
}
 
inline
bool CSeq_id_Base::IsTpe(void) const
{
    return m_choice == e_Tpe;
}
 
inline
bool CSeq_id_Base::IsTpd(void) const
{
    return m_choice == e_Tpd;
}
 
inline
bool CSeq_id_Base::IsGpipe(void) const
{
    return m_choice == e_Gpipe;
}
 
inline
bool CSeq_id_Base::IsNamed_annot_track(void) const
{
    return m_choice == e_Named_annot_track;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_SEQLOC_SEQ_ID_BASE_HPP