Mim_reference_.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 Mim_reference_.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/mim/mim.asn">mim.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/mim/mim.def">mim.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_MIM_MIM_REFERENCE_BASE_HPP
#define OBJECTS_MIM_MIM_REFERENCE_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 CMim_author;
class CMim_date;
class CMim_page;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_Mim
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///
/// CMim_reference_Base --
///
 
class NCBI_MIM_EXPORT CMim_reference_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CMim_reference_Base(void);
    // destructor
    virtual ~CMim_reference_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    enum EType {
        eType_not_set                = 0,
        eType_citation               = 1,
        eType_book                   = 2,
        eType_personal_communication = 3,
        eType_book_citation          = 4
    };
    
    /// Access to EType's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EType)(void);
    
    // types
    typedef int TNumber;
    typedef int TOrigNumber;
    typedef EType TType;
    typedef list< CRef< CMim_author > > TAuthors;
    typedef string TPrimaryAuthor;
    typedef string TOtherAuthors;
    typedef string TCitationTitle;
    typedef int TCitationType;
    typedef string TBookTitle;
    typedef list< CRef< CMim_author > > TEditors;
    typedef string TVolume;
    typedef string TEdition;
    typedef string TJournal;
    typedef string TSeries;
    typedef string TPublisher;
    typedef string TPlace;
    typedef string TCommNote;
    typedef CMim_date TPubDate;
    typedef list< CRef< CMim_page > > TPages;
    typedef string TMiscInfo;
    typedef int TPubmedUID;
    typedef bool TAmbiguous;
    typedef bool TNoLink;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_number,
        e_origNumber,
        e_type,
        e_authors,
        e_primaryAuthor,
        e_otherAuthors,
        e_citationTitle,
        e_citationType,
        e_bookTitle,
        e_editors,
        e_volume,
        e_edition,
        e_journal,
        e_series,
        e_publisher,
        e_place,
        e_commNote,
        e_pubDate,
        e_pages,
        e_miscInfo,
        e_pubmedUID,
        e_ambiguous,
        e_noLink
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 24> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Number data member.
    ///
    /// Data member Number is mandatory;
    /// its type is defined as 'typedef int TNumber'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetNumber(void) const;
 
    /// Check if it is safe to call GetNumber method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetNumber(void) const;
 
    /// Reset Number data member.
    void ResetNumber(void);
 
    /// Get the Number member data.
    ///
    /// @return
    ///   Copy of the member data.
    TNumber GetNumber(void) const;
 
    /// Assign a value to Number data member.
    ///
    /// @param value
    ///   Value to assign
    void SetNumber(TNumber value);
 
    /// Assign a value to Number data member.
    ///
    /// @return
    ///   Reference to the data value.
    TNumber& SetNumber(void);
 
    /// Check if a value has been assigned to OrigNumber data member.
    ///
    /// Data member OrigNumber is optional;
    /// its type is defined as 'typedef int TOrigNumber'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetOrigNumber(void) const;
 
    /// Check if it is safe to call GetOrigNumber method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetOrigNumber(void) const;
 
    /// Reset OrigNumber data member.
    void ResetOrigNumber(void);
 
    /// Get the OrigNumber member data.
    ///
    /// @return
    ///   Copy of the member data.
    TOrigNumber GetOrigNumber(void) const;
 
    /// Assign a value to OrigNumber data member.
    ///
    /// @param value
    ///   Value to assign
    void SetOrigNumber(TOrigNumber value);
 
    /// Assign a value to OrigNumber data member.
    ///
    /// @return
    ///   Reference to the data value.
    TOrigNumber& SetOrigNumber(void);
 
    /// Check if a value has been assigned to Type data member.
    ///
    /// Data member Type is optional;
    /// its type is defined as 'typedef EType TType'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetType(void) const;
 
    /// Check if it is safe to call GetType method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetType(void) const;
 
    /// Reset Type data member.
    void ResetType(void);
 
    /// Get the Type member data.
    ///
    /// @return
    ///   Copy of the member data.
    TType GetType(void) const;
 
    /// Assign a value to Type data member.
    ///
    /// @param value
    ///   Value to assign
    void SetType(TType value);
 
    /// Assign a value to Type data member.
    ///
    /// @return
    ///   Reference to the data value.
    TType& SetType(void);
 
    /// Check if a value has been assigned to Authors data member.
    ///
    /// Data member Authors is mandatory;
    /// its type is defined as 'typedef list< CRef< CMim_author > > TAuthors'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAuthors(void) const;
 
    /// Check if it is safe to call GetAuthors method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAuthors(void) const;
 
    /// Reset Authors data member.
    void ResetAuthors(void);
 
    /// Get the Authors member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAuthors& GetAuthors(void) const;
 
    /// Assign a value to Authors data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAuthors& SetAuthors(void);
 
    /// Check if a value has been assigned to PrimaryAuthor data member.
    ///
    /// Data member PrimaryAuthor is mandatory;
    /// its type is defined as 'typedef string TPrimaryAuthor'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPrimaryAuthor(void) const;
 
    /// Check if it is safe to call GetPrimaryAuthor method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPrimaryAuthor(void) const;
 
    /// Reset PrimaryAuthor data member.
    void ResetPrimaryAuthor(void);
 
    /// Get the PrimaryAuthor member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPrimaryAuthor& GetPrimaryAuthor(void) const;
 
    /// Assign a value to PrimaryAuthor data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPrimaryAuthor(const TPrimaryAuthor& value);
    void SetPrimaryAuthor(TPrimaryAuthor&& value);
 
    /// Assign a value to PrimaryAuthor data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPrimaryAuthor& SetPrimaryAuthor(void);
 
    /// Check if a value has been assigned to OtherAuthors data member.
    ///
    /// Data member OtherAuthors is mandatory;
    /// its type is defined as 'typedef string TOtherAuthors'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetOtherAuthors(void) const;
 
    /// Check if it is safe to call GetOtherAuthors method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetOtherAuthors(void) const;
 
    /// Reset OtherAuthors data member.
    void ResetOtherAuthors(void);
 
    /// Get the OtherAuthors member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TOtherAuthors& GetOtherAuthors(void) const;
 
    /// Assign a value to OtherAuthors data member.
    ///
    /// @param value
    ///   Value to assign
    void SetOtherAuthors(const TOtherAuthors& value);
    void SetOtherAuthors(TOtherAuthors&& value);
 
    /// Assign a value to OtherAuthors data member.
    ///
    /// @return
    ///   Reference to the data value.
    TOtherAuthors& SetOtherAuthors(void);
 
    /// Check if a value has been assigned to CitationTitle data member.
    ///
    /// Data member CitationTitle is mandatory;
    /// its type is defined as 'typedef string TCitationTitle'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetCitationTitle(void) const;
 
    /// Check if it is safe to call GetCitationTitle method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetCitationTitle(void) const;
 
    /// Reset CitationTitle data member.
    void ResetCitationTitle(void);
 
    /// Get the CitationTitle member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TCitationTitle& GetCitationTitle(void) const;
 
    /// Assign a value to CitationTitle data member.
    ///
    /// @param value
    ///   Value to assign
    void SetCitationTitle(const TCitationTitle& value);
    void SetCitationTitle(TCitationTitle&& value);
 
    /// Assign a value to CitationTitle data member.
    ///
    /// @return
    ///   Reference to the data value.
    TCitationTitle& SetCitationTitle(void);
 
    /// Check if a value has been assigned to CitationType data member.
    ///
    /// Data member CitationType is optional;
    /// its type is defined as 'typedef int TCitationType'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetCitationType(void) const;
 
    /// Check if it is safe to call GetCitationType method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetCitationType(void) const;
 
    /// Reset CitationType data member.
    void ResetCitationType(void);
 
    /// Get the CitationType member data.
    ///
    /// @return
    ///   Copy of the member data.
    TCitationType GetCitationType(void) const;
 
    /// Assign a value to CitationType data member.
    ///
    /// @param value
    ///   Value to assign
    void SetCitationType(TCitationType value);
 
    /// Assign a value to CitationType data member.
    ///
    /// @return
    ///   Reference to the data value.
    TCitationType& SetCitationType(void);
 
    /// Check if a value has been assigned to BookTitle data member.
    ///
    /// Data member BookTitle is optional;
    /// its type is defined as 'typedef string TBookTitle'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetBookTitle(void) const;
 
    /// Check if it is safe to call GetBookTitle method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetBookTitle(void) const;
 
    /// Reset BookTitle data member.
    void ResetBookTitle(void);
 
    /// Get the BookTitle member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TBookTitle& GetBookTitle(void) const;
 
    /// Assign a value to BookTitle data member.
    ///
    /// @param value
    ///   Value to assign
    void SetBookTitle(const TBookTitle& value);
    void SetBookTitle(TBookTitle&& value);
 
    /// Assign a value to BookTitle data member.
    ///
    /// @return
    ///   Reference to the data value.
    TBookTitle& SetBookTitle(void);
 
    /// Check if a value has been assigned to Editors data member.
    ///
    /// Data member Editors is optional;
    /// its type is defined as 'typedef list< CRef< CMim_author > > TEditors'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetEditors(void) const;
 
    /// Check if it is safe to call GetEditors method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetEditors(void) const;
 
    /// Reset Editors data member.
    void ResetEditors(void);
 
    /// Get the Editors member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TEditors& GetEditors(void) const;
 
    /// Assign a value to Editors data member.
    ///
    /// @return
    ///   Reference to the data value.
    TEditors& SetEditors(void);
 
    /// Check if a value has been assigned to Volume data member.
    ///
    /// Data member Volume is optional;
    /// its type is defined as 'typedef string TVolume'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetVolume(void) const;
 
    /// Check if it is safe to call GetVolume method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetVolume(void) const;
 
    /// Reset Volume data member.
    void ResetVolume(void);
 
    /// Get the Volume member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TVolume& GetVolume(void) const;
 
    /// Assign a value to Volume data member.
    ///
    /// @param value
    ///   Value to assign
    void SetVolume(const TVolume& value);
    void SetVolume(TVolume&& value);
 
    /// Assign a value to Volume data member.
    ///
    /// @return
    ///   Reference to the data value.
    TVolume& SetVolume(void);
 
    /// Check if a value has been assigned to Edition data member.
    ///
    /// Data member Edition is optional;
    /// its type is defined as 'typedef string TEdition'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetEdition(void) const;
 
    /// Check if it is safe to call GetEdition method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetEdition(void) const;
 
    /// Reset Edition data member.
    void ResetEdition(void);
 
    /// Get the Edition member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TEdition& GetEdition(void) const;
 
    /// Assign a value to Edition data member.
    ///
    /// @param value
    ///   Value to assign
    void SetEdition(const TEdition& value);
    void SetEdition(TEdition&& value);
 
    /// Assign a value to Edition data member.
    ///
    /// @return
    ///   Reference to the data value.
    TEdition& SetEdition(void);
 
    /// Check if a value has been assigned to Journal data member.
    ///
    /// Data member Journal is optional;
    /// its type is defined as 'typedef string TJournal'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetJournal(void) const;
 
    /// Check if it is safe to call GetJournal method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetJournal(void) const;
 
    /// Reset Journal data member.
    void ResetJournal(void);
 
    /// Get the Journal member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TJournal& GetJournal(void) const;
 
    /// Assign a value to Journal data member.
    ///
    /// @param value
    ///   Value to assign
    void SetJournal(const TJournal& value);
    void SetJournal(TJournal&& value);
 
    /// Assign a value to Journal data member.
    ///
    /// @return
    ///   Reference to the data value.
    TJournal& SetJournal(void);
 
    /// Check if a value has been assigned to Series data member.
    ///
    /// Data member Series is optional;
    /// its type is defined as 'typedef string TSeries'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetSeries(void) const;
 
    /// Check if it is safe to call GetSeries method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetSeries(void) const;
 
    /// Reset Series data member.
    void ResetSeries(void);
 
    /// Get the Series member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TSeries& GetSeries(void) const;
 
    /// Assign a value to Series data member.
    ///
    /// @param value
    ///   Value to assign
    void SetSeries(const TSeries& value);
    void SetSeries(TSeries&& value);
 
    /// Assign a value to Series data member.
    ///
    /// @return
    ///   Reference to the data value.
    TSeries& SetSeries(void);
 
    /// Check if a value has been assigned to Publisher data member.
    ///
    /// Data member Publisher is optional;
    /// its type is defined as 'typedef string TPublisher'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPublisher(void) const;
 
    /// Check if it is safe to call GetPublisher method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPublisher(void) const;
 
    /// Reset Publisher data member.
    void ResetPublisher(void);
 
    /// Get the Publisher member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPublisher& GetPublisher(void) const;
 
    /// Assign a value to Publisher data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPublisher(const TPublisher& value);
    void SetPublisher(TPublisher&& value);
 
    /// Assign a value to Publisher data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPublisher& SetPublisher(void);
 
    /// Check if a value has been assigned to Place data member.
    ///
    /// Data member Place is optional;
    /// its type is defined as 'typedef string TPlace'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPlace(void) const;
 
    /// Check if it is safe to call GetPlace method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPlace(void) const;
 
    /// Reset Place data member.
    void ResetPlace(void);
 
    /// Get the Place member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPlace& GetPlace(void) const;
 
    /// Assign a value to Place data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPlace(const TPlace& value);
    void SetPlace(TPlace&& value);
 
    /// Assign a value to Place data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPlace& SetPlace(void);
 
    /// Check if a value has been assigned to CommNote data member.
    ///
    /// Data member CommNote is optional;
    /// its type is defined as 'typedef string TCommNote'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetCommNote(void) const;
 
    /// Check if it is safe to call GetCommNote method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetCommNote(void) const;
 
    /// Reset CommNote data member.
    void ResetCommNote(void);
 
    /// Get the CommNote member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TCommNote& GetCommNote(void) const;
 
    /// Assign a value to CommNote data member.
    ///
    /// @param value
    ///   Value to assign
    void SetCommNote(const TCommNote& value);
    void SetCommNote(TCommNote&& value);
 
    /// Assign a value to CommNote data member.
    ///
    /// @return
    ///   Reference to the data value.
    TCommNote& SetCommNote(void);
 
    /// Check if a value has been assigned to PubDate data member.
    ///
    /// Data member PubDate is mandatory;
    /// its type is defined as 'typedef CMim_date TPubDate'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPubDate(void) const;
 
    /// Check if it is safe to call GetPubDate method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPubDate(void) const;
 
    /// Reset PubDate data member.
    void ResetPubDate(void);
 
    /// Get the PubDate member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPubDate& GetPubDate(void) const;
 
    /// Assign a value to PubDate data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetPubDate(TPubDate& value);
 
    /// Assign a value to PubDate data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPubDate& SetPubDate(void);
 
    /// Check if a value has been assigned to Pages data member.
    ///
    /// Data member Pages is optional;
    /// its type is defined as 'typedef list< CRef< CMim_page > > TPages'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPages(void) const;
 
    /// Check if it is safe to call GetPages method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPages(void) const;
 
    /// Reset Pages data member.
    void ResetPages(void);
 
    /// Get the Pages member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPages& GetPages(void) const;
 
    /// Assign a value to Pages data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPages& SetPages(void);
 
    /// Check if a value has been assigned to MiscInfo data member.
    ///
    /// Data member MiscInfo is optional;
    /// its type is defined as 'typedef string TMiscInfo'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMiscInfo(void) const;
 
    /// Check if it is safe to call GetMiscInfo method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMiscInfo(void) const;
 
    /// Reset MiscInfo data member.
    void ResetMiscInfo(void);
 
    /// Get the MiscInfo member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TMiscInfo& GetMiscInfo(void) const;
 
    /// Assign a value to MiscInfo data member.
    ///
    /// @param value
    ///   Value to assign
    void SetMiscInfo(const TMiscInfo& value);
    void SetMiscInfo(TMiscInfo&& value);
 
    /// Assign a value to MiscInfo data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMiscInfo& SetMiscInfo(void);
 
    /// Check if a value has been assigned to PubmedUID data member.
    ///
    /// Data member PubmedUID is optional;
    /// its type is defined as 'typedef int TPubmedUID'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPubmedUID(void) const;
 
    /// Check if it is safe to call GetPubmedUID method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPubmedUID(void) const;
 
    /// Reset PubmedUID data member.
    void ResetPubmedUID(void);
 
    /// Get the PubmedUID member data.
    ///
    /// @return
    ///   Copy of the member data.
    TPubmedUID GetPubmedUID(void) const;
 
    /// Assign a value to PubmedUID data member.
    ///
    /// @param value
    ///   Value to assign
    void SetPubmedUID(TPubmedUID value);
 
    /// Assign a value to PubmedUID data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPubmedUID& SetPubmedUID(void);
 
    /// Check if a value has been assigned to Ambiguous data member.
    ///
    /// Data member Ambiguous is mandatory;
    /// its type is defined as 'typedef bool TAmbiguous'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAmbiguous(void) const;
 
    /// Check if it is safe to call GetAmbiguous method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAmbiguous(void) const;
 
    /// Reset Ambiguous data member.
    void ResetAmbiguous(void);
 
    /// Get the Ambiguous member data.
    ///
    /// @return
    ///   Copy of the member data.
    TAmbiguous GetAmbiguous(void) const;
 
    /// Assign a value to Ambiguous data member.
    ///
    /// @param value
    ///   Value to assign
    void SetAmbiguous(TAmbiguous value);
 
    /// Assign a value to Ambiguous data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAmbiguous& SetAmbiguous(void);
 
    /// Check if a value has been assigned to NoLink data member.
    ///
    /// Data member NoLink is optional;
    /// its type is defined as 'typedef bool TNoLink'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetNoLink(void) const;
 
    /// Check if it is safe to call GetNoLink method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetNoLink(void) const;
 
    /// Reset NoLink data member.
    void ResetNoLink(void);
 
    /// Get the NoLink member data.
    ///
    /// @return
    ///   Copy of the member data.
    TNoLink GetNoLink(void) const;
 
    /// Assign a value to NoLink data member.
    ///
    /// @param value
    ///   Value to assign
    void SetNoLink(TNoLink value);
 
    /// Assign a value to NoLink data member.
    ///
    /// @return
    ///   Reference to the data value.
    TNoLink& SetNoLink(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CMim_reference_Base(const CMim_reference_Base&);
    CMim_reference_Base& operator=(const CMim_reference_Base&);
 
    // data
    Uint4 m_set_State[2];
    int m_Number;
    int m_OrigNumber;
    EType m_Type;
    list< CRef< CMim_author > > m_Authors;
    string m_PrimaryAuthor;
    string m_OtherAuthors;
    string m_CitationTitle;
    int m_CitationType;
    string m_BookTitle;
    list< CRef< CMim_author > > m_Editors;
    string m_Volume;
    string m_Edition;
    string m_Journal;
    string m_Series;
    string m_Publisher;
    string m_Place;
    string m_CommNote;
    CRef< TPubDate > m_PubDate;
    list< CRef< CMim_page > > m_Pages;
    string m_MiscInfo;
    int m_PubmedUID;
    bool m_Ambiguous;
    bool m_NoLink;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CMim_reference_Base::IsSetNumber(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CMim_reference_Base::CanGetNumber(void) const
{
    return IsSetNumber();
}
 
inline
void CMim_reference_Base::ResetNumber(void)
{
    m_Number = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CMim_reference_Base::TNumber CMim_reference_Base::GetNumber(void) const
{
    if (!CanGetNumber()) {
        ThrowUnassigned(0);
    }
    return m_Number;
}
 
inline
void CMim_reference_Base::SetNumber(CMim_reference_Base::TNumber value)
{
    m_Number = value;
    m_set_State[0] |= 0x3;
}
 
inline
CMim_reference_Base::TNumber& CMim_reference_Base::SetNumber(void)
{
#ifdef _DEBUG
    if (!IsSetNumber()) {
        memset(&m_Number,UnassignedByte(),sizeof(m_Number));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Number;
}
 
inline
bool CMim_reference_Base::IsSetOrigNumber(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CMim_reference_Base::CanGetOrigNumber(void) const
{
    return IsSetOrigNumber();
}
 
inline
void CMim_reference_Base::ResetOrigNumber(void)
{
    m_OrigNumber = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CMim_reference_Base::TOrigNumber CMim_reference_Base::GetOrigNumber(void) const
{
    if (!CanGetOrigNumber()) {
        ThrowUnassigned(1);
    }
    return m_OrigNumber;
}
 
inline
void CMim_reference_Base::SetOrigNumber(CMim_reference_Base::TOrigNumber value)
{
    m_OrigNumber = value;
    m_set_State[0] |= 0xc;
}
 
inline
CMim_reference_Base::TOrigNumber& CMim_reference_Base::SetOrigNumber(void)
{
#ifdef _DEBUG
    if (!IsSetOrigNumber()) {
        memset(&m_OrigNumber,UnassignedByte(),sizeof(m_OrigNumber));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_OrigNumber;
}
 
inline
bool CMim_reference_Base::IsSetType(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CMim_reference_Base::CanGetType(void) const
{
    return IsSetType();
}
 
inline
void CMim_reference_Base::ResetType(void)
{
    m_Type = (EType)(0);
    m_set_State[0] &= ~0x30;
}
 
inline
CMim_reference_Base::TType CMim_reference_Base::GetType(void) const
{
    if (!CanGetType()) {
        ThrowUnassigned(2);
    }
    return m_Type;
}
 
inline
void CMim_reference_Base::SetType(CMim_reference_Base::TType value)
{
    m_Type = value;
    m_set_State[0] |= 0x30;
}
 
inline
CMim_reference_Base::TType& CMim_reference_Base::SetType(void)
{
#ifdef _DEBUG
    if (!IsSetType()) {
        memset(&m_Type,UnassignedByte(),sizeof(m_Type));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Type;
}
 
inline
bool CMim_reference_Base::IsSetAuthors(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CMim_reference_Base::CanGetAuthors(void) const
{
    return true;
}
 
inline
const CMim_reference_Base::TAuthors& CMim_reference_Base::GetAuthors(void) const
{
    return m_Authors;
}
 
inline
CMim_reference_Base::TAuthors& CMim_reference_Base::SetAuthors(void)
{
    m_set_State[0] |= 0x40;
    return m_Authors;
}
 
inline
bool CMim_reference_Base::IsSetPrimaryAuthor(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CMim_reference_Base::CanGetPrimaryAuthor(void) const
{
    return IsSetPrimaryAuthor();
}
 
inline
const CMim_reference_Base::TPrimaryAuthor& CMim_reference_Base::GetPrimaryAuthor(void) const
{
    if (!CanGetPrimaryAuthor()) {
        ThrowUnassigned(4);
    }
    return m_PrimaryAuthor;
}
 
inline
void CMim_reference_Base::SetPrimaryAuthor(const CMim_reference_Base::TPrimaryAuthor& value)
{
    m_PrimaryAuthor = value;
    m_set_State[0] |= 0x300;
}
 
inline
void CMim_reference_Base::SetPrimaryAuthor(CMim_reference_Base::TPrimaryAuthor&& value)
{
    m_PrimaryAuthor = std::forward<CMim_reference_Base::TPrimaryAuthor>(value);
    m_set_State[0] |= 0x300;
}
 
inline
CMim_reference_Base::TPrimaryAuthor& CMim_reference_Base::SetPrimaryAuthor(void)
{
#ifdef _DEBUG
    if (!IsSetPrimaryAuthor()) {
        m_PrimaryAuthor = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100;
    return m_PrimaryAuthor;
}
 
inline
bool CMim_reference_Base::IsSetOtherAuthors(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CMim_reference_Base::CanGetOtherAuthors(void) const
{
    return IsSetOtherAuthors();
}
 
inline
const CMim_reference_Base::TOtherAuthors& CMim_reference_Base::GetOtherAuthors(void) const
{
    if (!CanGetOtherAuthors()) {
        ThrowUnassigned(5);
    }
    return m_OtherAuthors;
}
 
inline
void CMim_reference_Base::SetOtherAuthors(const CMim_reference_Base::TOtherAuthors& value)
{
    m_OtherAuthors = value;
    m_set_State[0] |= 0xc00;
}
 
inline
void CMim_reference_Base::SetOtherAuthors(CMim_reference_Base::TOtherAuthors&& value)
{
    m_OtherAuthors = std::forward<CMim_reference_Base::TOtherAuthors>(value);
    m_set_State[0] |= 0xc00;
}
 
inline
CMim_reference_Base::TOtherAuthors& CMim_reference_Base::SetOtherAuthors(void)
{
#ifdef _DEBUG
    if (!IsSetOtherAuthors()) {
        m_OtherAuthors = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400;
    return m_OtherAuthors;
}
 
inline
bool CMim_reference_Base::IsSetCitationTitle(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetCitationTitle(void) const
{
    return IsSetCitationTitle();
}
 
inline
const CMim_reference_Base::TCitationTitle& CMim_reference_Base::GetCitationTitle(void) const
{
    if (!CanGetCitationTitle()) {
        ThrowUnassigned(6);
    }
    return m_CitationTitle;
}
 
inline
void CMim_reference_Base::SetCitationTitle(const CMim_reference_Base::TCitationTitle& value)
{
    m_CitationTitle = value;
    m_set_State[0] |= 0x3000;
}
 
inline
void CMim_reference_Base::SetCitationTitle(CMim_reference_Base::TCitationTitle&& value)
{
    m_CitationTitle = std::forward<CMim_reference_Base::TCitationTitle>(value);
    m_set_State[0] |= 0x3000;
}
 
inline
CMim_reference_Base::TCitationTitle& CMim_reference_Base::SetCitationTitle(void)
{
#ifdef _DEBUG
    if (!IsSetCitationTitle()) {
        m_CitationTitle = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_CitationTitle;
}
 
inline
bool CMim_reference_Base::IsSetCitationType(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetCitationType(void) const
{
    return IsSetCitationType();
}
 
inline
void CMim_reference_Base::ResetCitationType(void)
{
    m_CitationType = 0;
    m_set_State[0] &= ~0xc000;
}
 
inline
CMim_reference_Base::TCitationType CMim_reference_Base::GetCitationType(void) const
{
    if (!CanGetCitationType()) {
        ThrowUnassigned(7);
    }
    return m_CitationType;
}
 
inline
void CMim_reference_Base::SetCitationType(CMim_reference_Base::TCitationType value)
{
    m_CitationType = value;
    m_set_State[0] |= 0xc000;
}
 
inline
CMim_reference_Base::TCitationType& CMim_reference_Base::SetCitationType(void)
{
#ifdef _DEBUG
    if (!IsSetCitationType()) {
        memset(&m_CitationType,UnassignedByte(),sizeof(m_CitationType));
    }
#endif
    m_set_State[0] |= 0x4000;
    return m_CitationType;
}
 
inline
bool CMim_reference_Base::IsSetBookTitle(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetBookTitle(void) const
{
    return IsSetBookTitle();
}
 
inline
const CMim_reference_Base::TBookTitle& CMim_reference_Base::GetBookTitle(void) const
{
    if (!CanGetBookTitle()) {
        ThrowUnassigned(8);
    }
    return m_BookTitle;
}
 
inline
void CMim_reference_Base::SetBookTitle(const CMim_reference_Base::TBookTitle& value)
{
    m_BookTitle = value;
    m_set_State[0] |= 0x30000;
}
 
inline
void CMim_reference_Base::SetBookTitle(CMim_reference_Base::TBookTitle&& value)
{
    m_BookTitle = std::forward<CMim_reference_Base::TBookTitle>(value);
    m_set_State[0] |= 0x30000;
}
 
inline
CMim_reference_Base::TBookTitle& CMim_reference_Base::SetBookTitle(void)
{
#ifdef _DEBUG
    if (!IsSetBookTitle()) {
        m_BookTitle = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_BookTitle;
}
 
inline
bool CMim_reference_Base::IsSetEditors(void) const
{
    return ((m_set_State[0] & 0xc0000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetEditors(void) const
{
    return true;
}
 
inline
const CMim_reference_Base::TEditors& CMim_reference_Base::GetEditors(void) const
{
    return m_Editors;
}
 
inline
CMim_reference_Base::TEditors& CMim_reference_Base::SetEditors(void)
{
    m_set_State[0] |= 0x40000;
    return m_Editors;
}
 
inline
bool CMim_reference_Base::IsSetVolume(void) const
{
    return ((m_set_State[0] & 0x300000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetVolume(void) const
{
    return IsSetVolume();
}
 
inline
const CMim_reference_Base::TVolume& CMim_reference_Base::GetVolume(void) const
{
    if (!CanGetVolume()) {
        ThrowUnassigned(10);
    }
    return m_Volume;
}
 
inline
void CMim_reference_Base::SetVolume(const CMim_reference_Base::TVolume& value)
{
    m_Volume = value;
    m_set_State[0] |= 0x300000;
}
 
inline
void CMim_reference_Base::SetVolume(CMim_reference_Base::TVolume&& value)
{
    m_Volume = std::forward<CMim_reference_Base::TVolume>(value);
    m_set_State[0] |= 0x300000;
}
 
inline
CMim_reference_Base::TVolume& CMim_reference_Base::SetVolume(void)
{
#ifdef _DEBUG
    if (!IsSetVolume()) {
        m_Volume = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100000;
    return m_Volume;
}
 
inline
bool CMim_reference_Base::IsSetEdition(void) const
{
    return ((m_set_State[0] & 0xc00000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetEdition(void) const
{
    return IsSetEdition();
}
 
inline
const CMim_reference_Base::TEdition& CMim_reference_Base::GetEdition(void) const
{
    if (!CanGetEdition()) {
        ThrowUnassigned(11);
    }
    return m_Edition;
}
 
inline
void CMim_reference_Base::SetEdition(const CMim_reference_Base::TEdition& value)
{
    m_Edition = value;
    m_set_State[0] |= 0xc00000;
}
 
inline
void CMim_reference_Base::SetEdition(CMim_reference_Base::TEdition&& value)
{
    m_Edition = std::forward<CMim_reference_Base::TEdition>(value);
    m_set_State[0] |= 0xc00000;
}
 
inline
CMim_reference_Base::TEdition& CMim_reference_Base::SetEdition(void)
{
#ifdef _DEBUG
    if (!IsSetEdition()) {
        m_Edition = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x400000;
    return m_Edition;
}
 
inline
bool CMim_reference_Base::IsSetJournal(void) const
{
    return ((m_set_State[0] & 0x3000000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetJournal(void) const
{
    return IsSetJournal();
}
 
inline
const CMim_reference_Base::TJournal& CMim_reference_Base::GetJournal(void) const
{
    if (!CanGetJournal()) {
        ThrowUnassigned(12);
    }
    return m_Journal;
}
 
inline
void CMim_reference_Base::SetJournal(const CMim_reference_Base::TJournal& value)
{
    m_Journal = value;
    m_set_State[0] |= 0x3000000;
}
 
inline
void CMim_reference_Base::SetJournal(CMim_reference_Base::TJournal&& value)
{
    m_Journal = std::forward<CMim_reference_Base::TJournal>(value);
    m_set_State[0] |= 0x3000000;
}
 
inline
CMim_reference_Base::TJournal& CMim_reference_Base::SetJournal(void)
{
#ifdef _DEBUG
    if (!IsSetJournal()) {
        m_Journal = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1000000;
    return m_Journal;
}
 
inline
bool CMim_reference_Base::IsSetSeries(void) const
{
    return ((m_set_State[0] & 0xc000000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetSeries(void) const
{
    return IsSetSeries();
}
 
inline
const CMim_reference_Base::TSeries& CMim_reference_Base::GetSeries(void) const
{
    if (!CanGetSeries()) {
        ThrowUnassigned(13);
    }
    return m_Series;
}
 
inline
void CMim_reference_Base::SetSeries(const CMim_reference_Base::TSeries& value)
{
    m_Series = value;
    m_set_State[0] |= 0xc000000;
}
 
inline
void CMim_reference_Base::SetSeries(CMim_reference_Base::TSeries&& value)
{
    m_Series = std::forward<CMim_reference_Base::TSeries>(value);
    m_set_State[0] |= 0xc000000;
}
 
inline
CMim_reference_Base::TSeries& CMim_reference_Base::SetSeries(void)
{
#ifdef _DEBUG
    if (!IsSetSeries()) {
        m_Series = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000000;
    return m_Series;
}
 
inline
bool CMim_reference_Base::IsSetPublisher(void) const
{
    return ((m_set_State[0] & 0x30000000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetPublisher(void) const
{
    return IsSetPublisher();
}
 
inline
const CMim_reference_Base::TPublisher& CMim_reference_Base::GetPublisher(void) const
{
    if (!CanGetPublisher()) {
        ThrowUnassigned(14);
    }
    return m_Publisher;
}
 
inline
void CMim_reference_Base::SetPublisher(const CMim_reference_Base::TPublisher& value)
{
    m_Publisher = value;
    m_set_State[0] |= 0x30000000;
}
 
inline
void CMim_reference_Base::SetPublisher(CMim_reference_Base::TPublisher&& value)
{
    m_Publisher = std::forward<CMim_reference_Base::TPublisher>(value);
    m_set_State[0] |= 0x30000000;
}
 
inline
CMim_reference_Base::TPublisher& CMim_reference_Base::SetPublisher(void)
{
#ifdef _DEBUG
    if (!IsSetPublisher()) {
        m_Publisher = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10000000;
    return m_Publisher;
}
 
inline
bool CMim_reference_Base::IsSetPlace(void) const
{
    return ((m_set_State[0] & 0xc0000000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetPlace(void) const
{
    return IsSetPlace();
}
 
inline
const CMim_reference_Base::TPlace& CMim_reference_Base::GetPlace(void) const
{
    if (!CanGetPlace()) {
        ThrowUnassigned(15);
    }
    return m_Place;
}
 
inline
void CMim_reference_Base::SetPlace(const CMim_reference_Base::TPlace& value)
{
    m_Place = value;
    m_set_State[0] |= 0xc0000000;
}
 
inline
void CMim_reference_Base::SetPlace(CMim_reference_Base::TPlace&& value)
{
    m_Place = std::forward<CMim_reference_Base::TPlace>(value);
    m_set_State[0] |= 0xc0000000;
}
 
inline
CMim_reference_Base::TPlace& CMim_reference_Base::SetPlace(void)
{
#ifdef _DEBUG
    if (!IsSetPlace()) {
        m_Place = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40000000;
    return m_Place;
}
 
inline
bool CMim_reference_Base::IsSetCommNote(void) const
{
    return ((m_set_State[1] & 0x3) != 0);
}
 
inline
bool CMim_reference_Base::CanGetCommNote(void) const
{
    return IsSetCommNote();
}
 
inline
const CMim_reference_Base::TCommNote& CMim_reference_Base::GetCommNote(void) const
{
    if (!CanGetCommNote()) {
        ThrowUnassigned(16);
    }
    return m_CommNote;
}
 
inline
void CMim_reference_Base::SetCommNote(const CMim_reference_Base::TCommNote& value)
{
    m_CommNote = value;
    m_set_State[1] |= 0x3;
}
 
inline
void CMim_reference_Base::SetCommNote(CMim_reference_Base::TCommNote&& value)
{
    m_CommNote = std::forward<CMim_reference_Base::TCommNote>(value);
    m_set_State[1] |= 0x3;
}
 
inline
CMim_reference_Base::TCommNote& CMim_reference_Base::SetCommNote(void)
{
#ifdef _DEBUG
    if (!IsSetCommNote()) {
        m_CommNote = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x1;
    return m_CommNote;
}
 
inline
bool CMim_reference_Base::IsSetPubDate(void) const
{
    return m_PubDate.NotEmpty();
}
 
inline
bool CMim_reference_Base::CanGetPubDate(void) const
{
    return true;
}
 
inline
const CMim_reference_Base::TPubDate& CMim_reference_Base::GetPubDate(void) const
{
    if ( !m_PubDate ) {
        const_cast<CMim_reference_Base*>(this)->ResetPubDate();
    }
    return (*m_PubDate);
}
 
inline
CMim_reference_Base::TPubDate& CMim_reference_Base::SetPubDate(void)
{
    if ( !m_PubDate ) {
        ResetPubDate();
    }
    return (*m_PubDate);
}
 
inline
bool CMim_reference_Base::IsSetPages(void) const
{
    return ((m_set_State[1] & 0x30) != 0);
}
 
inline
bool CMim_reference_Base::CanGetPages(void) const
{
    return true;
}
 
inline
const CMim_reference_Base::TPages& CMim_reference_Base::GetPages(void) const
{
    return m_Pages;
}
 
inline
CMim_reference_Base::TPages& CMim_reference_Base::SetPages(void)
{
    m_set_State[1] |= 0x10;
    return m_Pages;
}
 
inline
bool CMim_reference_Base::IsSetMiscInfo(void) const
{
    return ((m_set_State[1] & 0xc0) != 0);
}
 
inline
bool CMim_reference_Base::CanGetMiscInfo(void) const
{
    return IsSetMiscInfo();
}
 
inline
const CMim_reference_Base::TMiscInfo& CMim_reference_Base::GetMiscInfo(void) const
{
    if (!CanGetMiscInfo()) {
        ThrowUnassigned(19);
    }
    return m_MiscInfo;
}
 
inline
void CMim_reference_Base::SetMiscInfo(const CMim_reference_Base::TMiscInfo& value)
{
    m_MiscInfo = value;
    m_set_State[1] |= 0xc0;
}
 
inline
void CMim_reference_Base::SetMiscInfo(CMim_reference_Base::TMiscInfo&& value)
{
    m_MiscInfo = std::forward<CMim_reference_Base::TMiscInfo>(value);
    m_set_State[1] |= 0xc0;
}
 
inline
CMim_reference_Base::TMiscInfo& CMim_reference_Base::SetMiscInfo(void)
{
#ifdef _DEBUG
    if (!IsSetMiscInfo()) {
        m_MiscInfo = UnassignedString();
    }
#endif
    m_set_State[1] |= 0x40;
    return m_MiscInfo;
}
 
inline
bool CMim_reference_Base::IsSetPubmedUID(void) const
{
    return ((m_set_State[1] & 0x300) != 0);
}
 
inline
bool CMim_reference_Base::CanGetPubmedUID(void) const
{
    return IsSetPubmedUID();
}
 
inline
void CMim_reference_Base::ResetPubmedUID(void)
{
    m_PubmedUID = 0;
    m_set_State[1] &= ~0x300;
}
 
inline
CMim_reference_Base::TPubmedUID CMim_reference_Base::GetPubmedUID(void) const
{
    if (!CanGetPubmedUID()) {
        ThrowUnassigned(20);
    }
    return m_PubmedUID;
}
 
inline
void CMim_reference_Base::SetPubmedUID(CMim_reference_Base::TPubmedUID value)
{
    m_PubmedUID = value;
    m_set_State[1] |= 0x300;
}
 
inline
CMim_reference_Base::TPubmedUID& CMim_reference_Base::SetPubmedUID(void)
{
#ifdef _DEBUG
    if (!IsSetPubmedUID()) {
        memset(&m_PubmedUID,UnassignedByte(),sizeof(m_PubmedUID));
    }
#endif
    m_set_State[1] |= 0x100;
    return m_PubmedUID;
}
 
inline
bool CMim_reference_Base::IsSetAmbiguous(void) const
{
    return ((m_set_State[1] & 0xc00) != 0);
}
 
inline
bool CMim_reference_Base::CanGetAmbiguous(void) const
{
    return IsSetAmbiguous();
}
 
inline
void CMim_reference_Base::ResetAmbiguous(void)
{
    m_Ambiguous = 0;
    m_set_State[1] &= ~0xc00;
}
 
inline
CMim_reference_Base::TAmbiguous CMim_reference_Base::GetAmbiguous(void) const
{
    if (!CanGetAmbiguous()) {
        ThrowUnassigned(21);
    }
    return m_Ambiguous;
}
 
inline
void CMim_reference_Base::SetAmbiguous(CMim_reference_Base::TAmbiguous value)
{
    m_Ambiguous = value;
    m_set_State[1] |= 0xc00;
}
 
inline
CMim_reference_Base::TAmbiguous& CMim_reference_Base::SetAmbiguous(void)
{
#ifdef _DEBUG
    if (!IsSetAmbiguous()) {
        memset(&m_Ambiguous,UnassignedByte(),sizeof(m_Ambiguous));
    }
#endif
    m_set_State[1] |= 0x400;
    return m_Ambiguous;
}
 
inline
bool CMim_reference_Base::IsSetNoLink(void) const
{
    return ((m_set_State[1] & 0x3000) != 0);
}
 
inline
bool CMim_reference_Base::CanGetNoLink(void) const
{
    return IsSetNoLink();
}
 
inline
void CMim_reference_Base::ResetNoLink(void)
{
    m_NoLink = 0;
    m_set_State[1] &= ~0x3000;
}
 
inline
CMim_reference_Base::TNoLink CMim_reference_Base::GetNoLink(void) const
{
    if (!CanGetNoLink()) {
        ThrowUnassigned(22);
    }
    return m_NoLink;
}
 
inline
void CMim_reference_Base::SetNoLink(CMim_reference_Base::TNoLink value)
{
    m_NoLink = value;
    m_set_State[1] |= 0x3000;
}
 
inline
CMim_reference_Base::TNoLink& CMim_reference_Base::SetNoLink(void)
{
#ifdef _DEBUG
    if (!IsSetNoLink()) {
        memset(&m_NoLink,UnassignedByte(),sizeof(m_NoLink));
    }
#endif
    m_set_State[1] |= 0x1000;
    return m_NoLink;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_MIM_MIM_REFERENCE_BASE_HPP