PC_XRefData_.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 PC_XRefData_.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/pcsubstance/pcsubstance.asn">pcsubstance.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/pcsubstance/pcsubstance.def">pcsubstance.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_PCSUBSTANCE_PC_XREFDATA_BASE_HPP
#define OBJECTS_PCSUBSTANCE_PC_XREFDATA_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#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::
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_PCSubstance
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
/// Depositor Provided X-Ref and LinkOut data for Entrez
///
/// CPC_XRefData_Base --
///
 
class NCBI_PCSUBSTANCE_EXPORT CPC_XRefData_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CPC_XRefData_Base(void);
    // destructor
    virtual ~CPC_XRefData_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
 
    /// Choice variants.
    enum E_Choice {
        e_not_set = 0,           ///< No variant selected
        e_Regid,                 ///< External Database Registry ID
        e_Rn,                    ///< Registry Number (e.g., EC Number, CAS Number)
        e_Mesh,                  ///< MESH Index Term
        e_Pmid,                  ///< PubMed ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Gi,                    ///< GenBank General ID    Note: Please use protein-gi or nucleotide-gi, if possible    Note: Must be greater than "0" or, if invalid, "0"
        e_Mmdb,                  ///< MMDB ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Sid,                   ///< PubChem Substance ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Cid,                   ///< PubChem Compound ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Dburl,                 ///< Depositor Source Database Homepage
        e_Sburl,                 ///< Depositor Homepage for a Substance
        e_Asurl,                 ///< Depositor Homepage for an Assay
        e_Protein_gi,            ///< GenBank General ID for a Protein    Note: Must be greater than "0" or, if invalid, "0"
        e_Nucleotide_gi,         ///< GenBank General ID for a Nucleotide    Note: Must be greater than "0" or, if invalid, "0"
        e_Taxonomy,              ///< Taxonomy ID for an Organism    Note: Must be greater than "0" or, if invalid, "0"
        e_Aid,                   ///< PubChem BioAssay ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Mim,                   ///< MIM, Mendelian Inheritance in Man, Number    Note: Must be greater than "0" or, if invalid, "0"
        e_Gene,                  ///< Entrez Gene ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Probe,                 ///< Probe ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Biosystem,             ///< BioSystem ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Geogse,                ///< Gene Expression Omnibus Series Accession (GEO GSE) ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Geogsm,                ///< Gene Expression Omnibus Sample Accession (GEO GSM) ID    Note: Must be greater than "0" or, if invalid, "0"
        e_Patent,                ///< Patent Identifier (e.g., USPTO, EPO, WPO, JPO, CPO)
        e_Protein_accession,     ///< GenBank Accession for a Protein
        e_Nucleotide_accession,  ///< GenBank Accession for a Nucleotide
        e_Doi,                   ///< digital object identifier (DOI)
        e_Citation               ///< citation when PMID or DOI are not available
    };
    /// Maximum+1 value of the choice variant enumerator.
    enum E_ChoiceStopper {
        e_MaxChoice = 27 ///< == e_Citation+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 string TRegid;
    typedef string TRn;
    typedef string TMesh;
    typedef int TPmid;
    typedef int TGi;
    typedef int TMmdb;
    typedef int TSid;
    typedef int TCid;
    typedef string TDburl;
    typedef string TSburl;
    typedef string TAsurl;
    typedef int TProtein_gi;
    typedef int TNucleotide_gi;
    typedef int TTaxonomy;
    typedef int TAid;
    typedef int TMim;
    typedef int TGene;
    typedef int TProbe;
    typedef int TBiosystem;
    typedef int TGeogse;
    typedef int TGeogsm;
    typedef string TPatent;
    typedef string TProtein_accession;
    typedef string TNucleotide_accession;
    typedef string TDoi;
    typedef string TCitation;
 
    // getters
    // setters
 
 
    /// Check if variant Regid is selected.
    ///
    /// Regid type is defined as 'typedef string TRegid'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsRegid(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TRegid& GetRegid(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TRegid& SetRegid(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetRegid(const TRegid& value);
 
 
    /// Check if variant Rn is selected.
    ///
    /// Rn type is defined as 'typedef string TRn'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsRn(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TRn& GetRn(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TRn& SetRn(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetRn(const TRn& value);
 
 
    /// Check if variant Mesh is selected.
    ///
    /// Mesh type is defined as 'typedef string TMesh'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsMesh(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TMesh& GetMesh(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TMesh& SetMesh(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetMesh(const TMesh& value);
 
 
    /// Check if variant Pmid is selected.
    ///
    /// Pmid type is defined as 'typedef int TPmid'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsPmid(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TPmid GetPmid(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TPmid& SetPmid(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetPmid(TPmid value);
 
 
    /// Check if variant Gi is selected.
    ///
    /// Gi type is defined as 'typedef int 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 Mmdb is selected.
    ///
    /// Mmdb type is defined as 'typedef int TMmdb'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsMmdb(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TMmdb GetMmdb(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TMmdb& SetMmdb(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetMmdb(TMmdb value);
 
 
    /// Check if variant Sid is selected.
    ///
    /// Sid type is defined as 'typedef int TSid'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsSid(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TSid GetSid(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TSid& SetSid(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetSid(TSid value);
 
 
    /// Check if variant Cid is selected.
    ///
    /// Cid type is defined as 'typedef int TCid'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsCid(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TCid GetCid(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TCid& SetCid(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetCid(TCid value);
 
 
    /// Check if variant Dburl is selected.
    ///
    /// Dburl type is defined as 'typedef string TDburl'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsDburl(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TDburl& GetDburl(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TDburl& SetDburl(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetDburl(const TDburl& value);
 
 
    /// Check if variant Sburl is selected.
    ///
    /// Sburl type is defined as 'typedef string TSburl'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsSburl(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TSburl& GetSburl(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TSburl& SetSburl(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetSburl(const TSburl& value);
 
 
    /// Check if variant Asurl is selected.
    ///
    /// Asurl type is defined as 'typedef string TAsurl'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsAsurl(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TAsurl& GetAsurl(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TAsurl& SetAsurl(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetAsurl(const TAsurl& value);
 
 
    /// Check if variant Protein_gi is selected.
    ///
    /// Protein_gi type is defined as 'typedef int TProtein_gi'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsProtein_gi(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TProtein_gi GetProtein_gi(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TProtein_gi& SetProtein_gi(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetProtein_gi(TProtein_gi value);
 
 
    /// Check if variant Nucleotide_gi is selected.
    ///
    /// Nucleotide_gi type is defined as 'typedef int TNucleotide_gi'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsNucleotide_gi(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TNucleotide_gi GetNucleotide_gi(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TNucleotide_gi& SetNucleotide_gi(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetNucleotide_gi(TNucleotide_gi value);
 
 
    /// Check if variant Taxonomy is selected.
    ///
    /// Taxonomy type is defined as 'typedef int TTaxonomy'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsTaxonomy(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TTaxonomy GetTaxonomy(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TTaxonomy& SetTaxonomy(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetTaxonomy(TTaxonomy value);
 
 
    /// Check if variant Aid is selected.
    ///
    /// Aid type is defined as 'typedef int TAid'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsAid(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TAid GetAid(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TAid& SetAid(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetAid(TAid value);
 
 
    /// Check if variant Mim is selected.
    ///
    /// Mim type is defined as 'typedef int TMim'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsMim(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TMim GetMim(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TMim& SetMim(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetMim(TMim value);
 
 
    /// Check if variant Gene is selected.
    ///
    /// Gene type is defined as 'typedef int TGene'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGene(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGene GetGene(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGene& SetGene(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGene(TGene value);
 
 
    /// Check if variant Probe is selected.
    ///
    /// Probe type is defined as 'typedef int TProbe'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsProbe(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TProbe GetProbe(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TProbe& SetProbe(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetProbe(TProbe value);
 
 
    /// Check if variant Biosystem is selected.
    ///
    /// Biosystem type is defined as 'typedef int TBiosystem'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsBiosystem(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TBiosystem GetBiosystem(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TBiosystem& SetBiosystem(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetBiosystem(TBiosystem value);
 
 
    /// Check if variant Geogse is selected.
    ///
    /// Geogse type is defined as 'typedef int TGeogse'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGeogse(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGeogse GetGeogse(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGeogse& SetGeogse(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGeogse(TGeogse value);
 
 
    /// Check if variant Geogsm is selected.
    ///
    /// Geogsm type is defined as 'typedef int TGeogsm'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsGeogsm(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Copy of the variant data.
    TGeogsm GetGeogsm(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TGeogsm& SetGeogsm(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetGeogsm(TGeogsm value);
 
 
    /// Check if variant Patent is selected.
    ///
    /// Patent type is defined as 'typedef string 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
    ///   Variant data.
    void SetPatent(const TPatent& value);
 
 
    /// Check if variant Protein_accession is selected.
    ///
    /// Protein_accession type is defined as 'typedef string TProtein_accession'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsProtein_accession(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TProtein_accession& GetProtein_accession(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TProtein_accession& SetProtein_accession(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetProtein_accession(const TProtein_accession& value);
 
 
    /// Check if variant Nucleotide_accession is selected.
    ///
    /// Nucleotide_accession type is defined as 'typedef string TNucleotide_accession'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsNucleotide_accession(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TNucleotide_accession& GetNucleotide_accession(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TNucleotide_accession& SetNucleotide_accession(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetNucleotide_accession(const TNucleotide_accession& value);
 
 
    /// Check if variant Doi is selected.
    ///
    /// Doi type is defined as 'typedef string TDoi'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsDoi(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TDoi& GetDoi(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TDoi& SetDoi(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetDoi(const TDoi& value);
 
 
    /// Check if variant Citation is selected.
    ///
    /// Citation type is defined as 'typedef string TCitation'.
    /// @return
    ///   - true, if the variant is selected.
    ///   - false, otherwise.
    bool IsCitation(void) const;
 
    /// Get the variant data.
    ///
    /// @return
    ///   Reference to the data.
    const TCitation& GetCitation(void) const;
 
    /// Select the variant.
    ///
    /// @return
    ///   Reference to the variant data.
    TCitation& SetCitation(void);
 
    /// Select the variant and set its data.
    ///
    /// @param value
    ///   Variant data.
    void SetCitation(const TCitation& value);
 
 
private:
    // copy constructor and assignment operator
    CPC_XRefData_Base(const CPC_XRefData_Base& );
    CPC_XRefData_Base& operator=(const CPC_XRefData_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 {
        TPmid m_Pmid;
        TGi m_Gi;
        TMmdb m_Mmdb;
        TSid m_Sid;
        TCid m_Cid;
        TProtein_gi m_Protein_gi;
        TNucleotide_gi m_Nucleotide_gi;
        TTaxonomy m_Taxonomy;
        TAid m_Aid;
        TMim m_Mim;
        TGene m_Gene;
        TProbe m_Probe;
        TBiosystem m_Biosystem;
        TGeogse m_Geogse;
        TGeogsm m_Geogsm;
        NCBI_NS_NCBI::CUnionBuffer<NCBI_NS_STD::string> m_string;
        void* m_dummy_pointer_for_alignment;
    };
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
CPC_XRefData_Base::E_Choice CPC_XRefData_Base::Which(void) const
{
    return m_choice;
}
 
inline
void CPC_XRefData_Base::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CPC_XRefData_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 CPC_XRefData_Base::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CPC_XRefData_Base::IsRegid(void) const
{
    return m_choice == e_Regid;
}
 
inline
const CPC_XRefData_Base::TRegid& CPC_XRefData_Base::GetRegid(void) const
{
    CheckSelected(e_Regid);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TRegid& CPC_XRefData_Base::SetRegid(void)
{
    Select(e_Regid, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsRn(void) const
{
    return m_choice == e_Rn;
}
 
inline
const CPC_XRefData_Base::TRn& CPC_XRefData_Base::GetRn(void) const
{
    CheckSelected(e_Rn);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TRn& CPC_XRefData_Base::SetRn(void)
{
    Select(e_Rn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsMesh(void) const
{
    return m_choice == e_Mesh;
}
 
inline
const CPC_XRefData_Base::TMesh& CPC_XRefData_Base::GetMesh(void) const
{
    CheckSelected(e_Mesh);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TMesh& CPC_XRefData_Base::SetMesh(void)
{
    Select(e_Mesh, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsPmid(void) const
{
    return m_choice == e_Pmid;
}
 
inline
CPC_XRefData_Base::TPmid CPC_XRefData_Base::GetPmid(void) const
{
    CheckSelected(e_Pmid);
    return m_Pmid;
}
 
inline
CPC_XRefData_Base::TPmid& CPC_XRefData_Base::SetPmid(void)
{
    Select(e_Pmid, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Pmid;
}
 
inline
void CPC_XRefData_Base::SetPmid(CPC_XRefData_Base::TPmid value)
{
    Select(e_Pmid, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Pmid = value;
}
 
inline
bool CPC_XRefData_Base::IsGi(void) const
{
    return m_choice == e_Gi;
}
 
inline
CPC_XRefData_Base::TGi CPC_XRefData_Base::GetGi(void) const
{
    CheckSelected(e_Gi);
    return m_Gi;
}
 
inline
CPC_XRefData_Base::TGi& CPC_XRefData_Base::SetGi(void)
{
    Select(e_Gi, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Gi;
}
 
inline
void CPC_XRefData_Base::SetGi(CPC_XRefData_Base::TGi value)
{
    Select(e_Gi, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Gi = value;
}
 
inline
bool CPC_XRefData_Base::IsMmdb(void) const
{
    return m_choice == e_Mmdb;
}
 
inline
CPC_XRefData_Base::TMmdb CPC_XRefData_Base::GetMmdb(void) const
{
    CheckSelected(e_Mmdb);
    return m_Mmdb;
}
 
inline
CPC_XRefData_Base::TMmdb& CPC_XRefData_Base::SetMmdb(void)
{
    Select(e_Mmdb, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Mmdb;
}
 
inline
void CPC_XRefData_Base::SetMmdb(CPC_XRefData_Base::TMmdb value)
{
    Select(e_Mmdb, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Mmdb = value;
}
 
inline
bool CPC_XRefData_Base::IsSid(void) const
{
    return m_choice == e_Sid;
}
 
inline
CPC_XRefData_Base::TSid CPC_XRefData_Base::GetSid(void) const
{
    CheckSelected(e_Sid);
    return m_Sid;
}
 
inline
CPC_XRefData_Base::TSid& CPC_XRefData_Base::SetSid(void)
{
    Select(e_Sid, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Sid;
}
 
inline
void CPC_XRefData_Base::SetSid(CPC_XRefData_Base::TSid value)
{
    Select(e_Sid, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Sid = value;
}
 
inline
bool CPC_XRefData_Base::IsCid(void) const
{
    return m_choice == e_Cid;
}
 
inline
CPC_XRefData_Base::TCid CPC_XRefData_Base::GetCid(void) const
{
    CheckSelected(e_Cid);
    return m_Cid;
}
 
inline
CPC_XRefData_Base::TCid& CPC_XRefData_Base::SetCid(void)
{
    Select(e_Cid, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Cid;
}
 
inline
void CPC_XRefData_Base::SetCid(CPC_XRefData_Base::TCid value)
{
    Select(e_Cid, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Cid = value;
}
 
inline
bool CPC_XRefData_Base::IsDburl(void) const
{
    return m_choice == e_Dburl;
}
 
inline
const CPC_XRefData_Base::TDburl& CPC_XRefData_Base::GetDburl(void) const
{
    CheckSelected(e_Dburl);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TDburl& CPC_XRefData_Base::SetDburl(void)
{
    Select(e_Dburl, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsSburl(void) const
{
    return m_choice == e_Sburl;
}
 
inline
const CPC_XRefData_Base::TSburl& CPC_XRefData_Base::GetSburl(void) const
{
    CheckSelected(e_Sburl);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TSburl& CPC_XRefData_Base::SetSburl(void)
{
    Select(e_Sburl, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsAsurl(void) const
{
    return m_choice == e_Asurl;
}
 
inline
const CPC_XRefData_Base::TAsurl& CPC_XRefData_Base::GetAsurl(void) const
{
    CheckSelected(e_Asurl);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TAsurl& CPC_XRefData_Base::SetAsurl(void)
{
    Select(e_Asurl, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsProtein_gi(void) const
{
    return m_choice == e_Protein_gi;
}
 
inline
CPC_XRefData_Base::TProtein_gi CPC_XRefData_Base::GetProtein_gi(void) const
{
    CheckSelected(e_Protein_gi);
    return m_Protein_gi;
}
 
inline
CPC_XRefData_Base::TProtein_gi& CPC_XRefData_Base::SetProtein_gi(void)
{
    Select(e_Protein_gi, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Protein_gi;
}
 
inline
void CPC_XRefData_Base::SetProtein_gi(CPC_XRefData_Base::TProtein_gi value)
{
    Select(e_Protein_gi, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Protein_gi = value;
}
 
inline
bool CPC_XRefData_Base::IsNucleotide_gi(void) const
{
    return m_choice == e_Nucleotide_gi;
}
 
inline
CPC_XRefData_Base::TNucleotide_gi CPC_XRefData_Base::GetNucleotide_gi(void) const
{
    CheckSelected(e_Nucleotide_gi);
    return m_Nucleotide_gi;
}
 
inline
CPC_XRefData_Base::TNucleotide_gi& CPC_XRefData_Base::SetNucleotide_gi(void)
{
    Select(e_Nucleotide_gi, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Nucleotide_gi;
}
 
inline
void CPC_XRefData_Base::SetNucleotide_gi(CPC_XRefData_Base::TNucleotide_gi value)
{
    Select(e_Nucleotide_gi, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Nucleotide_gi = value;
}
 
inline
bool CPC_XRefData_Base::IsTaxonomy(void) const
{
    return m_choice == e_Taxonomy;
}
 
inline
CPC_XRefData_Base::TTaxonomy CPC_XRefData_Base::GetTaxonomy(void) const
{
    CheckSelected(e_Taxonomy);
    return m_Taxonomy;
}
 
inline
CPC_XRefData_Base::TTaxonomy& CPC_XRefData_Base::SetTaxonomy(void)
{
    Select(e_Taxonomy, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Taxonomy;
}
 
inline
void CPC_XRefData_Base::SetTaxonomy(CPC_XRefData_Base::TTaxonomy value)
{
    Select(e_Taxonomy, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Taxonomy = value;
}
 
inline
bool CPC_XRefData_Base::IsAid(void) const
{
    return m_choice == e_Aid;
}
 
inline
CPC_XRefData_Base::TAid CPC_XRefData_Base::GetAid(void) const
{
    CheckSelected(e_Aid);
    return m_Aid;
}
 
inline
CPC_XRefData_Base::TAid& CPC_XRefData_Base::SetAid(void)
{
    Select(e_Aid, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Aid;
}
 
inline
void CPC_XRefData_Base::SetAid(CPC_XRefData_Base::TAid value)
{
    Select(e_Aid, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Aid = value;
}
 
inline
bool CPC_XRefData_Base::IsMim(void) const
{
    return m_choice == e_Mim;
}
 
inline
CPC_XRefData_Base::TMim CPC_XRefData_Base::GetMim(void) const
{
    CheckSelected(e_Mim);
    return m_Mim;
}
 
inline
CPC_XRefData_Base::TMim& CPC_XRefData_Base::SetMim(void)
{
    Select(e_Mim, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Mim;
}
 
inline
void CPC_XRefData_Base::SetMim(CPC_XRefData_Base::TMim value)
{
    Select(e_Mim, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Mim = value;
}
 
inline
bool CPC_XRefData_Base::IsGene(void) const
{
    return m_choice == e_Gene;
}
 
inline
CPC_XRefData_Base::TGene CPC_XRefData_Base::GetGene(void) const
{
    CheckSelected(e_Gene);
    return m_Gene;
}
 
inline
CPC_XRefData_Base::TGene& CPC_XRefData_Base::SetGene(void)
{
    Select(e_Gene, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Gene;
}
 
inline
void CPC_XRefData_Base::SetGene(CPC_XRefData_Base::TGene value)
{
    Select(e_Gene, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Gene = value;
}
 
inline
bool CPC_XRefData_Base::IsProbe(void) const
{
    return m_choice == e_Probe;
}
 
inline
CPC_XRefData_Base::TProbe CPC_XRefData_Base::GetProbe(void) const
{
    CheckSelected(e_Probe);
    return m_Probe;
}
 
inline
CPC_XRefData_Base::TProbe& CPC_XRefData_Base::SetProbe(void)
{
    Select(e_Probe, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Probe;
}
 
inline
void CPC_XRefData_Base::SetProbe(CPC_XRefData_Base::TProbe value)
{
    Select(e_Probe, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Probe = value;
}
 
inline
bool CPC_XRefData_Base::IsBiosystem(void) const
{
    return m_choice == e_Biosystem;
}
 
inline
CPC_XRefData_Base::TBiosystem CPC_XRefData_Base::GetBiosystem(void) const
{
    CheckSelected(e_Biosystem);
    return m_Biosystem;
}
 
inline
CPC_XRefData_Base::TBiosystem& CPC_XRefData_Base::SetBiosystem(void)
{
    Select(e_Biosystem, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Biosystem;
}
 
inline
void CPC_XRefData_Base::SetBiosystem(CPC_XRefData_Base::TBiosystem value)
{
    Select(e_Biosystem, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Biosystem = value;
}
 
inline
bool CPC_XRefData_Base::IsGeogse(void) const
{
    return m_choice == e_Geogse;
}
 
inline
CPC_XRefData_Base::TGeogse CPC_XRefData_Base::GetGeogse(void) const
{
    CheckSelected(e_Geogse);
    return m_Geogse;
}
 
inline
CPC_XRefData_Base::TGeogse& CPC_XRefData_Base::SetGeogse(void)
{
    Select(e_Geogse, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Geogse;
}
 
inline
void CPC_XRefData_Base::SetGeogse(CPC_XRefData_Base::TGeogse value)
{
    Select(e_Geogse, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Geogse = value;
}
 
inline
bool CPC_XRefData_Base::IsGeogsm(void) const
{
    return m_choice == e_Geogsm;
}
 
inline
CPC_XRefData_Base::TGeogsm CPC_XRefData_Base::GetGeogsm(void) const
{
    CheckSelected(e_Geogsm);
    return m_Geogsm;
}
 
inline
CPC_XRefData_Base::TGeogsm& CPC_XRefData_Base::SetGeogsm(void)
{
    Select(e_Geogsm, NCBI_NS_NCBI::eDoNotResetVariant);
    return m_Geogsm;
}
 
inline
void CPC_XRefData_Base::SetGeogsm(CPC_XRefData_Base::TGeogsm value)
{
    Select(e_Geogsm, NCBI_NS_NCBI::eDoNotResetVariant);
    m_Geogsm = value;
}
 
inline
bool CPC_XRefData_Base::IsPatent(void) const
{
    return m_choice == e_Patent;
}
 
inline
const CPC_XRefData_Base::TPatent& CPC_XRefData_Base::GetPatent(void) const
{
    CheckSelected(e_Patent);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TPatent& CPC_XRefData_Base::SetPatent(void)
{
    Select(e_Patent, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsProtein_accession(void) const
{
    return m_choice == e_Protein_accession;
}
 
inline
const CPC_XRefData_Base::TProtein_accession& CPC_XRefData_Base::GetProtein_accession(void) const
{
    CheckSelected(e_Protein_accession);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TProtein_accession& CPC_XRefData_Base::SetProtein_accession(void)
{
    Select(e_Protein_accession, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsNucleotide_accession(void) const
{
    return m_choice == e_Nucleotide_accession;
}
 
inline
const CPC_XRefData_Base::TNucleotide_accession& CPC_XRefData_Base::GetNucleotide_accession(void) const
{
    CheckSelected(e_Nucleotide_accession);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TNucleotide_accession& CPC_XRefData_Base::SetNucleotide_accession(void)
{
    Select(e_Nucleotide_accession, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsDoi(void) const
{
    return m_choice == e_Doi;
}
 
inline
const CPC_XRefData_Base::TDoi& CPC_XRefData_Base::GetDoi(void) const
{
    CheckSelected(e_Doi);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TDoi& CPC_XRefData_Base::SetDoi(void)
{
    Select(e_Doi, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
inline
bool CPC_XRefData_Base::IsCitation(void) const
{
    return m_choice == e_Citation;
}
 
inline
const CPC_XRefData_Base::TCitation& CPC_XRefData_Base::GetCitation(void) const
{
    CheckSelected(e_Citation);
    return *m_string;
}
 
inline
CPC_XRefData_Base::TCitation& CPC_XRefData_Base::SetCitation(void)
{
    Select(e_Citation, NCBI_NS_NCBI::eDoNotResetVariant);
    return *m_string;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_PCSUBSTANCE_PC_XREFDATA_BASE_HPP