Rs_.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 Rs_.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/docsum/docsum.asn">docsum.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/docsum/docsum.def">docsum.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_DOCSUM_RS_BASE_HPP
#define OBJECTS_DOCSUM_RS_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 CAssembly;
class CPrimarySequence;
class CRsLinkout;
class CRsStruct;
class CSs;
 
 
// generated classes
 
 
/** @addtogroup dataspec_Docsum_3_4
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///defines the docsum structure for refSNP clusters, where a refSNP
///             cluster (rs) is a grouping of individual dbSNP submissions that all refer to the
///             same variation. The refsnp provides a single unified record for annotation of NCBI
///             resources such as reference genome sequence.
///
/// CRs_Base --
///
 
class NCBI_DOCSUM_EXPORT CRs_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CRs_Base(void);
    // destructor
    virtual ~CRs_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Attlist --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Attlist(void);
        // destructor
        ~C_Attlist(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        enum EAttlist_snpClass {
            eAttlist_snpClass_snp                          = 1,
            eAttlist_snpClass_in_del                       = 2,
            eAttlist_snpClass_heterozygous                 = 3,
            eAttlist_snpClass_microsatellite               = 4,
            eAttlist_snpClass_named_locus                  = 5,
            eAttlist_snpClass_no_variation                 = 6,
            eAttlist_snpClass_mixed                        = 7,
            eAttlist_snpClass_multinucleotide_polymorphism = 8
        };
        
        /// Access to EAttlist_snpClass's attributes (values, names) as defined in spec
        static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_snpClass)(void);
        
        enum EAttlist_snpType {
            eAttlist_snpType_notwithdrawn         = 1,
            eAttlist_snpType_artifact             = 2,
            eAttlist_snpType_gene_duplication     = 3,
            eAttlist_snpType_duplicate_submission = 4,
            eAttlist_snpType_notspecified         = 5,
            eAttlist_snpType_ambiguous_location   = 6,
            eAttlist_snpType_low_map_quality      = 7
        };
        
        /// Access to EAttlist_snpType's attributes (values, names) as defined in spec
        static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_snpType)(void);
        
        enum EAttlist_molType {
            eAttlist_molType_genomic = 1,
            eAttlist_molType_cDNA    = 2,
            eAttlist_molType_mito    = 3,
            eAttlist_molType_chloro  = 4,
            eAttlist_molType_unknown = 5
        };
        
        /// Access to EAttlist_molType's attributes (values, names) as defined in spec
        static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_molType)(void);
        
        // types
        typedef int TRsId;
        typedef EAttlist_snpClass TSnpClass;
        typedef EAttlist_snpType TSnpType;
        typedef EAttlist_molType TMolType;
        typedef int TValidProbMin;
        typedef int TValidProbMax;
        typedef bool TGenotype;
        typedef string TBitField;
        typedef int TTaxId;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_rsId,
            e_snpClass,
            e_snpType,
            e_molType,
            e_validProbMin,
            e_validProbMax,
            e_genotype,
            e_bitField,
            e_taxId
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 10> TmemberIndex;
    
        // getters
        // setters
    
        ///refSNP (rs) number
        /// Check if a value has been assigned to RsId data member.
        ///
        /// Data member RsId is mandatory;
        /// its type is defined as 'typedef int TRsId'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetRsId(void) const;
    
        /// Check if it is safe to call GetRsId method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetRsId(void) const;
    
        /// Reset RsId data member.
        void ResetRsId(void);
    
        /// Get the RsId member data.
        ///
        /// @return
        ///   Copy of the member data.
        TRsId GetRsId(void) const;
    
        /// Assign a value to RsId data member.
        ///
        /// @param value
        ///   Value to assign
        void SetRsId(TRsId value);
    
        /// Assign a value to RsId data member.
        ///
        /// @return
        ///   Reference to the data value.
        TRsId& SetRsId(void);
    
        /// Check if a value has been assigned to SnpClass data member.
        ///
        /// Data member SnpClass is mandatory;
        /// its type is defined as 'typedef EAttlist_snpClass TSnpClass'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSnpClass(void) const;
    
        /// Check if it is safe to call GetSnpClass method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSnpClass(void) const;
    
        /// Reset SnpClass data member.
        void ResetSnpClass(void);
    
        /// Get the SnpClass member data.
        ///
        /// @return
        ///   Copy of the member data.
        TSnpClass GetSnpClass(void) const;
    
        /// Assign a value to SnpClass data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSnpClass(TSnpClass value);
    
        /// Assign a value to SnpClass data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSnpClass& SetSnpClass(void);
    
        /// Check if a value has been assigned to SnpType data member.
        ///
        /// Data member SnpType is mandatory;
        /// its type is defined as 'typedef EAttlist_snpType TSnpType'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSnpType(void) const;
    
        /// Check if it is safe to call GetSnpType method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSnpType(void) const;
    
        /// Reset SnpType data member.
        void ResetSnpType(void);
    
        /// Get the SnpType member data.
        ///
        /// @return
        ///   Copy of the member data.
        TSnpType GetSnpType(void) const;
    
        /// Assign a value to SnpType data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSnpType(TSnpType value);
    
        /// Assign a value to SnpType data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSnpType& SetSnpType(void);
    
        /// Check if a value has been assigned to MolType data member.
        ///
        /// Data member MolType is mandatory;
        /// its type is defined as 'typedef EAttlist_molType TMolType'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetMolType(void) const;
    
        /// Check if it is safe to call GetMolType method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetMolType(void) const;
    
        /// Reset MolType data member.
        void ResetMolType(void);
    
        /// Get the MolType member data.
        ///
        /// @return
        ///   Copy of the member data.
        TMolType GetMolType(void) const;
    
        /// Assign a value to MolType data member.
        ///
        /// @param value
        ///   Value to assign
        void SetMolType(TMolType value);
    
        /// Assign a value to MolType data member.
        ///
        /// @return
        ///   Reference to the data value.
        TMolType& SetMolType(void);
    
        ///minimum reported success rate of all submissions in
        ///                     cluster
        /// Check if a value has been assigned to ValidProbMin data member.
        ///
        /// Data member ValidProbMin is optional;
        /// its type is defined as 'typedef int TValidProbMin'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetValidProbMin(void) const;
    
        /// Check if it is safe to call GetValidProbMin method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetValidProbMin(void) const;
    
        /// Reset ValidProbMin data member.
        void ResetValidProbMin(void);
    
        /// Get the ValidProbMin member data.
        ///
        /// @return
        ///   Copy of the member data.
        TValidProbMin GetValidProbMin(void) const;
    
        /// Assign a value to ValidProbMin data member.
        ///
        /// @param value
        ///   Value to assign
        void SetValidProbMin(TValidProbMin value);
    
        /// Assign a value to ValidProbMin data member.
        ///
        /// @return
        ///   Reference to the data value.
        TValidProbMin& SetValidProbMin(void);
    
        ///maximum reported success rate of all submissions in
        ///                     cluster
        /// Check if a value has been assigned to ValidProbMax data member.
        ///
        /// Data member ValidProbMax is optional;
        /// its type is defined as 'typedef int TValidProbMax'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetValidProbMax(void) const;
    
        /// Check if it is safe to call GetValidProbMax method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetValidProbMax(void) const;
    
        /// Reset ValidProbMax data member.
        void ResetValidProbMax(void);
    
        /// Get the ValidProbMax member data.
        ///
        /// @return
        ///   Copy of the member data.
        TValidProbMax GetValidProbMax(void) const;
    
        /// Assign a value to ValidProbMax data member.
        ///
        /// @param value
        ///   Value to assign
        void SetValidProbMax(TValidProbMax value);
    
        /// Assign a value to ValidProbMax data member.
        ///
        /// @return
        ///   Reference to the data value.
        TValidProbMax& SetValidProbMax(void);
    
        ///at least one genotype reported for this
        ///                     refSNP
        /// Check if a value has been assigned to Genotype data member.
        ///
        /// Data member Genotype is optional;
        /// its type is defined as 'typedef bool TGenotype'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetGenotype(void) const;
    
        /// Check if it is safe to call GetGenotype method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetGenotype(void) const;
    
        /// Reset Genotype data member.
        void ResetGenotype(void);
    
        /// Get the Genotype member data.
        ///
        /// @return
        ///   Copy of the member data.
        TGenotype GetGenotype(void) const;
    
        /// Assign a value to Genotype data member.
        ///
        /// @param value
        ///   Value to assign
        void SetGenotype(TGenotype value);
    
        /// Assign a value to Genotype data member.
        ///
        /// @return
        ///   Reference to the data value.
        TGenotype& SetGenotype(void);
    
        /// Check if a value has been assigned to BitField data member.
        ///
        /// Data member BitField is optional;
        /// its type is defined as 'typedef string TBitField'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetBitField(void) const;
    
        /// Check if it is safe to call GetBitField method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetBitField(void) const;
    
        /// Reset BitField data member.
        void ResetBitField(void);
    
        /// Get the BitField member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TBitField& GetBitField(void) const;
    
        /// Assign a value to BitField data member.
        ///
        /// @param value
        ///   Value to assign
        void SetBitField(const TBitField& value);
        void SetBitField(TBitField&& value);
    
        /// Assign a value to BitField data member.
        ///
        /// @return
        ///   Reference to the data value.
        TBitField& SetBitField(void);
    
        /// Check if a value has been assigned to TaxId data member.
        ///
        /// Data member TaxId is optional;
        /// its type is defined as 'typedef int TTaxId'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTaxId(void) const;
    
        /// Check if it is safe to call GetTaxId method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTaxId(void) const;
    
        /// Reset TaxId data member.
        void ResetTaxId(void);
    
        /// Get the TaxId member data.
        ///
        /// @return
        ///   Copy of the member data.
        TTaxId GetTaxId(void) const;
    
        /// Assign a value to TaxId data member.
        ///
        /// @param value
        ///   Value to assign
        void SetTaxId(TTaxId value);
    
        /// Assign a value to TaxId data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTaxId& SetTaxId(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Attlist(const C_Attlist&);
        C_Attlist& operator=(const C_Attlist&);
    
        // data
        Uint4 m_set_State[1];
        int m_RsId;
        EAttlist_snpClass m_SnpClass;
        EAttlist_snpType m_SnpType;
        EAttlist_molType m_MolType;
        int m_ValidProbMin;
        int m_ValidProbMax;
        bool m_Genotype;
        string m_BitField;
        int m_TaxId;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Het --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Het : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Het(void);
        // destructor
        ~C_Het(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            ///Est=Estimated average het from allele
            ///                                 frequencies, Obs=Observed from genotype data
            enum EHet_attlist_type {
                eHet_attlist_type_est = 1,
                eHet_attlist_type_obs = 2
            };
            
            /// Access to EHet_attlist_type's attributes (values, names) as defined in spec
            static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EHet_attlist_type)(void);
            
            // types
            typedef EHet_attlist_type TType;
            typedef double TValue;
            typedef double TStdError;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_type,
                e_value,
                e_stdError
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 4> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Type data member.
            ///
            /// Data member Type is mandatory;
            /// its type is defined as 'typedef EHet_attlist_type 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);
        
            ///Heterozygosity
            /// Check if a value has been assigned to Value data member.
            ///
            /// Data member Value is mandatory;
            /// its type is defined as 'typedef double TValue'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetValue(void) const;
        
            /// Check if it is safe to call GetValue method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetValue(void) const;
        
            /// Reset Value data member.
            void ResetValue(void);
        
            /// Get the Value member data.
            ///
            /// @return
            ///   Copy of the member data.
            TValue GetValue(void) const;
        
            /// Assign a value to Value data member.
            ///
            /// @param value
            ///   Value to assign
            void SetValue(TValue value);
        
            /// Assign a value to Value data member.
            ///
            /// @return
            ///   Reference to the data value.
            TValue& SetValue(void);
        
            ///Standard error of Het
            ///                                 estimate
            /// Check if a value has been assigned to StdError data member.
            ///
            /// Data member StdError is optional;
            /// its type is defined as 'typedef double TStdError'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetStdError(void) const;
        
            /// Check if it is safe to call GetStdError method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetStdError(void) const;
        
            /// Reset StdError data member.
            void ResetStdError(void);
        
            /// Get the StdError member data.
            ///
            /// @return
            ///   Copy of the member data.
            TStdError GetStdError(void) const;
        
            /// Assign a value to StdError data member.
            ///
            /// @param value
            ///   Value to assign
            void SetStdError(TStdError value);
        
            /// Assign a value to StdError data member.
            ///
            /// @return
            ///   Reference to the data value.
            TStdError& SetStdError(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            EHet_attlist_type m_Type;
            double m_Value;
            double m_StdError;
        };
        // types
        typedef C_Attlist TAttlist;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_het
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        /// Check if a value has been assigned to Het data member.
        ///
        /// Data member Het is mandatory
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetHet(void) const;
    
        /// Check if value of Het member is getatable.
        ///
        /// @return
        ///   - false; the data member of type 'NULL' has no value.
        bool CanGetHet(void) const;
    
        /// Reset Het data member.
        void ResetHet(void);
    
        /// Set NULL data member (assign 'NULL' value to Het data member).
        void SetHet(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Het(const C_Het&);
        C_Het& operator=(const C_Het&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Validation --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Validation : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Validation(void);
        // destructor
        ~C_Validation(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef bool TByCluster;
            typedef bool TByFrequency;
            typedef bool TByOtherPop;
            typedef bool TBy2Hit2Allele;
            typedef bool TByHapMap;
            typedef bool TBy1000G;
            typedef bool TSuspect;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_byCluster,
                e_byFrequency,
                e_byOtherPop,
                e_by2Hit2Allele,
                e_byHapMap,
                e_by1000G,
                e_suspect
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 8> TmemberIndex;
        
            // getters
            // setters
        
            ///at least one subsnp in cluster has frequency data
            ///                                 submitted
            /// Check if a value has been assigned to ByCluster data member.
            ///
            /// Data member ByCluster is optional;
            /// its type is defined as 'typedef bool TByCluster'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetByCluster(void) const;
        
            /// Check if it is safe to call GetByCluster method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetByCluster(void) const;
        
            /// Reset ByCluster data member.
            void ResetByCluster(void);
        
            /// Get the ByCluster member data.
            ///
            /// @return
            ///   Copy of the member data.
            TByCluster GetByCluster(void) const;
        
            /// Assign a value to ByCluster data member.
            ///
            /// @param value
            ///   Value to assign
            void SetByCluster(TByCluster value);
        
            /// Assign a value to ByCluster data member.
            ///
            /// @return
            ///   Reference to the data value.
            TByCluster& SetByCluster(void);
        
            ///Validated by allele frequency
            /// Check if a value has been assigned to ByFrequency data member.
            ///
            /// Data member ByFrequency is optional;
            /// its type is defined as 'typedef bool TByFrequency'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetByFrequency(void) const;
        
            /// Check if it is safe to call GetByFrequency method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetByFrequency(void) const;
        
            /// Reset ByFrequency data member.
            void ResetByFrequency(void);
        
            /// Get the ByFrequency member data.
            ///
            /// @return
            ///   Copy of the member data.
            TByFrequency GetByFrequency(void) const;
        
            /// Assign a value to ByFrequency data member.
            ///
            /// @param value
            ///   Value to assign
            void SetByFrequency(TByFrequency value);
        
            /// Assign a value to ByFrequency data member.
            ///
            /// @return
            ///   Reference to the data value.
            TByFrequency& SetByFrequency(void);
        
            /// Check if a value has been assigned to ByOtherPop data member.
            ///
            /// Data member ByOtherPop is optional;
            /// its type is defined as 'typedef bool TByOtherPop'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetByOtherPop(void) const;
        
            /// Check if it is safe to call GetByOtherPop method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetByOtherPop(void) const;
        
            /// Reset ByOtherPop data member.
            void ResetByOtherPop(void);
        
            /// Get the ByOtherPop member data.
            ///
            /// @return
            ///   Copy of the member data.
            TByOtherPop GetByOtherPop(void) const;
        
            /// Assign a value to ByOtherPop data member.
            ///
            /// @param value
            ///   Value to assign
            void SetByOtherPop(TByOtherPop value);
        
            /// Assign a value to ByOtherPop data member.
            ///
            /// @return
            ///   Reference to the data value.
            TByOtherPop& SetByOtherPop(void);
        
            ///cluster has 2+ submissions, with 1+ submissions
            ///                                 assayed with a non-computational method
            /// Check if a value has been assigned to By2Hit2Allele data member.
            ///
            /// Data member By2Hit2Allele is optional;
            /// its type is defined as 'typedef bool TBy2Hit2Allele'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetBy2Hit2Allele(void) const;
        
            /// Check if it is safe to call GetBy2Hit2Allele method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetBy2Hit2Allele(void) const;
        
            /// Reset By2Hit2Allele data member.
            void ResetBy2Hit2Allele(void);
        
            /// Get the By2Hit2Allele member data.
            ///
            /// @return
            ///   Copy of the member data.
            TBy2Hit2Allele GetBy2Hit2Allele(void) const;
        
            /// Assign a value to By2Hit2Allele data member.
            ///
            /// @param value
            ///   Value to assign
            void SetBy2Hit2Allele(TBy2Hit2Allele value);
        
            /// Assign a value to By2Hit2Allele data member.
            ///
            /// @return
            ///   Reference to the data value.
            TBy2Hit2Allele& SetBy2Hit2Allele(void);
        
            ///Validated by HapMap Project 
            /// Check if a value has been assigned to ByHapMap data member.
            ///
            /// Data member ByHapMap is optional;
            /// its type is defined as 'typedef bool TByHapMap'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetByHapMap(void) const;
        
            /// Check if it is safe to call GetByHapMap method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetByHapMap(void) const;
        
            /// Reset ByHapMap data member.
            void ResetByHapMap(void);
        
            /// Get the ByHapMap member data.
            ///
            /// @return
            ///   Copy of the member data.
            TByHapMap GetByHapMap(void) const;
        
            /// Assign a value to ByHapMap data member.
            ///
            /// @param value
            ///   Value to assign
            void SetByHapMap(TByHapMap value);
        
            /// Assign a value to ByHapMap data member.
            ///
            /// @return
            ///   Reference to the data value.
            TByHapMap& SetByHapMap(void);
        
            ///Validated by 1000 Genomes Project
            /// Check if a value has been assigned to By1000G data member.
            ///
            /// Data member By1000G is optional;
            /// its type is defined as 'typedef bool TBy1000G'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetBy1000G(void) const;
        
            /// Check if it is safe to call GetBy1000G method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetBy1000G(void) const;
        
            /// Reset By1000G data member.
            void ResetBy1000G(void);
        
            /// Get the By1000G member data.
            ///
            /// @return
            ///   Copy of the member data.
            TBy1000G GetBy1000G(void) const;
        
            /// Assign a value to By1000G data member.
            ///
            /// @param value
            ///   Value to assign
            void SetBy1000G(TBy1000G value);
        
            /// Assign a value to By1000G data member.
            ///
            /// @return
            ///   Reference to the data value.
            TBy1000G& SetBy1000G(void);
        
            ///Suspected to be false SNP
            /// Check if a value has been assigned to Suspect data member.
            ///
            /// Data member Suspect is optional;
            /// its type is defined as 'typedef bool TSuspect'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetSuspect(void) const;
        
            /// Check if it is safe to call GetSuspect method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetSuspect(void) const;
        
            /// Reset Suspect data member.
            void ResetSuspect(void);
        
            /// Get the Suspect member data.
            ///
            /// @return
            ///   Copy of the member data.
            TSuspect GetSuspect(void) const;
        
            /// Assign a value to Suspect data member.
            ///
            /// @param value
            ///   Value to assign
            void SetSuspect(TSuspect value);
        
            /// Assign a value to Suspect data member.
            ///
            /// @return
            ///   Reference to the data value.
            TSuspect& SetSuspect(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            bool m_ByCluster;
            bool m_ByFrequency;
            bool m_ByOtherPop;
            bool m_By2Hit2Allele;
            bool m_ByHapMap;
            bool m_By1000G;
            bool m_Suspect;
        };
        // types
        typedef C_Attlist TAttlist;
        typedef list< int > TOtherPopBatchId;
        typedef list< int > TTwoHit2AlleleBatchId;
        typedef list< int > TFrequencyClass;
        typedef list< int > THapMapPhase;
        typedef list< int > TTGPPhase;
        typedef list< string > TSuspectEvidence;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_otherPopBatchId,
            e_twoHit2AlleleBatchId,
            e_frequencyClass,
            e_hapMapPhase,
            e_tGPPhase,
            e_suspectEvidence
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 8> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        ///dbSNP batch-id's for other pop snp validation
        ///                                     data.
        /// Check if a value has been assigned to OtherPopBatchId data member.
        ///
        /// Data member OtherPopBatchId is optional;
        /// its type is defined as 'typedef list< int > TOtherPopBatchId'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOtherPopBatchId(void) const;
    
        /// Check if it is safe to call GetOtherPopBatchId method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOtherPopBatchId(void) const;
    
        /// Reset OtherPopBatchId data member.
        void ResetOtherPopBatchId(void);
    
        /// Get the OtherPopBatchId member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TOtherPopBatchId& GetOtherPopBatchId(void) const;
    
        /// Assign a value to OtherPopBatchId data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOtherPopBatchId& SetOtherPopBatchId(void);
    
        ///dbSNP batch-id's for double-hit snp
        ///                                     validation data. Use batch-id to get methods, etc.
        /// Check if a value has been assigned to TwoHit2AlleleBatchId data member.
        ///
        /// Data member TwoHit2AlleleBatchId is optional;
        /// its type is defined as 'typedef list< int > TTwoHit2AlleleBatchId'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTwoHit2AlleleBatchId(void) const;
    
        /// Check if it is safe to call GetTwoHit2AlleleBatchId method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTwoHit2AlleleBatchId(void) const;
    
        /// Reset TwoHit2AlleleBatchId data member.
        void ResetTwoHit2AlleleBatchId(void);
    
        /// Get the TwoHit2AlleleBatchId member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTwoHit2AlleleBatchId& GetTwoHit2AlleleBatchId(void) const;
    
        /// Assign a value to TwoHit2AlleleBatchId data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTwoHit2AlleleBatchId& SetTwoHit2AlleleBatchId(void);
    
        ///Frequency validation class (1) low frequency
        ///                                     variation that is cited in journal and other reputable
        ///                                     sources (2) greater than 5 percent minor allele freq in each
        ///                                     and all populations (4) greater than 5 percent minor allele
        ///                                     freq in 1+ populations (8) if the variant has 2+ minor
        ///                                     allele count based on freq or genotype data (16) less than 1
        ///                                     percent minor allele freq in each and all populations (32)
        ///                                     less than 1 percent minor freq in 1+ populations
        /// Check if a value has been assigned to FrequencyClass data member.
        ///
        /// Data member FrequencyClass is optional;
        /// its type is defined as 'typedef list< int > TFrequencyClass'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetFrequencyClass(void) const;
    
        /// Check if it is safe to call GetFrequencyClass method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetFrequencyClass(void) const;
    
        /// Reset FrequencyClass data member.
        void ResetFrequencyClass(void);
    
        /// Get the FrequencyClass member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TFrequencyClass& GetFrequencyClass(void) const;
    
        /// Assign a value to FrequencyClass data member.
        ///
        /// @return
        ///   Reference to the data value.
        TFrequencyClass& SetFrequencyClass(void);
    
        ///alidated by HapMap Project phase1-genotyped
        ///                                     (1), Phase 1 genotyped; filtered, non-redundant
        ///                                     phase2-genotyped (2), Phase 2 genotyped; filtered,
        ///                                     non-redundant phase3-genotyped (4) Phase 3 genotyped;
        ///                                     filtered, non-redundant 
        /// Check if a value has been assigned to HapMapPhase data member.
        ///
        /// Data member HapMapPhase is optional;
        /// its type is defined as 'typedef list< int > THapMapPhase'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetHapMapPhase(void) const;
    
        /// Check if it is safe to call GetHapMapPhase method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetHapMapPhase(void) const;
    
        /// Reset HapMapPhase data member.
        void ResetHapMapPhase(void);
    
        /// Get the HapMapPhase member data.
        ///
        /// @return
        ///   Reference to the member data.
        const THapMapPhase& GetHapMapPhase(void) const;
    
        /// Assign a value to HapMapPhase data member.
        ///
        /// @return
        ///   Reference to the data value.
        THapMapPhase& SetHapMapPhase(void);
    
        ///Validated by 1000 Genomes Project (TGP) pilot
        ///                                     1 (1), pilot 2 (2), pilot 3 (4) 
        /// Check if a value has been assigned to TGPPhase data member.
        ///
        /// Data member TGPPhase is optional;
        /// its type is defined as 'typedef list< int > TTGPPhase'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetTGPPhase(void) const;
    
        /// Check if it is safe to call GetTGPPhase method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetTGPPhase(void) const;
    
        /// Reset TGPPhase data member.
        void ResetTGPPhase(void);
    
        /// Get the TGPPhase member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TTGPPhase& GetTGPPhase(void) const;
    
        /// Assign a value to TGPPhase data member.
        ///
        /// @return
        ///   Reference to the data value.
        TTGPPhase& SetTGPPhase(void);
    
        ///Suspected to be false SNP evidence Single
        ///                                     Nucleotide Difference - paralogous genes (1), Genotype or
        ///                                     base calling errors (2), Submission evidence or errors (4),
        ///                                     Others (8) 
        /// Check if a value has been assigned to SuspectEvidence data member.
        ///
        /// Data member SuspectEvidence is optional;
        /// its type is defined as 'typedef list< string > TSuspectEvidence'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSuspectEvidence(void) const;
    
        /// Check if it is safe to call GetSuspectEvidence method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSuspectEvidence(void) const;
    
        /// Reset SuspectEvidence data member.
        void ResetSuspectEvidence(void);
    
        /// Get the SuspectEvidence member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSuspectEvidence& GetSuspectEvidence(void) const;
    
        /// Assign a value to SuspectEvidence data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSuspectEvidence& SetSuspectEvidence(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Validation(const C_Validation&);
        C_Validation& operator=(const C_Validation&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
        list< int > m_OtherPopBatchId;
        list< int > m_TwoHit2AlleleBatchId;
        list< int > m_FrequencyClass;
        list< int > m_HapMapPhase;
        list< int > m_TGPPhase;
        list< string > m_SuspectEvidence;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///date the refsnp cluster was
    ///                         instantiated
    ///date the refsnp cluster was
    ///                         instantiated
    ///
    /// C_Create --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Create : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Create(void);
        // destructor
        ~C_Create(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef int TBuild;
            typedef string TDate;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_build,
                e_date
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
        
            // getters
            // setters
        
            ///build number when the cluster was
            ///                                 created
            /// Check if a value has been assigned to Build data member.
            ///
            /// Data member Build is optional;
            /// its type is defined as 'typedef int TBuild'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetBuild(void) const;
        
            /// Check if it is safe to call GetBuild method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetBuild(void) const;
        
            /// Reset Build data member.
            void ResetBuild(void);
        
            /// Get the Build member data.
            ///
            /// @return
            ///   Copy of the member data.
            TBuild GetBuild(void) const;
        
            /// Assign a value to Build data member.
            ///
            /// @param value
            ///   Value to assign
            void SetBuild(TBuild value);
        
            /// Assign a value to Build data member.
            ///
            /// @return
            ///   Reference to the data value.
            TBuild& SetBuild(void);
        
            ///yyyy-mm-dd
            /// Check if a value has been assigned to Date data member.
            ///
            /// Data member Date is optional;
            /// its type is defined as 'typedef string TDate'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetDate(void) const;
        
            /// Check if it is safe to call GetDate method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetDate(void) const;
        
            /// Reset Date data member.
            void ResetDate(void);
        
            /// Get the Date member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TDate& GetDate(void) const;
        
            /// Assign a value to Date data member.
            ///
            /// @param value
            ///   Value to assign
            void SetDate(const TDate& value);
            void SetDate(TDate&& value);
        
            /// Assign a value to Date data member.
            ///
            /// @return
            ///   Reference to the data value.
            TDate& SetDate(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            int m_Build;
            string m_Date;
        };
        // types
        typedef C_Attlist TAttlist;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_create
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        ///date the refsnp cluster was
        ///                         instantiated
        /// Check if a value has been assigned to Create data member.
        ///
        /// Data member Create is mandatory
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetCreate(void) const;
    
        /// Check if value of Create member is getatable.
        ///
        /// @return
        ///   - false; the data member of type 'NULL' has no value.
        bool CanGetCreate(void) const;
    
        /// Reset Create data member.
        void ResetCreate(void);
    
        /// Set NULL data member (assign 'NULL' value to Create data member).
        void SetCreate(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Create(const C_Create&);
        C_Create& operator=(const C_Create&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///most recent date the cluster was updated (member added or
    ///                         deleted)
    ///most recent date the cluster was updated (member added or
    ///                         deleted)
    ///
    /// C_Update --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Update : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Update(void);
        // destructor
        ~C_Update(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef int TBuild;
            typedef string TDate;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_build,
                e_date
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
        
            // getters
            // setters
        
            ///build number when the cluster was
            ///                                 updated
            /// Check if a value has been assigned to Build data member.
            ///
            /// Data member Build is optional;
            /// its type is defined as 'typedef int TBuild'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetBuild(void) const;
        
            /// Check if it is safe to call GetBuild method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetBuild(void) const;
        
            /// Reset Build data member.
            void ResetBuild(void);
        
            /// Get the Build member data.
            ///
            /// @return
            ///   Copy of the member data.
            TBuild GetBuild(void) const;
        
            /// Assign a value to Build data member.
            ///
            /// @param value
            ///   Value to assign
            void SetBuild(TBuild value);
        
            /// Assign a value to Build data member.
            ///
            /// @return
            ///   Reference to the data value.
            TBuild& SetBuild(void);
        
            ///yyyy-mm-dd
            /// Check if a value has been assigned to Date data member.
            ///
            /// Data member Date is optional;
            /// its type is defined as 'typedef string TDate'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetDate(void) const;
        
            /// Check if it is safe to call GetDate method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetDate(void) const;
        
            /// Reset Date data member.
            void ResetDate(void);
        
            /// Get the Date member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TDate& GetDate(void) const;
        
            /// Assign a value to Date data member.
            ///
            /// @param value
            ///   Value to assign
            void SetDate(const TDate& value);
            void SetDate(TDate&& value);
        
            /// Assign a value to Date data member.
            ///
            /// @return
            ///   Reference to the data value.
            TDate& SetDate(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            int m_Build;
            string m_Date;
        };
        // types
        typedef C_Attlist TAttlist;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_update
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        ///most recent date the cluster was updated (member added or
        ///                         deleted)
        /// Check if a value has been assigned to Update data member.
        ///
        /// Data member Update is mandatory
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetUpdate(void) const;
    
        /// Check if value of Update member is getatable.
        ///
        /// @return
        ///   - false; the data member of type 'NULL' has no value.
        bool CanGetUpdate(void) const;
    
        /// Reset Update data member.
        void ResetUpdate(void);
    
        /// Set NULL data member (assign 'NULL' value to Update data member).
        void SetUpdate(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Update(const C_Update&);
        C_Update& operator=(const C_Update&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Sequence --
    ///
    
    class NCBI_DOCSUM_EXPORT C_Sequence : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Sequence(void);
        // destructor
        ~C_Sequence(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef Int8 TExemplarSs;
            typedef string TAncestralAllele;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_exemplarSs,
                e_ancestralAllele
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
        
            // getters
            // setters
        
            ///dbSNP ss# selected as source of refSNP flanking
            ///                                 sequence, ss# part of ss-list below 
            /// Check if a value has been assigned to ExemplarSs data member.
            ///
            /// Data member ExemplarSs is mandatory;
            /// its type is defined as 'typedef Int8 TExemplarSs'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetExemplarSs(void) const;
        
            /// Check if it is safe to call GetExemplarSs method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetExemplarSs(void) const;
        
            /// Reset ExemplarSs data member.
            void ResetExemplarSs(void);
        
            /// Get the ExemplarSs member data.
            ///
            /// @return
            ///   Copy of the member data.
            TExemplarSs GetExemplarSs(void) const;
        
            /// Assign a value to ExemplarSs data member.
            ///
            /// @param value
            ///   Value to assign
            void SetExemplarSs(TExemplarSs value);
        
            /// Assign a value to ExemplarSs data member.
            ///
            /// @return
            ///   Reference to the data value.
            TExemplarSs& SetExemplarSs(void);
        
            /// Check if a value has been assigned to AncestralAllele data member.
            ///
            /// Data member AncestralAllele is optional;
            /// its type is defined as 'typedef string TAncestralAllele'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetAncestralAllele(void) const;
        
            /// Check if it is safe to call GetAncestralAllele method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetAncestralAllele(void) const;
        
            /// Reset AncestralAllele data member.
            void ResetAncestralAllele(void);
        
            /// Get the AncestralAllele member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TAncestralAllele& GetAncestralAllele(void) const;
        
            /// Assign a value to AncestralAllele data member.
            ///
            /// @param value
            ///   Value to assign
            void SetAncestralAllele(const TAncestralAllele& value);
            void SetAncestralAllele(TAncestralAllele&& value);
        
            /// Assign a value to AncestralAllele data member.
            ///
            /// @return
            ///   Reference to the data value.
            TAncestralAllele& SetAncestralAllele(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            Int8 m_ExemplarSs;
            string m_AncestralAllele;
        };
        // types
        typedef C_Attlist TAttlist;
        typedef string TSeq5;
        typedef string TObserved;
        typedef string TSeq3;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_seq5,
            e_observed,
            e_seq3
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 5> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        ///5' sequence that flanks the
        ///                                     variation
        /// Check if a value has been assigned to Seq5 data member.
        ///
        /// Data member Seq5 is optional;
        /// its type is defined as 'typedef string TSeq5'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSeq5(void) const;
    
        /// Check if it is safe to call GetSeq5 method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSeq5(void) const;
    
        /// Reset Seq5 data member.
        void ResetSeq5(void);
    
        /// Get the Seq5 member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSeq5& GetSeq5(void) const;
    
        /// Assign a value to Seq5 data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSeq5(const TSeq5& value);
        void SetSeq5(TSeq5&& value);
    
        /// Assign a value to Seq5 data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSeq5& SetSeq5(void);
    
        ///list of all nucleotide alleles observed in
        ///                                     ss-list members, correcting for reverse complementation of
        ///                                     members reported in reverse orientation
        /// Check if a value has been assigned to Observed data member.
        ///
        /// Data member Observed is mandatory;
        /// its type is defined as 'typedef string TObserved'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetObserved(void) const;
    
        /// Check if it is safe to call GetObserved method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetObserved(void) const;
    
        /// Reset Observed data member.
        void ResetObserved(void);
    
        /// Get the Observed member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TObserved& GetObserved(void) const;
    
        /// Assign a value to Observed data member.
        ///
        /// @param value
        ///   Value to assign
        void SetObserved(const TObserved& value);
        void SetObserved(TObserved&& value);
    
        /// Assign a value to Observed data member.
        ///
        /// @return
        ///   Reference to the data value.
        TObserved& SetObserved(void);
    
        ///3' sequence that flanks the
        ///                                     variation
        /// Check if a value has been assigned to Seq3 data member.
        ///
        /// Data member Seq3 is optional;
        /// its type is defined as 'typedef string TSeq3'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetSeq3(void) const;
    
        /// Check if it is safe to call GetSeq3 method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetSeq3(void) const;
    
        /// Reset Seq3 data member.
        void ResetSeq3(void);
    
        /// Get the Seq3 member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TSeq3& GetSeq3(void) const;
    
        /// Assign a value to Seq3 data member.
        ///
        /// @param value
        ///   Value to assign
        void SetSeq3(const TSeq3& value);
        void SetSeq3(TSeq3&& value);
    
        /// Assign a value to Seq3 data member.
        ///
        /// @return
        ///   Reference to the data value.
        TSeq3& SetSeq3(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Sequence(const C_Sequence&);
        C_Sequence& operator=(const C_Sequence&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
        string m_Seq5;
        string m_Observed;
        string m_Seq3;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E_MergeHistory --
    ///
    
    class NCBI_DOCSUM_EXPORT C_E_MergeHistory : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E_MergeHistory(void);
        // destructor
        ~C_E_MergeHistory(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef int TRsId;
            typedef int TBuildId;
            typedef bool TOrientFlip;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_rsId,
                e_buildId,
                e_orientFlip
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 4> TmemberIndex;
        
            // getters
            // setters
        
            ///previously issued rs id whose member assays have
            ///                                 now been merged
            /// Check if a value has been assigned to RsId data member.
            ///
            /// Data member RsId is mandatory;
            /// its type is defined as 'typedef int TRsId'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetRsId(void) const;
        
            /// Check if it is safe to call GetRsId method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetRsId(void) const;
        
            /// Reset RsId data member.
            void ResetRsId(void);
        
            /// Get the RsId member data.
            ///
            /// @return
            ///   Copy of the member data.
            TRsId GetRsId(void) const;
        
            /// Assign a value to RsId data member.
            ///
            /// @param value
            ///   Value to assign
            void SetRsId(TRsId value);
        
            /// Assign a value to RsId data member.
            ///
            /// @return
            ///   Reference to the data value.
            TRsId& SetRsId(void);
        
            ///build id when rs id was merged into parent
            ///                                 rs
            /// Check if a value has been assigned to BuildId data member.
            ///
            /// Data member BuildId is optional;
            /// its type is defined as 'typedef int TBuildId'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetBuildId(void) const;
        
            /// Check if it is safe to call GetBuildId method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetBuildId(void) const;
        
            /// Reset BuildId data member.
            void ResetBuildId(void);
        
            /// Get the BuildId member data.
            ///
            /// @return
            ///   Copy of the member data.
            TBuildId GetBuildId(void) const;
        
            /// Assign a value to BuildId data member.
            ///
            /// @param value
            ///   Value to assign
            void SetBuildId(TBuildId value);
        
            /// Assign a value to BuildId data member.
            ///
            /// @return
            ///   Reference to the data value.
            TBuildId& SetBuildId(void);
        
            ///TRUE if strand of rs id is reverse to parent
            ///                                 object's current strand
            /// Check if a value has been assigned to OrientFlip data member.
            ///
            /// Data member OrientFlip is optional;
            /// its type is defined as 'typedef bool TOrientFlip'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetOrientFlip(void) const;
        
            /// Check if it is safe to call GetOrientFlip method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetOrientFlip(void) const;
        
            /// Reset OrientFlip data member.
            void ResetOrientFlip(void);
        
            /// Get the OrientFlip member data.
            ///
            /// @return
            ///   Copy of the member data.
            TOrientFlip GetOrientFlip(void) const;
        
            /// Assign a value to OrientFlip data member.
            ///
            /// @param value
            ///   Value to assign
            void SetOrientFlip(TOrientFlip value);
        
            /// Assign a value to OrientFlip data member.
            ///
            /// @return
            ///   Reference to the data value.
            TOrientFlip& SetOrientFlip(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            int m_RsId;
            int m_BuildId;
            bool m_OrientFlip;
        };
        // types
        typedef C_Attlist TAttlist;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_mergeHistory
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        /// Check if a value has been assigned to MergeHistory data member.
        ///
        /// Data member MergeHistory is mandatory
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetMergeHistory(void) const;
    
        /// Check if value of MergeHistory member is getatable.
        ///
        /// @return
        ///   - false; the data member of type 'NULL' has no value.
        bool CanGetMergeHistory(void) const;
    
        /// Reset MergeHistory data member.
        void ResetMergeHistory(void);
    
        /// Set NULL data member (assign 'NULL' value to MergeHistory data member).
        void SetMergeHistory(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_E_MergeHistory(const C_E_MergeHistory&);
        C_E_MergeHistory& operator=(const C_E_MergeHistory&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E_AlleleOrigin --
    ///
    
    class NCBI_DOCSUM_EXPORT C_E_AlleleOrigin : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E_AlleleOrigin(void);
        // destructor
        ~C_E_AlleleOrigin(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef string TAllele;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_allele
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Allele data member.
            ///
            /// Data member Allele is optional;
            /// its type is defined as 'typedef string TAllele'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetAllele(void) const;
        
            /// Check if it is safe to call GetAllele method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetAllele(void) const;
        
            /// Reset Allele data member.
            void ResetAllele(void);
        
            /// Get the Allele member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TAllele& GetAllele(void) const;
        
            /// Assign a value to Allele data member.
            ///
            /// @param value
            ///   Value to assign
            void SetAllele(const TAllele& value);
            void SetAllele(TAllele&& value);
        
            /// Assign a value to Allele data member.
            ///
            /// @return
            ///   Reference to the data value.
            TAllele& SetAllele(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            string m_Allele;
        };
        // types
        typedef C_Attlist TAttlist;
        typedef int TAlleleOrigin;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_alleleOrigin
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        ///                         origin of this allele, if known
        ///                         note that these are powers-of-two, and represent bits; thus, we can
        ///                         represent more than one state simultaneously through a bitwise OR
        ///                         unknown         (0),
        ///                         germline        (1),
        ///                         somatic         (2),
        ///                         inherited       (4),
        ///                         paternal        (8),
        ///                         maternal        (16),
        ///                         de-novo         (32),
        ///                         biparental      (64),
        ///                         uniparental     (128),
        ///                         not-tested      (256),
        ///                         tested-inconclusive (512),
        /// Check if a value has been assigned to AlleleOrigin data member.
        ///
        /// Data member AlleleOrigin is mandatory;
        /// its type is defined as 'typedef int TAlleleOrigin'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAlleleOrigin(void) const;
    
        /// Check if it is safe to call GetAlleleOrigin method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAlleleOrigin(void) const;
    
        /// Reset AlleleOrigin data member.
        void ResetAlleleOrigin(void);
    
        /// Get the AlleleOrigin member data.
        ///
        /// @return
        ///   Copy of the member data.
        TAlleleOrigin GetAlleleOrigin(void) const;
    
        /// Assign a value to AlleleOrigin data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAlleleOrigin(TAlleleOrigin value);
    
        /// Assign a value to AlleleOrigin data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAlleleOrigin& SetAlleleOrigin(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_E_AlleleOrigin(const C_E_AlleleOrigin&);
        C_E_AlleleOrigin& operator=(const C_E_AlleleOrigin&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
        int m_AlleleOrigin;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E_Phenotype --
    ///
    
    class NCBI_DOCSUM_EXPORT C_E_Phenotype : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E_Phenotype(void);
        // destructor
        ~C_E_Phenotype(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        // types
        typedef list< string > TClinicalSignificance;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_clinicalSignificance
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
    
        // getters
        // setters
    
        ///                                     unknown                 (0),
        ///                                     untested                (1),
        ///                                     non-pathogenic          (2),
        ///                                     probable-non-pathogenic (3),
        ///                                     probable-pathogenic     (4),
        ///                                     pathogenic              (5),
        ///                                     drug response           (6),
        ///                                     other                   (255)
        /// Check if a value has been assigned to ClinicalSignificance data member.
        ///
        /// Data member ClinicalSignificance is optional;
        /// its type is defined as 'typedef list< string > TClinicalSignificance'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetClinicalSignificance(void) const;
    
        /// Check if it is safe to call GetClinicalSignificance method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetClinicalSignificance(void) const;
    
        /// Reset ClinicalSignificance data member.
        void ResetClinicalSignificance(void);
    
        /// Get the ClinicalSignificance member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TClinicalSignificance& GetClinicalSignificance(void) const;
    
        /// Assign a value to ClinicalSignificance data member.
        ///
        /// @return
        ///   Reference to the data value.
        TClinicalSignificance& SetClinicalSignificance(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_E_Phenotype(const C_E_Phenotype&);
        C_E_Phenotype& operator=(const C_E_Phenotype&);
    
        // data
        Uint4 m_set_State[1];
        list< string > m_ClinicalSignificance;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E_BioSource --
    ///
    
    class NCBI_DOCSUM_EXPORT C_E_BioSource : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E_BioSource(void);
        // destructor
        ~C_E_BioSource(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        // types
        typedef list< string > TGenome;
        typedef list< string > TOrigin;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_genome,
            e_origin
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        ///                                     unknown (0) ,
        ///                                     genomic (1) ,
        ///                                     chloroplast (2) ,
        ///                                     chromoplast (3) ,
        ///                                     kinetoplast (4) ,
        ///                                     mitochondrion (5) ,
        ///                                     plastid (6) ,
        ///                                     macronuclear (7) ,
        ///                                     extrachrom (8) ,
        ///                                     plasmid (9) ,
        ///                                     transposon (10) ,
        ///                                     insertion-seq (11) ,
        ///                                     cyanelle (12) ,
        ///                                     proviral (13) ,
        ///                                     virion (14) ,
        ///                                     nucleomorph (15) ,
        ///                                     apicoplast (16) ,
        ///                                     leucoplast (17) ,
        ///                                     proplastid (18) ,
        ///                                     endogenous-virus (19) ,
        ///                                     hydrogenosome (20) ,
        ///                                     chromosome (21) ,
        ///                                     chromatophore (22)
        /// Check if a value has been assigned to Genome data member.
        ///
        /// Data member Genome is optional;
        /// its type is defined as 'typedef list< string > TGenome'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetGenome(void) const;
    
        /// Check if it is safe to call GetGenome method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetGenome(void) const;
    
        /// Reset Genome data member.
        void ResetGenome(void);
    
        /// Get the Genome member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TGenome& GetGenome(void) const;
    
        /// Assign a value to Genome data member.
        ///
        /// @return
        ///   Reference to the data value.
        TGenome& SetGenome(void);
    
        ///                                     unknown (0) ,
        ///                                     natural (1) ,                    normal biological entity
        ///                                     natmut (2) ,                    naturally occurring mutant
        ///                                     mut (3) ,                        artificially mutagenized
        ///                                     artificial (4) ,                 artificially engineered
        ///                                     synthetic (5) ,                 purely synthetic
        ///                                     other (255)
        /// Check if a value has been assigned to Origin data member.
        ///
        /// Data member Origin is optional;
        /// its type is defined as 'typedef list< string > TOrigin'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOrigin(void) const;
    
        /// Check if it is safe to call GetOrigin method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOrigin(void) const;
    
        /// Reset Origin data member.
        void ResetOrigin(void);
    
        /// Get the Origin member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TOrigin& GetOrigin(void) const;
    
        /// Assign a value to Origin data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOrigin& SetOrigin(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_E_BioSource(const C_E_BioSource&);
        C_E_BioSource& operator=(const C_E_BioSource&);
    
        // data
        Uint4 m_set_State[1];
        list< string > m_Genome;
        list< string > m_Origin;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E_Frequency --
    ///
    
    class NCBI_DOCSUM_EXPORT C_E_Frequency : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E_Frequency(void);
        // destructor
        ~C_E_Frequency(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Attlist --
        ///
        
        class NCBI_DOCSUM_EXPORT C_Attlist : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Attlist(void);
            // destructor
            ~C_Attlist(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef double TFreq;
            typedef string TAllele;
            typedef int TPopId;
            typedef int TSampleSize;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_freq,
                e_allele,
                e_popId,
                e_sampleSize
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 5> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Freq data member.
            ///
            /// Data member Freq is optional;
            /// its type is defined as 'typedef double TFreq'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetFreq(void) const;
        
            /// Check if it is safe to call GetFreq method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetFreq(void) const;
        
            /// Reset Freq data member.
            void ResetFreq(void);
        
            /// Get the Freq member data.
            ///
            /// @return
            ///   Copy of the member data.
            TFreq GetFreq(void) const;
        
            /// Assign a value to Freq data member.
            ///
            /// @param value
            ///   Value to assign
            void SetFreq(TFreq value);
        
            /// Assign a value to Freq data member.
            ///
            /// @return
            ///   Reference to the data value.
            TFreq& SetFreq(void);
        
            /// Check if a value has been assigned to Allele data member.
            ///
            /// Data member Allele is optional;
            /// its type is defined as 'typedef string TAllele'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetAllele(void) const;
        
            /// Check if it is safe to call GetAllele method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetAllele(void) const;
        
            /// Reset Allele data member.
            void ResetAllele(void);
        
            /// Get the Allele member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TAllele& GetAllele(void) const;
        
            /// Assign a value to Allele data member.
            ///
            /// @param value
            ///   Value to assign
            void SetAllele(const TAllele& value);
            void SetAllele(TAllele&& value);
        
            /// Assign a value to Allele data member.
            ///
            /// @return
            ///   Reference to the data value.
            TAllele& SetAllele(void);
        
            ///dbSNP Populaton ID
            /// Check if a value has been assigned to PopId data member.
            ///
            /// Data member PopId is optional;
            /// its type is defined as 'typedef int TPopId'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetPopId(void) const;
        
            /// Check if it is safe to call GetPopId method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetPopId(void) const;
        
            /// Reset PopId data member.
            void ResetPopId(void);
        
            /// Get the PopId member data.
            ///
            /// @return
            ///   Copy of the member data.
            TPopId GetPopId(void) const;
        
            /// Assign a value to PopId data member.
            ///
            /// @param value
            ///   Value to assign
            void SetPopId(TPopId value);
        
            /// Assign a value to PopId data member.
            ///
            /// @return
            ///   Reference to the data value.
            TPopId& SetPopId(void);
        
            /// Check if a value has been assigned to SampleSize data member.
            ///
            /// Data member SampleSize is optional;
            /// its type is defined as 'typedef int TSampleSize'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetSampleSize(void) const;
        
            /// Check if it is safe to call GetSampleSize method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetSampleSize(void) const;
        
            /// Reset SampleSize data member.
            void ResetSampleSize(void);
        
            /// Get the SampleSize member data.
            ///
            /// @return
            ///   Copy of the member data.
            TSampleSize GetSampleSize(void) const;
        
            /// Assign a value to SampleSize data member.
            ///
            /// @param value
            ///   Value to assign
            void SetSampleSize(TSampleSize value);
        
            /// Assign a value to SampleSize data member.
            ///
            /// @return
            ///   Reference to the data value.
            TSampleSize& SetSampleSize(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Attlist(const C_Attlist&);
            C_Attlist& operator=(const C_Attlist&);
        
            // data
            Uint4 m_set_State[1];
            double m_Freq;
            string m_Allele;
            int m_PopId;
            int m_SampleSize;
        };
        // types
        typedef C_Attlist TAttlist;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_attlist,
            e_frequency
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Attlist data member.
        ///
        /// Data member Attlist is mandatory;
        /// its type is defined as 'typedef C_Attlist TAttlist'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAttlist(void) const;
    
        /// Check if it is safe to call GetAttlist method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAttlist(void) const;
    
        /// Reset Attlist data member.
        void ResetAttlist(void);
    
        /// Get the Attlist member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TAttlist& GetAttlist(void) const;
    
        /// Assign a value to Attlist data member.
        ///
        /// @param value
        ///   Reference to value.
        void SetAttlist(TAttlist& value);
    
        /// Assign a value to Attlist data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAttlist& SetAttlist(void);
    
        /// Check if a value has been assigned to Frequency data member.
        ///
        /// Data member Frequency is mandatory
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetFrequency(void) const;
    
        /// Check if value of Frequency member is getatable.
        ///
        /// @return
        ///   - false; the data member of type 'NULL' has no value.
        bool CanGetFrequency(void) const;
    
        /// Reset Frequency data member.
        void ResetFrequency(void);
    
        /// Set NULL data member (assign 'NULL' value to Frequency data member).
        void SetFrequency(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_E_Frequency(const C_E_Frequency&);
        C_E_Frequency& operator=(const C_E_Frequency&);
    
        // data
        Uint4 m_set_State[1];
        CRef< TAttlist > m_Attlist;
    };
    // types
    typedef C_Attlist TAttlist;
    typedef C_Het THet;
    typedef C_Validation TValidation;
    typedef C_Create TCreate;
    typedef C_Update TUpdate;
    typedef C_Sequence TSequence;
    typedef list< CRef< CSs > > TSs;
    typedef list< CRef< CAssembly > > TAssembly;
    typedef list< CRef< CPrimarySequence > > TPrimarySequence;
    typedef list< CRef< CRsStruct > > TRsStruct;
    typedef list< CRef< CRsLinkout > > TRsLinkout;
    typedef C_E_MergeHistory C_E;
    typedef list< CRef< C_E_MergeHistory > > TMergeHistory;
    typedef list< string > THgvs;
    typedef list< CRef< C_E_AlleleOrigin > > TAlleleOrigin;
    typedef list< CRef< C_E_Phenotype > > TPhenotype;
    typedef list< CRef< C_E_BioSource > > TBioSource;
    typedef list< CRef< C_E_Frequency > > TFrequency;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_attlist,
        e_het,
        e_validation,
        e_create,
        e_update,
        e_sequence,
        e_ss,
        e_assembly,
        e_primarySequence,
        e_rsStruct,
        e_rsLinkout,
        e_mergeHistory,
        e_hgvs,
        e_alleleOrigin,
        e_phenotype,
        e_bioSource,
        e_frequency
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 18> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Attlist data member.
    ///
    /// Data member Attlist is mandatory;
    /// its type is defined as 'typedef C_Attlist TAttlist'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAttlist(void) const;
 
    /// Check if it is safe to call GetAttlist method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAttlist(void) const;
 
    /// Reset Attlist data member.
    void ResetAttlist(void);
 
    /// Get the Attlist member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAttlist& GetAttlist(void) const;
 
    /// Assign a value to Attlist data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetAttlist(TAttlist& value);
 
    /// Assign a value to Attlist data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAttlist& SetAttlist(void);
 
    /// Check if a value has been assigned to Het data member.
    ///
    /// Data member Het is optional;
    /// its type is defined as 'typedef C_Het THet'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetHet(void) const;
 
    /// Check if it is safe to call GetHet method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetHet(void) const;
 
    /// Reset Het data member.
    void ResetHet(void);
 
    /// Get the Het member data.
    ///
    /// @return
    ///   Reference to the member data.
    const THet& GetHet(void) const;
 
    /// Assign a value to Het data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetHet(THet& value);
 
    /// Assign a value to Het data member.
    ///
    /// @return
    ///   Reference to the data value.
    THet& SetHet(void);
 
    /// Check if a value has been assigned to Validation data member.
    ///
    /// Data member Validation is mandatory;
    /// its type is defined as 'typedef C_Validation TValidation'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetValidation(void) const;
 
    /// Check if it is safe to call GetValidation method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetValidation(void) const;
 
    /// Reset Validation data member.
    void ResetValidation(void);
 
    /// Get the Validation member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TValidation& GetValidation(void) const;
 
    /// Assign a value to Validation data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetValidation(TValidation& value);
 
    /// Assign a value to Validation data member.
    ///
    /// @return
    ///   Reference to the data value.
    TValidation& SetValidation(void);
 
    /// Check if a value has been assigned to Create data member.
    ///
    /// Data member Create is mandatory;
    /// its type is defined as 'typedef C_Create TCreate'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetCreate(void) const;
 
    /// Check if it is safe to call GetCreate method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetCreate(void) const;
 
    /// Reset Create data member.
    void ResetCreate(void);
 
    /// Get the Create member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TCreate& GetCreate(void) const;
 
    /// Assign a value to Create data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetCreate(TCreate& value);
 
    /// Assign a value to Create data member.
    ///
    /// @return
    ///   Reference to the data value.
    TCreate& SetCreate(void);
 
    /// Check if a value has been assigned to Update data member.
    ///
    /// Data member Update is optional;
    /// its type is defined as 'typedef C_Update TUpdate'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetUpdate(void) const;
 
    /// Check if it is safe to call GetUpdate method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetUpdate(void) const;
 
    /// Reset Update data member.
    void ResetUpdate(void);
 
    /// Get the Update member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TUpdate& GetUpdate(void) const;
 
    /// Assign a value to Update data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetUpdate(TUpdate& value);
 
    /// Assign a value to Update data member.
    ///
    /// @return
    ///   Reference to the data value.
    TUpdate& SetUpdate(void);
 
    /// Check if a value has been assigned to Sequence data member.
    ///
    /// Data member Sequence is mandatory;
    /// its type is defined as 'typedef C_Sequence TSequence'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetSequence(void) const;
 
    /// Check if it is safe to call GetSequence method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetSequence(void) const;
 
    /// Reset Sequence data member.
    void ResetSequence(void);
 
    /// Get the Sequence member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TSequence& GetSequence(void) const;
 
    /// Assign a value to Sequence data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetSequence(TSequence& value);
 
    /// Assign a value to Sequence data member.
    ///
    /// @return
    ///   Reference to the data value.
    TSequence& SetSequence(void);
 
    /// Check if a value has been assigned to Ss data member.
    ///
    /// Data member Ss is mandatory;
    /// its type is defined as 'typedef list< CRef< CSs > > TSs'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetSs(void) const;
 
    /// Check if it is safe to call GetSs method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetSs(void) const;
 
    /// Reset Ss data member.
    void ResetSs(void);
 
    /// Get the Ss member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TSs& GetSs(void) const;
 
    /// Assign a value to Ss data member.
    ///
    /// @return
    ///   Reference to the data value.
    TSs& SetSs(void);
 
    /// Check if a value has been assigned to Assembly data member.
    ///
    /// Data member Assembly is optional;
    /// its type is defined as 'typedef list< CRef< CAssembly > > TAssembly'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAssembly(void) const;
 
    /// Check if it is safe to call GetAssembly method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAssembly(void) const;
 
    /// Reset Assembly data member.
    void ResetAssembly(void);
 
    /// Get the Assembly member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAssembly& GetAssembly(void) const;
 
    /// Assign a value to Assembly data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAssembly& SetAssembly(void);
 
    /// Check if a value has been assigned to PrimarySequence data member.
    ///
    /// Data member PrimarySequence is optional;
    /// its type is defined as 'typedef list< CRef< CPrimarySequence > > TPrimarySequence'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPrimarySequence(void) const;
 
    /// Check if it is safe to call GetPrimarySequence method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPrimarySequence(void) const;
 
    /// Reset PrimarySequence data member.
    void ResetPrimarySequence(void);
 
    /// Get the PrimarySequence member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPrimarySequence& GetPrimarySequence(void) const;
 
    /// Assign a value to PrimarySequence data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPrimarySequence& SetPrimarySequence(void);
 
    /// Check if a value has been assigned to RsStruct data member.
    ///
    /// Data member RsStruct is optional;
    /// its type is defined as 'typedef list< CRef< CRsStruct > > TRsStruct'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRsStruct(void) const;
 
    /// Check if it is safe to call GetRsStruct method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRsStruct(void) const;
 
    /// Reset RsStruct data member.
    void ResetRsStruct(void);
 
    /// Get the RsStruct member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TRsStruct& GetRsStruct(void) const;
 
    /// Assign a value to RsStruct data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRsStruct& SetRsStruct(void);
 
    /// Check if a value has been assigned to RsLinkout data member.
    ///
    /// Data member RsLinkout is optional;
    /// its type is defined as 'typedef list< CRef< CRsLinkout > > TRsLinkout'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRsLinkout(void) const;
 
    /// Check if it is safe to call GetRsLinkout method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRsLinkout(void) const;
 
    /// Reset RsLinkout data member.
    void ResetRsLinkout(void);
 
    /// Get the RsLinkout member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TRsLinkout& GetRsLinkout(void) const;
 
    /// Assign a value to RsLinkout data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRsLinkout& SetRsLinkout(void);
 
    /// Check if a value has been assigned to MergeHistory data member.
    ///
    /// Data member MergeHistory is optional;
    /// its type is defined as 'typedef list< CRef< C_E_MergeHistory > > TMergeHistory'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMergeHistory(void) const;
 
    /// Check if it is safe to call GetMergeHistory method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMergeHistory(void) const;
 
    /// Reset MergeHistory data member.
    void ResetMergeHistory(void);
 
    /// Get the MergeHistory member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TMergeHistory& GetMergeHistory(void) const;
 
    /// Assign a value to MergeHistory data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMergeHistory& SetMergeHistory(void);
 
    /// HGVS name list 
    /// Check if a value has been assigned to Hgvs data member.
    ///
    /// Data member Hgvs is optional;
    /// its type is defined as 'typedef list< string > THgvs'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetHgvs(void) const;
 
    /// Check if it is safe to call GetHgvs method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetHgvs(void) const;
 
    /// Reset Hgvs data member.
    void ResetHgvs(void);
 
    /// Get the Hgvs member data.
    ///
    /// @return
    ///   Reference to the member data.
    const THgvs& GetHgvs(void) const;
 
    /// Assign a value to Hgvs data member.
    ///
    /// @return
    ///   Reference to the data value.
    THgvs& SetHgvs(void);
 
    /// Check if a value has been assigned to AlleleOrigin data member.
    ///
    /// Data member AlleleOrigin is optional;
    /// its type is defined as 'typedef list< CRef< C_E_AlleleOrigin > > TAlleleOrigin'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAlleleOrigin(void) const;
 
    /// Check if it is safe to call GetAlleleOrigin method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAlleleOrigin(void) const;
 
    /// Reset AlleleOrigin data member.
    void ResetAlleleOrigin(void);
 
    /// Get the AlleleOrigin member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAlleleOrigin& GetAlleleOrigin(void) const;
 
    /// Assign a value to AlleleOrigin data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAlleleOrigin& SetAlleleOrigin(void);
 
    /// Check if a value has been assigned to Phenotype data member.
    ///
    /// Data member Phenotype is optional;
    /// its type is defined as 'typedef list< CRef< C_E_Phenotype > > TPhenotype'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetPhenotype(void) const;
 
    /// Check if it is safe to call GetPhenotype method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetPhenotype(void) const;
 
    /// Reset Phenotype data member.
    void ResetPhenotype(void);
 
    /// Get the Phenotype member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TPhenotype& GetPhenotype(void) const;
 
    /// Assign a value to Phenotype data member.
    ///
    /// @return
    ///   Reference to the data value.
    TPhenotype& SetPhenotype(void);
 
    /// Check if a value has been assigned to BioSource data member.
    ///
    /// Data member BioSource is optional;
    /// its type is defined as 'typedef list< CRef< C_E_BioSource > > TBioSource'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetBioSource(void) const;
 
    /// Check if it is safe to call GetBioSource method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetBioSource(void) const;
 
    /// Reset BioSource data member.
    void ResetBioSource(void);
 
    /// Get the BioSource member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TBioSource& GetBioSource(void) const;
 
    /// Assign a value to BioSource data member.
    ///
    /// @return
    ///   Reference to the data value.
    TBioSource& SetBioSource(void);
 
    /// Check if a value has been assigned to Frequency data member.
    ///
    /// Data member Frequency is optional;
    /// its type is defined as 'typedef list< CRef< C_E_Frequency > > TFrequency'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetFrequency(void) const;
 
    /// Check if it is safe to call GetFrequency method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetFrequency(void) const;
 
    /// Reset Frequency data member.
    void ResetFrequency(void);
 
    /// Get the Frequency member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TFrequency& GetFrequency(void) const;
 
    /// Assign a value to Frequency data member.
    ///
    /// @return
    ///   Reference to the data value.
    TFrequency& SetFrequency(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CRs_Base(const CRs_Base&);
    CRs_Base& operator=(const CRs_Base&);
 
    // data
    Uint4 m_set_State[2];
    CRef< TAttlist > m_Attlist;
    CRef< THet > m_Het;
    CRef< TValidation > m_Validation;
    CRef< TCreate > m_Create;
    CRef< TUpdate > m_Update;
    CRef< TSequence > m_Sequence;
    list< CRef< CSs > > m_Ss;
    list< CRef< CAssembly > > m_Assembly;
    list< CRef< CPrimarySequence > > m_PrimarySequence;
    list< CRef< CRsStruct > > m_RsStruct;
    list< CRef< CRsLinkout > > m_RsLinkout;
    list< CRef< C_E_MergeHistory > > m_MergeHistory;
    list< string > m_Hgvs;
    list< CRef< C_E_AlleleOrigin > > m_AlleleOrigin;
    list< CRef< C_E_Phenotype > > m_Phenotype;
    list< CRef< C_E_BioSource > > m_BioSource;
    list< CRef< C_E_Frequency > > m_Frequency;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CRs_Base::C_Attlist::IsSetRsId(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetRsId(void) const
{
    return IsSetRsId();
}
 
inline
void CRs_Base::C_Attlist::ResetRsId(void)
{
    m_RsId = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Attlist::TRsId CRs_Base::C_Attlist::GetRsId(void) const
{
    if (!CanGetRsId()) {
        ThrowUnassigned(0);
    }
    return m_RsId;
}
 
inline
void CRs_Base::C_Attlist::SetRsId(CRs_Base::C_Attlist::TRsId value)
{
    m_RsId = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Attlist::TRsId& CRs_Base::C_Attlist::SetRsId(void)
{
#ifdef _DEBUG
    if (!IsSetRsId()) {
        memset(&m_RsId,UnassignedByte(),sizeof(m_RsId));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_RsId;
}
 
inline
bool CRs_Base::C_Attlist::IsSetSnpClass(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetSnpClass(void) const
{
    return IsSetSnpClass();
}
 
inline
void CRs_Base::C_Attlist::ResetSnpClass(void)
{
    m_SnpClass = (EAttlist_snpClass)(0);
    m_set_State[0] &= ~0xc;
}
 
inline
CRs_Base::C_Attlist::TSnpClass CRs_Base::C_Attlist::GetSnpClass(void) const
{
    if (!CanGetSnpClass()) {
        ThrowUnassigned(1);
    }
    return m_SnpClass;
}
 
inline
void CRs_Base::C_Attlist::SetSnpClass(CRs_Base::C_Attlist::TSnpClass value)
{
    m_SnpClass = value;
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Attlist::TSnpClass& CRs_Base::C_Attlist::SetSnpClass(void)
{
#ifdef _DEBUG
    if (!IsSetSnpClass()) {
        memset(&m_SnpClass,UnassignedByte(),sizeof(m_SnpClass));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_SnpClass;
}
 
inline
bool CRs_Base::C_Attlist::IsSetSnpType(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetSnpType(void) const
{
    return IsSetSnpType();
}
 
inline
void CRs_Base::C_Attlist::ResetSnpType(void)
{
    m_SnpType = (EAttlist_snpType)(0);
    m_set_State[0] &= ~0x30;
}
 
inline
CRs_Base::C_Attlist::TSnpType CRs_Base::C_Attlist::GetSnpType(void) const
{
    if (!CanGetSnpType()) {
        ThrowUnassigned(2);
    }
    return m_SnpType;
}
 
inline
void CRs_Base::C_Attlist::SetSnpType(CRs_Base::C_Attlist::TSnpType value)
{
    m_SnpType = value;
    m_set_State[0] |= 0x30;
}
 
inline
CRs_Base::C_Attlist::TSnpType& CRs_Base::C_Attlist::SetSnpType(void)
{
#ifdef _DEBUG
    if (!IsSetSnpType()) {
        memset(&m_SnpType,UnassignedByte(),sizeof(m_SnpType));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_SnpType;
}
 
inline
bool CRs_Base::C_Attlist::IsSetMolType(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetMolType(void) const
{
    return IsSetMolType();
}
 
inline
void CRs_Base::C_Attlist::ResetMolType(void)
{
    m_MolType = (EAttlist_molType)(0);
    m_set_State[0] &= ~0xc0;
}
 
inline
CRs_Base::C_Attlist::TMolType CRs_Base::C_Attlist::GetMolType(void) const
{
    if (!CanGetMolType()) {
        ThrowUnassigned(3);
    }
    return m_MolType;
}
 
inline
void CRs_Base::C_Attlist::SetMolType(CRs_Base::C_Attlist::TMolType value)
{
    m_MolType = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CRs_Base::C_Attlist::TMolType& CRs_Base::C_Attlist::SetMolType(void)
{
#ifdef _DEBUG
    if (!IsSetMolType()) {
        memset(&m_MolType,UnassignedByte(),sizeof(m_MolType));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_MolType;
}
 
inline
bool CRs_Base::C_Attlist::IsSetValidProbMin(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetValidProbMin(void) const
{
    return IsSetValidProbMin();
}
 
inline
void CRs_Base::C_Attlist::ResetValidProbMin(void)
{
    m_ValidProbMin = 0;
    m_set_State[0] &= ~0x300;
}
 
inline
CRs_Base::C_Attlist::TValidProbMin CRs_Base::C_Attlist::GetValidProbMin(void) const
{
    if (!CanGetValidProbMin()) {
        ThrowUnassigned(4);
    }
    return m_ValidProbMin;
}
 
inline
void CRs_Base::C_Attlist::SetValidProbMin(CRs_Base::C_Attlist::TValidProbMin value)
{
    m_ValidProbMin = value;
    m_set_State[0] |= 0x300;
}
 
inline
CRs_Base::C_Attlist::TValidProbMin& CRs_Base::C_Attlist::SetValidProbMin(void)
{
#ifdef _DEBUG
    if (!IsSetValidProbMin()) {
        memset(&m_ValidProbMin,UnassignedByte(),sizeof(m_ValidProbMin));
    }
#endif
    m_set_State[0] |= 0x100;
    return m_ValidProbMin;
}
 
inline
bool CRs_Base::C_Attlist::IsSetValidProbMax(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetValidProbMax(void) const
{
    return IsSetValidProbMax();
}
 
inline
void CRs_Base::C_Attlist::ResetValidProbMax(void)
{
    m_ValidProbMax = 0;
    m_set_State[0] &= ~0xc00;
}
 
inline
CRs_Base::C_Attlist::TValidProbMax CRs_Base::C_Attlist::GetValidProbMax(void) const
{
    if (!CanGetValidProbMax()) {
        ThrowUnassigned(5);
    }
    return m_ValidProbMax;
}
 
inline
void CRs_Base::C_Attlist::SetValidProbMax(CRs_Base::C_Attlist::TValidProbMax value)
{
    m_ValidProbMax = value;
    m_set_State[0] |= 0xc00;
}
 
inline
CRs_Base::C_Attlist::TValidProbMax& CRs_Base::C_Attlist::SetValidProbMax(void)
{
#ifdef _DEBUG
    if (!IsSetValidProbMax()) {
        memset(&m_ValidProbMax,UnassignedByte(),sizeof(m_ValidProbMax));
    }
#endif
    m_set_State[0] |= 0x400;
    return m_ValidProbMax;
}
 
inline
bool CRs_Base::C_Attlist::IsSetGenotype(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetGenotype(void) const
{
    return IsSetGenotype();
}
 
inline
void CRs_Base::C_Attlist::ResetGenotype(void)
{
    m_Genotype = 0;
    m_set_State[0] &= ~0x3000;
}
 
inline
CRs_Base::C_Attlist::TGenotype CRs_Base::C_Attlist::GetGenotype(void) const
{
    if (!CanGetGenotype()) {
        ThrowUnassigned(6);
    }
    return m_Genotype;
}
 
inline
void CRs_Base::C_Attlist::SetGenotype(CRs_Base::C_Attlist::TGenotype value)
{
    m_Genotype = value;
    m_set_State[0] |= 0x3000;
}
 
inline
CRs_Base::C_Attlist::TGenotype& CRs_Base::C_Attlist::SetGenotype(void)
{
#ifdef _DEBUG
    if (!IsSetGenotype()) {
        memset(&m_Genotype,UnassignedByte(),sizeof(m_Genotype));
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_Genotype;
}
 
inline
bool CRs_Base::C_Attlist::IsSetBitField(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetBitField(void) const
{
    return IsSetBitField();
}
 
inline
const CRs_Base::C_Attlist::TBitField& CRs_Base::C_Attlist::GetBitField(void) const
{
    if (!CanGetBitField()) {
        ThrowUnassigned(7);
    }
    return m_BitField;
}
 
inline
void CRs_Base::C_Attlist::SetBitField(const CRs_Base::C_Attlist::TBitField& value)
{
    m_BitField = value;
    m_set_State[0] |= 0xc000;
}
 
inline
void CRs_Base::C_Attlist::SetBitField(CRs_Base::C_Attlist::TBitField&& value)
{
    m_BitField = std::forward<CRs_Base::C_Attlist::TBitField>(value);
    m_set_State[0] |= 0xc000;
}
 
inline
CRs_Base::C_Attlist::TBitField& CRs_Base::C_Attlist::SetBitField(void)
{
#ifdef _DEBUG
    if (!IsSetBitField()) {
        m_BitField = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000;
    return m_BitField;
}
 
inline
bool CRs_Base::C_Attlist::IsSetTaxId(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CRs_Base::C_Attlist::CanGetTaxId(void) const
{
    return IsSetTaxId();
}
 
inline
void CRs_Base::C_Attlist::ResetTaxId(void)
{
    m_TaxId = 0;
    m_set_State[0] &= ~0x30000;
}
 
inline
CRs_Base::C_Attlist::TTaxId CRs_Base::C_Attlist::GetTaxId(void) const
{
    if (!CanGetTaxId()) {
        ThrowUnassigned(8);
    }
    return m_TaxId;
}
 
inline
void CRs_Base::C_Attlist::SetTaxId(CRs_Base::C_Attlist::TTaxId value)
{
    m_TaxId = value;
    m_set_State[0] |= 0x30000;
}
 
inline
CRs_Base::C_Attlist::TTaxId& CRs_Base::C_Attlist::SetTaxId(void)
{
#ifdef _DEBUG
    if (!IsSetTaxId()) {
        memset(&m_TaxId,UnassignedByte(),sizeof(m_TaxId));
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_TaxId;
}
 
inline
bool CRs_Base::C_Het::C_Attlist::IsSetType(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Het::C_Attlist::CanGetType(void) const
{
    return IsSetType();
}
 
inline
void CRs_Base::C_Het::C_Attlist::ResetType(void)
{
    m_Type = (EHet_attlist_type)(0);
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Het::C_Attlist::TType CRs_Base::C_Het::C_Attlist::GetType(void) const
{
    if (!CanGetType()) {
        ThrowUnassigned(0);
    }
    return m_Type;
}
 
inline
void CRs_Base::C_Het::C_Attlist::SetType(CRs_Base::C_Het::C_Attlist::TType value)
{
    m_Type = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Het::C_Attlist::TType& CRs_Base::C_Het::C_Attlist::SetType(void)
{
#ifdef _DEBUG
    if (!IsSetType()) {
        memset(&m_Type,UnassignedByte(),sizeof(m_Type));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Type;
}
 
inline
bool CRs_Base::C_Het::C_Attlist::IsSetValue(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Het::C_Attlist::CanGetValue(void) const
{
    return IsSetValue();
}
 
inline
void CRs_Base::C_Het::C_Attlist::ResetValue(void)
{
    m_Value = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CRs_Base::C_Het::C_Attlist::TValue CRs_Base::C_Het::C_Attlist::GetValue(void) const
{
    if (!CanGetValue()) {
        ThrowUnassigned(1);
    }
    return m_Value;
}
 
inline
void CRs_Base::C_Het::C_Attlist::SetValue(CRs_Base::C_Het::C_Attlist::TValue value)
{
    m_Value = value;
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Het::C_Attlist::TValue& CRs_Base::C_Het::C_Attlist::SetValue(void)
{
#ifdef _DEBUG
    if (!IsSetValue()) {
        memset(&m_Value,UnassignedByte(),sizeof(m_Value));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Value;
}
 
inline
bool CRs_Base::C_Het::C_Attlist::IsSetStdError(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_Het::C_Attlist::CanGetStdError(void) const
{
    return IsSetStdError();
}
 
inline
void CRs_Base::C_Het::C_Attlist::ResetStdError(void)
{
    m_StdError = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CRs_Base::C_Het::C_Attlist::TStdError CRs_Base::C_Het::C_Attlist::GetStdError(void) const
{
    if (!CanGetStdError()) {
        ThrowUnassigned(2);
    }
    return m_StdError;
}
 
inline
void CRs_Base::C_Het::C_Attlist::SetStdError(CRs_Base::C_Het::C_Attlist::TStdError value)
{
    m_StdError = value;
    m_set_State[0] |= 0x30;
}
 
inline
CRs_Base::C_Het::C_Attlist::TStdError& CRs_Base::C_Het::C_Attlist::SetStdError(void)
{
#ifdef _DEBUG
    if (!IsSetStdError()) {
        memset(&m_StdError,UnassignedByte(),sizeof(m_StdError));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_StdError;
}
 
inline
bool CRs_Base::C_Het::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_Het::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Het::TAttlist& CRs_Base::C_Het::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_Het*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_Het::TAttlist& CRs_Base::C_Het::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_Het::IsSetHet(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Het::CanGetHet(void) const
{
    return false;
}
 
inline
void CRs_Base::C_Het::ResetHet(void)
{
    m_set_State[0] &= ~0xc;
}
 
inline
void CRs_Base::C_Het::SetHet(void)
{
    m_set_State[0] |= 0xc;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetByCluster(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetByCluster(void) const
{
    return IsSetByCluster();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetByCluster(void)
{
    m_ByCluster = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByCluster CRs_Base::C_Validation::C_Attlist::GetByCluster(void) const
{
    if (!CanGetByCluster()) {
        ThrowUnassigned(0);
    }
    return m_ByCluster;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetByCluster(CRs_Base::C_Validation::C_Attlist::TByCluster value)
{
    m_ByCluster = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByCluster& CRs_Base::C_Validation::C_Attlist::SetByCluster(void)
{
#ifdef _DEBUG
    if (!IsSetByCluster()) {
        memset(&m_ByCluster,UnassignedByte(),sizeof(m_ByCluster));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_ByCluster;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetByFrequency(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetByFrequency(void) const
{
    return IsSetByFrequency();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetByFrequency(void)
{
    m_ByFrequency = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByFrequency CRs_Base::C_Validation::C_Attlist::GetByFrequency(void) const
{
    if (!CanGetByFrequency()) {
        ThrowUnassigned(1);
    }
    return m_ByFrequency;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetByFrequency(CRs_Base::C_Validation::C_Attlist::TByFrequency value)
{
    m_ByFrequency = value;
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByFrequency& CRs_Base::C_Validation::C_Attlist::SetByFrequency(void)
{
#ifdef _DEBUG
    if (!IsSetByFrequency()) {
        memset(&m_ByFrequency,UnassignedByte(),sizeof(m_ByFrequency));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_ByFrequency;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetByOtherPop(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetByOtherPop(void) const
{
    return IsSetByOtherPop();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetByOtherPop(void)
{
    m_ByOtherPop = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByOtherPop CRs_Base::C_Validation::C_Attlist::GetByOtherPop(void) const
{
    if (!CanGetByOtherPop()) {
        ThrowUnassigned(2);
    }
    return m_ByOtherPop;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetByOtherPop(CRs_Base::C_Validation::C_Attlist::TByOtherPop value)
{
    m_ByOtherPop = value;
    m_set_State[0] |= 0x30;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByOtherPop& CRs_Base::C_Validation::C_Attlist::SetByOtherPop(void)
{
#ifdef _DEBUG
    if (!IsSetByOtherPop()) {
        memset(&m_ByOtherPop,UnassignedByte(),sizeof(m_ByOtherPop));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_ByOtherPop;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetBy2Hit2Allele(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetBy2Hit2Allele(void) const
{
    return IsSetBy2Hit2Allele();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetBy2Hit2Allele(void)
{
    m_By2Hit2Allele = 0;
    m_set_State[0] &= ~0xc0;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TBy2Hit2Allele CRs_Base::C_Validation::C_Attlist::GetBy2Hit2Allele(void) const
{
    if (!CanGetBy2Hit2Allele()) {
        ThrowUnassigned(3);
    }
    return m_By2Hit2Allele;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetBy2Hit2Allele(CRs_Base::C_Validation::C_Attlist::TBy2Hit2Allele value)
{
    m_By2Hit2Allele = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TBy2Hit2Allele& CRs_Base::C_Validation::C_Attlist::SetBy2Hit2Allele(void)
{
#ifdef _DEBUG
    if (!IsSetBy2Hit2Allele()) {
        memset(&m_By2Hit2Allele,UnassignedByte(),sizeof(m_By2Hit2Allele));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_By2Hit2Allele;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetByHapMap(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetByHapMap(void) const
{
    return IsSetByHapMap();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetByHapMap(void)
{
    m_ByHapMap = 0;
    m_set_State[0] &= ~0x300;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByHapMap CRs_Base::C_Validation::C_Attlist::GetByHapMap(void) const
{
    if (!CanGetByHapMap()) {
        ThrowUnassigned(4);
    }
    return m_ByHapMap;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetByHapMap(CRs_Base::C_Validation::C_Attlist::TByHapMap value)
{
    m_ByHapMap = value;
    m_set_State[0] |= 0x300;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TByHapMap& CRs_Base::C_Validation::C_Attlist::SetByHapMap(void)
{
#ifdef _DEBUG
    if (!IsSetByHapMap()) {
        memset(&m_ByHapMap,UnassignedByte(),sizeof(m_ByHapMap));
    }
#endif
    m_set_State[0] |= 0x100;
    return m_ByHapMap;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetBy1000G(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetBy1000G(void) const
{
    return IsSetBy1000G();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetBy1000G(void)
{
    m_By1000G = 0;
    m_set_State[0] &= ~0xc00;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TBy1000G CRs_Base::C_Validation::C_Attlist::GetBy1000G(void) const
{
    if (!CanGetBy1000G()) {
        ThrowUnassigned(5);
    }
    return m_By1000G;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetBy1000G(CRs_Base::C_Validation::C_Attlist::TBy1000G value)
{
    m_By1000G = value;
    m_set_State[0] |= 0xc00;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TBy1000G& CRs_Base::C_Validation::C_Attlist::SetBy1000G(void)
{
#ifdef _DEBUG
    if (!IsSetBy1000G()) {
        memset(&m_By1000G,UnassignedByte(),sizeof(m_By1000G));
    }
#endif
    m_set_State[0] |= 0x400;
    return m_By1000G;
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::IsSetSuspect(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CRs_Base::C_Validation::C_Attlist::CanGetSuspect(void) const
{
    return IsSetSuspect();
}
 
inline
void CRs_Base::C_Validation::C_Attlist::ResetSuspect(void)
{
    m_Suspect = 0;
    m_set_State[0] &= ~0x3000;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TSuspect CRs_Base::C_Validation::C_Attlist::GetSuspect(void) const
{
    if (!CanGetSuspect()) {
        ThrowUnassigned(6);
    }
    return m_Suspect;
}
 
inline
void CRs_Base::C_Validation::C_Attlist::SetSuspect(CRs_Base::C_Validation::C_Attlist::TSuspect value)
{
    m_Suspect = value;
    m_set_State[0] |= 0x3000;
}
 
inline
CRs_Base::C_Validation::C_Attlist::TSuspect& CRs_Base::C_Validation::C_Attlist::SetSuspect(void)
{
#ifdef _DEBUG
    if (!IsSetSuspect()) {
        memset(&m_Suspect,UnassignedByte(),sizeof(m_Suspect));
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_Suspect;
}
 
inline
bool CRs_Base::C_Validation::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_Validation::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TAttlist& CRs_Base::C_Validation::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_Validation*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_Validation::TAttlist& CRs_Base::C_Validation::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_Validation::IsSetOtherPopBatchId(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetOtherPopBatchId(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TOtherPopBatchId& CRs_Base::C_Validation::GetOtherPopBatchId(void) const
{
    return m_OtherPopBatchId;
}
 
inline
CRs_Base::C_Validation::TOtherPopBatchId& CRs_Base::C_Validation::SetOtherPopBatchId(void)
{
    m_set_State[0] |= 0x4;
    return m_OtherPopBatchId;
}
 
inline
bool CRs_Base::C_Validation::IsSetTwoHit2AlleleBatchId(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetTwoHit2AlleleBatchId(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TTwoHit2AlleleBatchId& CRs_Base::C_Validation::GetTwoHit2AlleleBatchId(void) const
{
    return m_TwoHit2AlleleBatchId;
}
 
inline
CRs_Base::C_Validation::TTwoHit2AlleleBatchId& CRs_Base::C_Validation::SetTwoHit2AlleleBatchId(void)
{
    m_set_State[0] |= 0x10;
    return m_TwoHit2AlleleBatchId;
}
 
inline
bool CRs_Base::C_Validation::IsSetFrequencyClass(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetFrequencyClass(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TFrequencyClass& CRs_Base::C_Validation::GetFrequencyClass(void) const
{
    return m_FrequencyClass;
}
 
inline
CRs_Base::C_Validation::TFrequencyClass& CRs_Base::C_Validation::SetFrequencyClass(void)
{
    m_set_State[0] |= 0x40;
    return m_FrequencyClass;
}
 
inline
bool CRs_Base::C_Validation::IsSetHapMapPhase(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetHapMapPhase(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::THapMapPhase& CRs_Base::C_Validation::GetHapMapPhase(void) const
{
    return m_HapMapPhase;
}
 
inline
CRs_Base::C_Validation::THapMapPhase& CRs_Base::C_Validation::SetHapMapPhase(void)
{
    m_set_State[0] |= 0x100;
    return m_HapMapPhase;
}
 
inline
bool CRs_Base::C_Validation::IsSetTGPPhase(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetTGPPhase(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TTGPPhase& CRs_Base::C_Validation::GetTGPPhase(void) const
{
    return m_TGPPhase;
}
 
inline
CRs_Base::C_Validation::TTGPPhase& CRs_Base::C_Validation::SetTGPPhase(void)
{
    m_set_State[0] |= 0x400;
    return m_TGPPhase;
}
 
inline
bool CRs_Base::C_Validation::IsSetSuspectEvidence(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CRs_Base::C_Validation::CanGetSuspectEvidence(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Validation::TSuspectEvidence& CRs_Base::C_Validation::GetSuspectEvidence(void) const
{
    return m_SuspectEvidence;
}
 
inline
CRs_Base::C_Validation::TSuspectEvidence& CRs_Base::C_Validation::SetSuspectEvidence(void)
{
    m_set_State[0] |= 0x1000;
    return m_SuspectEvidence;
}
 
inline
bool CRs_Base::C_Create::C_Attlist::IsSetBuild(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Create::C_Attlist::CanGetBuild(void) const
{
    return IsSetBuild();
}
 
inline
void CRs_Base::C_Create::C_Attlist::ResetBuild(void)
{
    m_Build = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Create::C_Attlist::TBuild CRs_Base::C_Create::C_Attlist::GetBuild(void) const
{
    if (!CanGetBuild()) {
        ThrowUnassigned(0);
    }
    return m_Build;
}
 
inline
void CRs_Base::C_Create::C_Attlist::SetBuild(CRs_Base::C_Create::C_Attlist::TBuild value)
{
    m_Build = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Create::C_Attlist::TBuild& CRs_Base::C_Create::C_Attlist::SetBuild(void)
{
#ifdef _DEBUG
    if (!IsSetBuild()) {
        memset(&m_Build,UnassignedByte(),sizeof(m_Build));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Build;
}
 
inline
bool CRs_Base::C_Create::C_Attlist::IsSetDate(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Create::C_Attlist::CanGetDate(void) const
{
    return IsSetDate();
}
 
inline
const CRs_Base::C_Create::C_Attlist::TDate& CRs_Base::C_Create::C_Attlist::GetDate(void) const
{
    if (!CanGetDate()) {
        ThrowUnassigned(1);
    }
    return m_Date;
}
 
inline
void CRs_Base::C_Create::C_Attlist::SetDate(const CRs_Base::C_Create::C_Attlist::TDate& value)
{
    m_Date = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CRs_Base::C_Create::C_Attlist::SetDate(CRs_Base::C_Create::C_Attlist::TDate&& value)
{
    m_Date = std::forward<CRs_Base::C_Create::C_Attlist::TDate>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Create::C_Attlist::TDate& CRs_Base::C_Create::C_Attlist::SetDate(void)
{
#ifdef _DEBUG
    if (!IsSetDate()) {
        m_Date = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Date;
}
 
inline
bool CRs_Base::C_Create::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_Create::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Create::TAttlist& CRs_Base::C_Create::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_Create*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_Create::TAttlist& CRs_Base::C_Create::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_Create::IsSetCreate(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Create::CanGetCreate(void) const
{
    return false;
}
 
inline
void CRs_Base::C_Create::ResetCreate(void)
{
    m_set_State[0] &= ~0xc;
}
 
inline
void CRs_Base::C_Create::SetCreate(void)
{
    m_set_State[0] |= 0xc;
}
 
inline
bool CRs_Base::C_Update::C_Attlist::IsSetBuild(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Update::C_Attlist::CanGetBuild(void) const
{
    return IsSetBuild();
}
 
inline
void CRs_Base::C_Update::C_Attlist::ResetBuild(void)
{
    m_Build = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Update::C_Attlist::TBuild CRs_Base::C_Update::C_Attlist::GetBuild(void) const
{
    if (!CanGetBuild()) {
        ThrowUnassigned(0);
    }
    return m_Build;
}
 
inline
void CRs_Base::C_Update::C_Attlist::SetBuild(CRs_Base::C_Update::C_Attlist::TBuild value)
{
    m_Build = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Update::C_Attlist::TBuild& CRs_Base::C_Update::C_Attlist::SetBuild(void)
{
#ifdef _DEBUG
    if (!IsSetBuild()) {
        memset(&m_Build,UnassignedByte(),sizeof(m_Build));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Build;
}
 
inline
bool CRs_Base::C_Update::C_Attlist::IsSetDate(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Update::C_Attlist::CanGetDate(void) const
{
    return IsSetDate();
}
 
inline
const CRs_Base::C_Update::C_Attlist::TDate& CRs_Base::C_Update::C_Attlist::GetDate(void) const
{
    if (!CanGetDate()) {
        ThrowUnassigned(1);
    }
    return m_Date;
}
 
inline
void CRs_Base::C_Update::C_Attlist::SetDate(const CRs_Base::C_Update::C_Attlist::TDate& value)
{
    m_Date = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CRs_Base::C_Update::C_Attlist::SetDate(CRs_Base::C_Update::C_Attlist::TDate&& value)
{
    m_Date = std::forward<CRs_Base::C_Update::C_Attlist::TDate>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Update::C_Attlist::TDate& CRs_Base::C_Update::C_Attlist::SetDate(void)
{
#ifdef _DEBUG
    if (!IsSetDate()) {
        m_Date = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Date;
}
 
inline
bool CRs_Base::C_Update::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_Update::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Update::TAttlist& CRs_Base::C_Update::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_Update*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_Update::TAttlist& CRs_Base::C_Update::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_Update::IsSetUpdate(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Update::CanGetUpdate(void) const
{
    return false;
}
 
inline
void CRs_Base::C_Update::ResetUpdate(void)
{
    m_set_State[0] &= ~0xc;
}
 
inline
void CRs_Base::C_Update::SetUpdate(void)
{
    m_set_State[0] |= 0xc;
}
 
inline
bool CRs_Base::C_Sequence::C_Attlist::IsSetExemplarSs(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_Sequence::C_Attlist::CanGetExemplarSs(void) const
{
    return IsSetExemplarSs();
}
 
inline
void CRs_Base::C_Sequence::C_Attlist::ResetExemplarSs(void)
{
    m_ExemplarSs = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_Sequence::C_Attlist::TExemplarSs CRs_Base::C_Sequence::C_Attlist::GetExemplarSs(void) const
{
    if (!CanGetExemplarSs()) {
        ThrowUnassigned(0);
    }
    return m_ExemplarSs;
}
 
inline
void CRs_Base::C_Sequence::C_Attlist::SetExemplarSs(CRs_Base::C_Sequence::C_Attlist::TExemplarSs value)
{
    m_ExemplarSs = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_Sequence::C_Attlist::TExemplarSs& CRs_Base::C_Sequence::C_Attlist::SetExemplarSs(void)
{
#ifdef _DEBUG
    if (!IsSetExemplarSs()) {
        memset(&m_ExemplarSs,UnassignedByte(),sizeof(m_ExemplarSs));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_ExemplarSs;
}
 
inline
bool CRs_Base::C_Sequence::C_Attlist::IsSetAncestralAllele(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Sequence::C_Attlist::CanGetAncestralAllele(void) const
{
    return IsSetAncestralAllele();
}
 
inline
const CRs_Base::C_Sequence::C_Attlist::TAncestralAllele& CRs_Base::C_Sequence::C_Attlist::GetAncestralAllele(void) const
{
    if (!CanGetAncestralAllele()) {
        ThrowUnassigned(1);
    }
    return m_AncestralAllele;
}
 
inline
void CRs_Base::C_Sequence::C_Attlist::SetAncestralAllele(const CRs_Base::C_Sequence::C_Attlist::TAncestralAllele& value)
{
    m_AncestralAllele = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CRs_Base::C_Sequence::C_Attlist::SetAncestralAllele(CRs_Base::C_Sequence::C_Attlist::TAncestralAllele&& value)
{
    m_AncestralAllele = std::forward<CRs_Base::C_Sequence::C_Attlist::TAncestralAllele>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Sequence::C_Attlist::TAncestralAllele& CRs_Base::C_Sequence::C_Attlist::SetAncestralAllele(void)
{
#ifdef _DEBUG
    if (!IsSetAncestralAllele()) {
        m_AncestralAllele = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_AncestralAllele;
}
 
inline
bool CRs_Base::C_Sequence::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_Sequence::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_Sequence::TAttlist& CRs_Base::C_Sequence::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_Sequence*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_Sequence::TAttlist& CRs_Base::C_Sequence::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_Sequence::IsSetSeq5(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_Sequence::CanGetSeq5(void) const
{
    return IsSetSeq5();
}
 
inline
const CRs_Base::C_Sequence::TSeq5& CRs_Base::C_Sequence::GetSeq5(void) const
{
    if (!CanGetSeq5()) {
        ThrowUnassigned(1);
    }
    return m_Seq5;
}
 
inline
void CRs_Base::C_Sequence::SetSeq5(const CRs_Base::C_Sequence::TSeq5& value)
{
    m_Seq5 = value;
    m_set_State[0] |= 0xc;
}
 
inline
void CRs_Base::C_Sequence::SetSeq5(CRs_Base::C_Sequence::TSeq5&& value)
{
    m_Seq5 = std::forward<CRs_Base::C_Sequence::TSeq5>(value);
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_Sequence::TSeq5& CRs_Base::C_Sequence::SetSeq5(void)
{
#ifdef _DEBUG
    if (!IsSetSeq5()) {
        m_Seq5 = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Seq5;
}
 
inline
bool CRs_Base::C_Sequence::IsSetObserved(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_Sequence::CanGetObserved(void) const
{
    return IsSetObserved();
}
 
inline
const CRs_Base::C_Sequence::TObserved& CRs_Base::C_Sequence::GetObserved(void) const
{
    if (!CanGetObserved()) {
        ThrowUnassigned(2);
    }
    return m_Observed;
}
 
inline
void CRs_Base::C_Sequence::SetObserved(const CRs_Base::C_Sequence::TObserved& value)
{
    m_Observed = value;
    m_set_State[0] |= 0x30;
}
 
inline
void CRs_Base::C_Sequence::SetObserved(CRs_Base::C_Sequence::TObserved&& value)
{
    m_Observed = std::forward<CRs_Base::C_Sequence::TObserved>(value);
    m_set_State[0] |= 0x30;
}
 
inline
CRs_Base::C_Sequence::TObserved& CRs_Base::C_Sequence::SetObserved(void)
{
#ifdef _DEBUG
    if (!IsSetObserved()) {
        m_Observed = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Observed;
}
 
inline
bool CRs_Base::C_Sequence::IsSetSeq3(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CRs_Base::C_Sequence::CanGetSeq3(void) const
{
    return IsSetSeq3();
}
 
inline
const CRs_Base::C_Sequence::TSeq3& CRs_Base::C_Sequence::GetSeq3(void) const
{
    if (!CanGetSeq3()) {
        ThrowUnassigned(3);
    }
    return m_Seq3;
}
 
inline
void CRs_Base::C_Sequence::SetSeq3(const CRs_Base::C_Sequence::TSeq3& value)
{
    m_Seq3 = value;
    m_set_State[0] |= 0xc0;
}
 
inline
void CRs_Base::C_Sequence::SetSeq3(CRs_Base::C_Sequence::TSeq3&& value)
{
    m_Seq3 = std::forward<CRs_Base::C_Sequence::TSeq3>(value);
    m_set_State[0] |= 0xc0;
}
 
inline
CRs_Base::C_Sequence::TSeq3& CRs_Base::C_Sequence::SetSeq3(void)
{
#ifdef _DEBUG
    if (!IsSetSeq3()) {
        m_Seq3 = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x40;
    return m_Seq3;
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::IsSetRsId(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::CanGetRsId(void) const
{
    return IsSetRsId();
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::ResetRsId(void)
{
    m_RsId = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TRsId CRs_Base::C_E_MergeHistory::C_Attlist::GetRsId(void) const
{
    if (!CanGetRsId()) {
        ThrowUnassigned(0);
    }
    return m_RsId;
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::SetRsId(CRs_Base::C_E_MergeHistory::C_Attlist::TRsId value)
{
    m_RsId = value;
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TRsId& CRs_Base::C_E_MergeHistory::C_Attlist::SetRsId(void)
{
#ifdef _DEBUG
    if (!IsSetRsId()) {
        memset(&m_RsId,UnassignedByte(),sizeof(m_RsId));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_RsId;
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::IsSetBuildId(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::CanGetBuildId(void) const
{
    return IsSetBuildId();
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::ResetBuildId(void)
{
    m_BuildId = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TBuildId CRs_Base::C_E_MergeHistory::C_Attlist::GetBuildId(void) const
{
    if (!CanGetBuildId()) {
        ThrowUnassigned(1);
    }
    return m_BuildId;
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::SetBuildId(CRs_Base::C_E_MergeHistory::C_Attlist::TBuildId value)
{
    m_BuildId = value;
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TBuildId& CRs_Base::C_E_MergeHistory::C_Attlist::SetBuildId(void)
{
#ifdef _DEBUG
    if (!IsSetBuildId()) {
        memset(&m_BuildId,UnassignedByte(),sizeof(m_BuildId));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_BuildId;
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::IsSetOrientFlip(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CRs_Base::C_E_MergeHistory::C_Attlist::CanGetOrientFlip(void) const
{
    return IsSetOrientFlip();
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::ResetOrientFlip(void)
{
    m_OrientFlip = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TOrientFlip CRs_Base::C_E_MergeHistory::C_Attlist::GetOrientFlip(void) const
{
    if (!CanGetOrientFlip()) {
        ThrowUnassigned(2);
    }
    return m_OrientFlip;
}
 
inline
void CRs_Base::C_E_MergeHistory::C_Attlist::SetOrientFlip(CRs_Base::C_E_MergeHistory::C_Attlist::TOrientFlip value)
{
    m_OrientFlip = value;
    m_set_State[0] |= 0x30;
}
 
inline
CRs_Base::C_E_MergeHistory::C_Attlist::TOrientFlip& CRs_Base::C_E_MergeHistory::C_Attlist::SetOrientFlip(void)
{
#ifdef _DEBUG
    if (!IsSetOrientFlip()) {
        memset(&m_OrientFlip,UnassignedByte(),sizeof(m_OrientFlip));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_OrientFlip;
}
 
inline
bool CRs_Base::C_E_MergeHistory::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_E_MergeHistory::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_E_MergeHistory::TAttlist& CRs_Base::C_E_MergeHistory::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_E_MergeHistory*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_E_MergeHistory::TAttlist& CRs_Base::C_E_MergeHistory::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_E_MergeHistory::IsSetMergeHistory(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_E_MergeHistory::CanGetMergeHistory(void) const
{
    return false;
}
 
inline
void CRs_Base::C_E_MergeHistory::ResetMergeHistory(void)
{
    m_set_State[0] &= ~0xc;
}
 
inline
void CRs_Base::C_E_MergeHistory::SetMergeHistory(void)
{
    m_set_State[0] |= 0xc;
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::C_Attlist::IsSetAllele(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::C_Attlist::CanGetAllele(void) const
{
    return IsSetAllele();
}
 
inline
const CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele& CRs_Base::C_E_AlleleOrigin::C_Attlist::GetAllele(void) const
{
    if (!CanGetAllele()) {
        ThrowUnassigned(0);
    }
    return m_Allele;
}
 
inline
void CRs_Base::C_E_AlleleOrigin::C_Attlist::SetAllele(const CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele& value)
{
    m_Allele = value;
    m_set_State[0] |= 0x3;
}
 
inline
void CRs_Base::C_E_AlleleOrigin::C_Attlist::SetAllele(CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele&& value)
{
    m_Allele = std::forward<CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele>(value);
    m_set_State[0] |= 0x3;
}
 
inline
CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele& CRs_Base::C_E_AlleleOrigin::C_Attlist::SetAllele(void)
{
#ifdef _DEBUG
    if (!IsSetAllele()) {
        m_Allele = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Allele;
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CRs_Base::C_E_AlleleOrigin::TAttlist& CRs_Base::C_E_AlleleOrigin::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<C_E_AlleleOrigin*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CRs_Base::C_E_AlleleOrigin::TAttlist& CRs_Base::C_E_AlleleOrigin::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::IsSetAlleleOrigin(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CRs_Base::C_E_AlleleOrigin::CanGetAlleleOrigin(void) const
{
    return IsSetAlleleOrigin();
}
 
inline
void CRs_Base::C_E_AlleleOrigin::ResetAlleleOrigin(void)
{
    m_AlleleOrigin = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CRs_Base::C_E_AlleleOrigin::TAlleleOrigin CRs_Base::C_E_AlleleOrigin::GetAlleleOrigin(void) const
{
    if (!CanGetAlleleOrigin()) {
        ThrowUnassigned(1);
    }
    return m_AlleleOrigin;
}
 
inline
void CRs_Base::C_E_AlleleOrigin::SetAlleleOrigin(CRs_Base::C_E_AlleleOrigin::TAlleleOrigin value)
{
    m_AlleleOrigin = value;
    m_set_State[0] |= 0xc;
}
 
inline
CRs_Base::C_E_AlleleOrigin::TAlleleOrigin& CRs_Base::C_E_AlleleOrigin::SetAlleleOrigin(void)
{
#ifdef _DEBUG
    if (!IsSetAlleleOrigin()) {
        memset(&m_AlleleOrigin,UnassignedByte(),sizeof(m_AlleleOrigin));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_AlleleOrigin;
}
 
inline
bool CRs_Base::C_E_Phenotype::IsSetClinicalSignificance(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CRs_Base::C_E_Phenotype::CanGetClinicalSignificance(void) const
{
    return true;
}
 
inline
const CRs_Base::C_E_Phenotype::TClinicalSignificance& CRs_Base::C_E_Phenotype::GetClinicalSignificance(void) const
{
    return m_ClinicalSignificance;
}
 
inline
CRs_Base::C_E_Phenotype::TClinicalSignificance& CRs_Base::C_E_Phenotype::SetClinicalSignificance(void)
{
    m_set_State[0] |= 0x1;
    return m_ClinicalSignificance;
}
 
inline