MapLoc_.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 MapLoc_.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_MAPLOC_BASE_HPP
#define OBJECTS_DOCSUM_MAPLOC_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 CFxnSet;
 
 
// generated classes
 
 
/** @addtogroup dataspec_Docsum_3_4
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///Position of a single hit of a variation on a
///             contig
///
/// CMapLoc_Base --
///
 
class NCBI_DOCSUM_EXPORT CMapLoc_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CMapLoc_Base(void);
    // destructor
    virtual ~CMapLoc_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();
    
        ///defines the seq-loc symbol if asn_from !=
        ///                     asn_to
        enum EAttlist_locType {
            eAttlist_locType_insertion   = 1,
            eAttlist_locType_exact       = 2,
            eAttlist_locType_deletion    = 3,
            eAttlist_locType_range_ins   = 4,
            eAttlist_locType_range_exact = 5,
            eAttlist_locType_range_del   = 6
        };
        
        /// Access to EAttlist_locType's attributes (values, names) as defined in spec
        static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_locType)(void);
        
        ///orientation of refSNP sequence to contig
        ///                     sequence
        enum EAttlist_orient {
            eAttlist_orient_forward = 1,
            eAttlist_orient_reverse = 2
        };
        
        /// Access to EAttlist_orient's attributes (values, names) as defined in spec
        static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_orient)(void);
        
        // types
        typedef int TAsnFrom;
        typedef int TAsnTo;
        typedef EAttlist_locType TLocType;
        typedef double TAlnQuality;
        typedef EAttlist_orient TOrient;
        typedef int TPhysMapInt;
        typedef int TLeftFlankNeighborPos;
        typedef int TRightFlankNeighborPos;
        typedef int TLeftContigNeighborPos;
        typedef int TRightContigNeighborPos;
        typedef int TNumberOfMismatches;
        typedef int TNumberOfDeletions;
        typedef int TNumberOfInsertions;
        typedef string TRefAllele;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_asnFrom,
            e_asnTo,
            e_locType,
            e_alnQuality,
            e_orient,
            e_physMapInt,
            e_leftFlankNeighborPos,
            e_rightFlankNeighborPos,
            e_leftContigNeighborPos,
            e_rightContigNeighborPos,
            e_numberOfMismatches,
            e_numberOfDeletions,
            e_numberOfInsertions,
            e_refAllele
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 15> TmemberIndex;
    
        // getters
        // setters
    
        ///beginning of variation as feature on
        ///                     contig
        /// Check if a value has been assigned to AsnFrom data member.
        ///
        /// Data member AsnFrom is mandatory;
        /// its type is defined as 'typedef int TAsnFrom'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAsnFrom(void) const;
    
        /// Check if it is safe to call GetAsnFrom method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAsnFrom(void) const;
    
        /// Reset AsnFrom data member.
        void ResetAsnFrom(void);
    
        /// Get the AsnFrom member data.
        ///
        /// @return
        ///   Copy of the member data.
        TAsnFrom GetAsnFrom(void) const;
    
        /// Assign a value to AsnFrom data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAsnFrom(TAsnFrom value);
    
        /// Assign a value to AsnFrom data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAsnFrom& SetAsnFrom(void);
    
        ///end position of variation as feature on
        ///                     contig
        /// Check if a value has been assigned to AsnTo data member.
        ///
        /// Data member AsnTo is mandatory;
        /// its type is defined as 'typedef int TAsnTo'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAsnTo(void) const;
    
        /// Check if it is safe to call GetAsnTo method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAsnTo(void) const;
    
        /// Reset AsnTo data member.
        void ResetAsnTo(void);
    
        /// Get the AsnTo member data.
        ///
        /// @return
        ///   Copy of the member data.
        TAsnTo GetAsnTo(void) const;
    
        /// Assign a value to AsnTo data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAsnTo(TAsnTo value);
    
        /// Assign a value to AsnTo data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAsnTo& SetAsnTo(void);
    
        /// Check if a value has been assigned to LocType data member.
        ///
        /// Data member LocType is mandatory;
        /// its type is defined as 'typedef EAttlist_locType TLocType'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetLocType(void) const;
    
        /// Check if it is safe to call GetLocType method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetLocType(void) const;
    
        /// Reset LocType data member.
        void ResetLocType(void);
    
        /// Get the LocType member data.
        ///
        /// @return
        ///   Copy of the member data.
        TLocType GetLocType(void) const;
    
        /// Assign a value to LocType data member.
        ///
        /// @param value
        ///   Value to assign
        void SetLocType(TLocType value);
    
        /// Assign a value to LocType data member.
        ///
        /// @return
        ///   Reference to the data value.
        TLocType& SetLocType(void);
    
        ///alignment qualiity
        /// Check if a value has been assigned to AlnQuality data member.
        ///
        /// Data member AlnQuality is optional;
        /// its type is defined as 'typedef double TAlnQuality'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetAlnQuality(void) const;
    
        /// Check if it is safe to call GetAlnQuality method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetAlnQuality(void) const;
    
        /// Reset AlnQuality data member.
        void ResetAlnQuality(void);
    
        /// Get the AlnQuality member data.
        ///
        /// @return
        ///   Copy of the member data.
        TAlnQuality GetAlnQuality(void) const;
    
        /// Assign a value to AlnQuality data member.
        ///
        /// @param value
        ///   Value to assign
        void SetAlnQuality(TAlnQuality value);
    
        /// Assign a value to AlnQuality data member.
        ///
        /// @return
        ///   Reference to the data value.
        TAlnQuality& SetAlnQuality(void);
    
        /// Check if a value has been assigned to Orient data member.
        ///
        /// Data member Orient is optional;
        /// its type is defined as 'typedef EAttlist_orient TOrient'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetOrient(void) const;
    
        /// Check if it is safe to call GetOrient method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetOrient(void) const;
    
        /// Reset Orient data member.
        void ResetOrient(void);
    
        /// Get the Orient member data.
        ///
        /// @return
        ///   Copy of the member data.
        TOrient GetOrient(void) const;
    
        /// Assign a value to Orient data member.
        ///
        /// @param value
        ///   Value to assign
        void SetOrient(TOrient value);
    
        /// Assign a value to Orient data member.
        ///
        /// @return
        ///   Reference to the data value.
        TOrient& SetOrient(void);
    
        ///chromosome position as integer for
        ///                     sorting
        /// Check if a value has been assigned to PhysMapInt data member.
        ///
        /// Data member PhysMapInt is optional;
        /// its type is defined as 'typedef int TPhysMapInt'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetPhysMapInt(void) const;
    
        /// Check if it is safe to call GetPhysMapInt method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetPhysMapInt(void) const;
    
        /// Reset PhysMapInt data member.
        void ResetPhysMapInt(void);
    
        /// Get the PhysMapInt member data.
        ///
        /// @return
        ///   Copy of the member data.
        TPhysMapInt GetPhysMapInt(void) const;
    
        /// Assign a value to PhysMapInt data member.
        ///
        /// @param value
        ///   Value to assign
        void SetPhysMapInt(TPhysMapInt value);
    
        /// Assign a value to PhysMapInt data member.
        ///
        /// @return
        ///   Reference to the data value.
        TPhysMapInt& SetPhysMapInt(void);
    
        ///nearest aligned position in 5' flanking sequence of
        ///                     snp
        /// Check if a value has been assigned to LeftFlankNeighborPos data member.
        ///
        /// Data member LeftFlankNeighborPos is optional;
        /// its type is defined as 'typedef int TLeftFlankNeighborPos'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetLeftFlankNeighborPos(void) const;
    
        /// Check if it is safe to call GetLeftFlankNeighborPos method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetLeftFlankNeighborPos(void) const;
    
        /// Reset LeftFlankNeighborPos data member.
        void ResetLeftFlankNeighborPos(void);
    
        /// Get the LeftFlankNeighborPos member data.
        ///
        /// @return
        ///   Copy of the member data.
        TLeftFlankNeighborPos GetLeftFlankNeighborPos(void) const;
    
        /// Assign a value to LeftFlankNeighborPos data member.
        ///
        /// @param value
        ///   Value to assign
        void SetLeftFlankNeighborPos(TLeftFlankNeighborPos value);
    
        /// Assign a value to LeftFlankNeighborPos data member.
        ///
        /// @return
        ///   Reference to the data value.
        TLeftFlankNeighborPos& SetLeftFlankNeighborPos(void);
    
        ///nearest aligned position in 3' flanking sequence of snp
        /// Check if a value has been assigned to RightFlankNeighborPos data member.
        ///
        /// Data member RightFlankNeighborPos is optional;
        /// its type is defined as 'typedef int TRightFlankNeighborPos'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetRightFlankNeighborPos(void) const;
    
        /// Check if it is safe to call GetRightFlankNeighborPos method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetRightFlankNeighborPos(void) const;
    
        /// Reset RightFlankNeighborPos data member.
        void ResetRightFlankNeighborPos(void);
    
        /// Get the RightFlankNeighborPos member data.
        ///
        /// @return
        ///   Copy of the member data.
        TRightFlankNeighborPos GetRightFlankNeighborPos(void) const;
    
        /// Assign a value to RightFlankNeighborPos data member.
        ///
        /// @param value
        ///   Value to assign
        void SetRightFlankNeighborPos(TRightFlankNeighborPos value);
    
        /// Assign a value to RightFlankNeighborPos data member.
        ///
        /// @return
        ///   Reference to the data value.
        TRightFlankNeighborPos& SetRightFlankNeighborPos(void);
    
        ///nearest aligned position in 5' contig alignment of
        ///                     snp
        /// Check if a value has been assigned to LeftContigNeighborPos data member.
        ///
        /// Data member LeftContigNeighborPos is optional;
        /// its type is defined as 'typedef int TLeftContigNeighborPos'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetLeftContigNeighborPos(void) const;
    
        /// Check if it is safe to call GetLeftContigNeighborPos method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetLeftContigNeighborPos(void) const;
    
        /// Reset LeftContigNeighborPos data member.
        void ResetLeftContigNeighborPos(void);
    
        /// Get the LeftContigNeighborPos member data.
        ///
        /// @return
        ///   Copy of the member data.
        TLeftContigNeighborPos GetLeftContigNeighborPos(void) const;
    
        /// Assign a value to LeftContigNeighborPos data member.
        ///
        /// @param value
        ///   Value to assign
        void SetLeftContigNeighborPos(TLeftContigNeighborPos value);
    
        /// Assign a value to LeftContigNeighborPos data member.
        ///
        /// @return
        ///   Reference to the data value.
        TLeftContigNeighborPos& SetLeftContigNeighborPos(void);
    
        ///nearest aligned position in 3' contig alignment of
        ///                     snp
        /// Check if a value has been assigned to RightContigNeighborPos data member.
        ///
        /// Data member RightContigNeighborPos is optional;
        /// its type is defined as 'typedef int TRightContigNeighborPos'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetRightContigNeighborPos(void) const;
    
        /// Check if it is safe to call GetRightContigNeighborPos method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetRightContigNeighborPos(void) const;
    
        /// Reset RightContigNeighborPos data member.
        void ResetRightContigNeighborPos(void);
    
        /// Get the RightContigNeighborPos member data.
        ///
        /// @return
        ///   Copy of the member data.
        TRightContigNeighborPos GetRightContigNeighborPos(void) const;
    
        /// Assign a value to RightContigNeighborPos data member.
        ///
        /// @param value
        ///   Value to assign
        void SetRightContigNeighborPos(TRightContigNeighborPos value);
    
        /// Assign a value to RightContigNeighborPos data member.
        ///
        /// @return
        ///   Reference to the data value.
        TRightContigNeighborPos& SetRightContigNeighborPos(void);
    
        ///number of Mismatched positions in this
        ///                     alignment
        /// Check if a value has been assigned to NumberOfMismatches data member.
        ///
        /// Data member NumberOfMismatches is optional;
        /// its type is defined as 'typedef int TNumberOfMismatches'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetNumberOfMismatches(void) const;
    
        /// Check if it is safe to call GetNumberOfMismatches method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetNumberOfMismatches(void) const;
    
        /// Reset NumberOfMismatches data member.
        void ResetNumberOfMismatches(void);
    
        /// Get the NumberOfMismatches member data.
        ///
        /// @return
        ///   Copy of the member data.
        TNumberOfMismatches GetNumberOfMismatches(void) const;
    
        /// Assign a value to NumberOfMismatches data member.
        ///
        /// @param value
        ///   Value to assign
        void SetNumberOfMismatches(TNumberOfMismatches value);
    
        /// Assign a value to NumberOfMismatches data member.
        ///
        /// @return
        ///   Reference to the data value.
        TNumberOfMismatches& SetNumberOfMismatches(void);
    
        ///number of deletions in this alignment
        /// Check if a value has been assigned to NumberOfDeletions data member.
        ///
        /// Data member NumberOfDeletions is optional;
        /// its type is defined as 'typedef int TNumberOfDeletions'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetNumberOfDeletions(void) const;
    
        /// Check if it is safe to call GetNumberOfDeletions method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetNumberOfDeletions(void) const;
    
        /// Reset NumberOfDeletions data member.
        void ResetNumberOfDeletions(void);
    
        /// Get the NumberOfDeletions member data.
        ///
        /// @return
        ///   Copy of the member data.
        TNumberOfDeletions GetNumberOfDeletions(void) const;
    
        /// Assign a value to NumberOfDeletions data member.
        ///
        /// @param value
        ///   Value to assign
        void SetNumberOfDeletions(TNumberOfDeletions value);
    
        /// Assign a value to NumberOfDeletions data member.
        ///
        /// @return
        ///   Reference to the data value.
        TNumberOfDeletions& SetNumberOfDeletions(void);
    
        ///number of insetions in this alignment
        /// Check if a value has been assigned to NumberOfInsertions data member.
        ///
        /// Data member NumberOfInsertions is optional;
        /// its type is defined as 'typedef int TNumberOfInsertions'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetNumberOfInsertions(void) const;
    
        /// Check if it is safe to call GetNumberOfInsertions method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetNumberOfInsertions(void) const;
    
        /// Reset NumberOfInsertions data member.
        void ResetNumberOfInsertions(void);
    
        /// Get the NumberOfInsertions member data.
        ///
        /// @return
        ///   Copy of the member data.
        TNumberOfInsertions GetNumberOfInsertions(void) const;
    
        /// Assign a value to NumberOfInsertions data member.
        ///
        /// @param value
        ///   Value to assign
        void SetNumberOfInsertions(TNumberOfInsertions value);
    
        /// Assign a value to NumberOfInsertions data member.
        ///
        /// @return
        ///   Reference to the data value.
        TNumberOfInsertions& SetNumberOfInsertions(void);
    
        /// Check if a value has been assigned to RefAllele data member.
        ///
        /// Data member RefAllele is optional;
        /// its type is defined as 'typedef string TRefAllele'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetRefAllele(void) const;
    
        /// Check if it is safe to call GetRefAllele method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetRefAllele(void) const;
    
        /// Reset RefAllele data member.
        void ResetRefAllele(void);
    
        /// Get the RefAllele member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TRefAllele& GetRefAllele(void) const;
    
        /// Assign a value to RefAllele data member.
        ///
        /// @param value
        ///   Value to assign
        void SetRefAllele(const TRefAllele& value);
        void SetRefAllele(TRefAllele&& value);
    
        /// Assign a value to RefAllele data member.
        ///
        /// @return
        ///   Reference to the data value.
        TRefAllele& SetRefAllele(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_AsnFrom;
        int m_AsnTo;
        EAttlist_locType m_LocType;
        double m_AlnQuality;
        EAttlist_orient m_Orient;
        int m_PhysMapInt;
        int m_LeftFlankNeighborPos;
        int m_RightFlankNeighborPos;
        int m_LeftContigNeighborPos;
        int m_RightContigNeighborPos;
        int m_NumberOfMismatches;
        int m_NumberOfDeletions;
        int m_NumberOfInsertions;
        string m_RefAllele;
    };
    // types
    typedef C_Attlist TAttlist;
    typedef list< CRef< CFxnSet > > TFxnSet;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_attlist,
        e_fxnSet
    };
    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 FxnSet data member.
    ///
    /// Data member FxnSet is optional;
    /// its type is defined as 'typedef list< CRef< CFxnSet > > TFxnSet'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetFxnSet(void) const;
 
    /// Check if it is safe to call GetFxnSet method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetFxnSet(void) const;
 
    /// Reset FxnSet data member.
    void ResetFxnSet(void);
 
    /// Get the FxnSet member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TFxnSet& GetFxnSet(void) const;
 
    /// Assign a value to FxnSet data member.
    ///
    /// @return
    ///   Reference to the data value.
    TFxnSet& SetFxnSet(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CMapLoc_Base(const CMapLoc_Base&);
    CMapLoc_Base& operator=(const CMapLoc_Base&);
 
    // data
    Uint4 m_set_State[1];
    CRef< TAttlist > m_Attlist;
    list< CRef< CFxnSet > > m_FxnSet;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CMapLoc_Base::C_Attlist::IsSetAsnFrom(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetAsnFrom(void) const
{
    return IsSetAsnFrom();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetAsnFrom(void)
{
    m_AsnFrom = 0;
    m_set_State[0] &= ~0x3;
}
 
inline
CMapLoc_Base::C_Attlist::TAsnFrom CMapLoc_Base::C_Attlist::GetAsnFrom(void) const
{
    if (!CanGetAsnFrom()) {
        ThrowUnassigned(0);
    }
    return m_AsnFrom;
}
 
inline
void CMapLoc_Base::C_Attlist::SetAsnFrom(CMapLoc_Base::C_Attlist::TAsnFrom value)
{
    m_AsnFrom = value;
    m_set_State[0] |= 0x3;
}
 
inline
CMapLoc_Base::C_Attlist::TAsnFrom& CMapLoc_Base::C_Attlist::SetAsnFrom(void)
{
#ifdef _DEBUG
    if (!IsSetAsnFrom()) {
        memset(&m_AsnFrom,UnassignedByte(),sizeof(m_AsnFrom));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_AsnFrom;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetAsnTo(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetAsnTo(void) const
{
    return IsSetAsnTo();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetAsnTo(void)
{
    m_AsnTo = 0;
    m_set_State[0] &= ~0xc;
}
 
inline
CMapLoc_Base::C_Attlist::TAsnTo CMapLoc_Base::C_Attlist::GetAsnTo(void) const
{
    if (!CanGetAsnTo()) {
        ThrowUnassigned(1);
    }
    return m_AsnTo;
}
 
inline
void CMapLoc_Base::C_Attlist::SetAsnTo(CMapLoc_Base::C_Attlist::TAsnTo value)
{
    m_AsnTo = value;
    m_set_State[0] |= 0xc;
}
 
inline
CMapLoc_Base::C_Attlist::TAsnTo& CMapLoc_Base::C_Attlist::SetAsnTo(void)
{
#ifdef _DEBUG
    if (!IsSetAsnTo()) {
        memset(&m_AsnTo,UnassignedByte(),sizeof(m_AsnTo));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_AsnTo;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetLocType(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetLocType(void) const
{
    return IsSetLocType();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetLocType(void)
{
    m_LocType = (EAttlist_locType)(0);
    m_set_State[0] &= ~0x30;
}
 
inline
CMapLoc_Base::C_Attlist::TLocType CMapLoc_Base::C_Attlist::GetLocType(void) const
{
    if (!CanGetLocType()) {
        ThrowUnassigned(2);
    }
    return m_LocType;
}
 
inline
void CMapLoc_Base::C_Attlist::SetLocType(CMapLoc_Base::C_Attlist::TLocType value)
{
    m_LocType = value;
    m_set_State[0] |= 0x30;
}
 
inline
CMapLoc_Base::C_Attlist::TLocType& CMapLoc_Base::C_Attlist::SetLocType(void)
{
#ifdef _DEBUG
    if (!IsSetLocType()) {
        memset(&m_LocType,UnassignedByte(),sizeof(m_LocType));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_LocType;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetAlnQuality(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetAlnQuality(void) const
{
    return IsSetAlnQuality();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetAlnQuality(void)
{
    m_AlnQuality = 0;
    m_set_State[0] &= ~0xc0;
}
 
inline
CMapLoc_Base::C_Attlist::TAlnQuality CMapLoc_Base::C_Attlist::GetAlnQuality(void) const
{
    if (!CanGetAlnQuality()) {
        ThrowUnassigned(3);
    }
    return m_AlnQuality;
}
 
inline
void CMapLoc_Base::C_Attlist::SetAlnQuality(CMapLoc_Base::C_Attlist::TAlnQuality value)
{
    m_AlnQuality = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CMapLoc_Base::C_Attlist::TAlnQuality& CMapLoc_Base::C_Attlist::SetAlnQuality(void)
{
#ifdef _DEBUG
    if (!IsSetAlnQuality()) {
        memset(&m_AlnQuality,UnassignedByte(),sizeof(m_AlnQuality));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_AlnQuality;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetOrient(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetOrient(void) const
{
    return IsSetOrient();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetOrient(void)
{
    m_Orient = (EAttlist_orient)(0);
    m_set_State[0] &= ~0x300;
}
 
inline
CMapLoc_Base::C_Attlist::TOrient CMapLoc_Base::C_Attlist::GetOrient(void) const
{
    if (!CanGetOrient()) {
        ThrowUnassigned(4);
    }
    return m_Orient;
}
 
inline
void CMapLoc_Base::C_Attlist::SetOrient(CMapLoc_Base::C_Attlist::TOrient value)
{
    m_Orient = value;
    m_set_State[0] |= 0x300;
}
 
inline
CMapLoc_Base::C_Attlist::TOrient& CMapLoc_Base::C_Attlist::SetOrient(void)
{
#ifdef _DEBUG
    if (!IsSetOrient()) {
        memset(&m_Orient,UnassignedByte(),sizeof(m_Orient));
    }
#endif
    m_set_State[0] |= 0x100;
    return m_Orient;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetPhysMapInt(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetPhysMapInt(void) const
{
    return IsSetPhysMapInt();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetPhysMapInt(void)
{
    m_PhysMapInt = 0;
    m_set_State[0] &= ~0xc00;
}
 
inline
CMapLoc_Base::C_Attlist::TPhysMapInt CMapLoc_Base::C_Attlist::GetPhysMapInt(void) const
{
    if (!CanGetPhysMapInt()) {
        ThrowUnassigned(5);
    }
    return m_PhysMapInt;
}
 
inline
void CMapLoc_Base::C_Attlist::SetPhysMapInt(CMapLoc_Base::C_Attlist::TPhysMapInt value)
{
    m_PhysMapInt = value;
    m_set_State[0] |= 0xc00;
}
 
inline
CMapLoc_Base::C_Attlist::TPhysMapInt& CMapLoc_Base::C_Attlist::SetPhysMapInt(void)
{
#ifdef _DEBUG
    if (!IsSetPhysMapInt()) {
        memset(&m_PhysMapInt,UnassignedByte(),sizeof(m_PhysMapInt));
    }
#endif
    m_set_State[0] |= 0x400;
    return m_PhysMapInt;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetLeftFlankNeighborPos(void) const
{
    return ((m_set_State[0] & 0x3000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetLeftFlankNeighborPos(void) const
{
    return IsSetLeftFlankNeighborPos();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetLeftFlankNeighborPos(void)
{
    m_LeftFlankNeighborPos = 0;
    m_set_State[0] &= ~0x3000;
}
 
inline
CMapLoc_Base::C_Attlist::TLeftFlankNeighborPos CMapLoc_Base::C_Attlist::GetLeftFlankNeighborPos(void) const
{
    if (!CanGetLeftFlankNeighborPos()) {
        ThrowUnassigned(6);
    }
    return m_LeftFlankNeighborPos;
}
 
inline
void CMapLoc_Base::C_Attlist::SetLeftFlankNeighborPos(CMapLoc_Base::C_Attlist::TLeftFlankNeighborPos value)
{
    m_LeftFlankNeighborPos = value;
    m_set_State[0] |= 0x3000;
}
 
inline
CMapLoc_Base::C_Attlist::TLeftFlankNeighborPos& CMapLoc_Base::C_Attlist::SetLeftFlankNeighborPos(void)
{
#ifdef _DEBUG
    if (!IsSetLeftFlankNeighborPos()) {
        memset(&m_LeftFlankNeighborPos,UnassignedByte(),sizeof(m_LeftFlankNeighborPos));
    }
#endif
    m_set_State[0] |= 0x1000;
    return m_LeftFlankNeighborPos;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetRightFlankNeighborPos(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetRightFlankNeighborPos(void) const
{
    return IsSetRightFlankNeighborPos();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetRightFlankNeighborPos(void)
{
    m_RightFlankNeighborPos = 0;
    m_set_State[0] &= ~0xc000;
}
 
inline
CMapLoc_Base::C_Attlist::TRightFlankNeighborPos CMapLoc_Base::C_Attlist::GetRightFlankNeighborPos(void) const
{
    if (!CanGetRightFlankNeighborPos()) {
        ThrowUnassigned(7);
    }
    return m_RightFlankNeighborPos;
}
 
inline
void CMapLoc_Base::C_Attlist::SetRightFlankNeighborPos(CMapLoc_Base::C_Attlist::TRightFlankNeighborPos value)
{
    m_RightFlankNeighborPos = value;
    m_set_State[0] |= 0xc000;
}
 
inline
CMapLoc_Base::C_Attlist::TRightFlankNeighborPos& CMapLoc_Base::C_Attlist::SetRightFlankNeighborPos(void)
{
#ifdef _DEBUG
    if (!IsSetRightFlankNeighborPos()) {
        memset(&m_RightFlankNeighborPos,UnassignedByte(),sizeof(m_RightFlankNeighborPos));
    }
#endif
    m_set_State[0] |= 0x4000;
    return m_RightFlankNeighborPos;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetLeftContigNeighborPos(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetLeftContigNeighborPos(void) const
{
    return IsSetLeftContigNeighborPos();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetLeftContigNeighborPos(void)
{
    m_LeftContigNeighborPos = 0;
    m_set_State[0] &= ~0x30000;
}
 
inline
CMapLoc_Base::C_Attlist::TLeftContigNeighborPos CMapLoc_Base::C_Attlist::GetLeftContigNeighborPos(void) const
{
    if (!CanGetLeftContigNeighborPos()) {
        ThrowUnassigned(8);
    }
    return m_LeftContigNeighborPos;
}
 
inline
void CMapLoc_Base::C_Attlist::SetLeftContigNeighborPos(CMapLoc_Base::C_Attlist::TLeftContigNeighborPos value)
{
    m_LeftContigNeighborPos = value;
    m_set_State[0] |= 0x30000;
}
 
inline
CMapLoc_Base::C_Attlist::TLeftContigNeighborPos& CMapLoc_Base::C_Attlist::SetLeftContigNeighborPos(void)
{
#ifdef _DEBUG
    if (!IsSetLeftContigNeighborPos()) {
        memset(&m_LeftContigNeighborPos,UnassignedByte(),sizeof(m_LeftContigNeighborPos));
    }
#endif
    m_set_State[0] |= 0x10000;
    return m_LeftContigNeighborPos;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetRightContigNeighborPos(void) const
{
    return ((m_set_State[0] & 0xc0000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetRightContigNeighborPos(void) const
{
    return IsSetRightContigNeighborPos();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetRightContigNeighborPos(void)
{
    m_RightContigNeighborPos = 0;
    m_set_State[0] &= ~0xc0000;
}
 
inline
CMapLoc_Base::C_Attlist::TRightContigNeighborPos CMapLoc_Base::C_Attlist::GetRightContigNeighborPos(void) const
{
    if (!CanGetRightContigNeighborPos()) {
        ThrowUnassigned(9);
    }
    return m_RightContigNeighborPos;
}
 
inline
void CMapLoc_Base::C_Attlist::SetRightContigNeighborPos(CMapLoc_Base::C_Attlist::TRightContigNeighborPos value)
{
    m_RightContigNeighborPos = value;
    m_set_State[0] |= 0xc0000;
}
 
inline
CMapLoc_Base::C_Attlist::TRightContigNeighborPos& CMapLoc_Base::C_Attlist::SetRightContigNeighborPos(void)
{
#ifdef _DEBUG
    if (!IsSetRightContigNeighborPos()) {
        memset(&m_RightContigNeighborPos,UnassignedByte(),sizeof(m_RightContigNeighborPos));
    }
#endif
    m_set_State[0] |= 0x40000;
    return m_RightContigNeighborPos;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetNumberOfMismatches(void) const
{
    return ((m_set_State[0] & 0x300000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetNumberOfMismatches(void) const
{
    return IsSetNumberOfMismatches();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetNumberOfMismatches(void)
{
    m_NumberOfMismatches = 0;
    m_set_State[0] &= ~0x300000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfMismatches CMapLoc_Base::C_Attlist::GetNumberOfMismatches(void) const
{
    if (!CanGetNumberOfMismatches()) {
        ThrowUnassigned(10);
    }
    return m_NumberOfMismatches;
}
 
inline
void CMapLoc_Base::C_Attlist::SetNumberOfMismatches(CMapLoc_Base::C_Attlist::TNumberOfMismatches value)
{
    m_NumberOfMismatches = value;
    m_set_State[0] |= 0x300000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfMismatches& CMapLoc_Base::C_Attlist::SetNumberOfMismatches(void)
{
#ifdef _DEBUG
    if (!IsSetNumberOfMismatches()) {
        memset(&m_NumberOfMismatches,UnassignedByte(),sizeof(m_NumberOfMismatches));
    }
#endif
    m_set_State[0] |= 0x100000;
    return m_NumberOfMismatches;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetNumberOfDeletions(void) const
{
    return ((m_set_State[0] & 0xc00000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetNumberOfDeletions(void) const
{
    return IsSetNumberOfDeletions();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetNumberOfDeletions(void)
{
    m_NumberOfDeletions = 0;
    m_set_State[0] &= ~0xc00000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfDeletions CMapLoc_Base::C_Attlist::GetNumberOfDeletions(void) const
{
    if (!CanGetNumberOfDeletions()) {
        ThrowUnassigned(11);
    }
    return m_NumberOfDeletions;
}
 
inline
void CMapLoc_Base::C_Attlist::SetNumberOfDeletions(CMapLoc_Base::C_Attlist::TNumberOfDeletions value)
{
    m_NumberOfDeletions = value;
    m_set_State[0] |= 0xc00000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfDeletions& CMapLoc_Base::C_Attlist::SetNumberOfDeletions(void)
{
#ifdef _DEBUG
    if (!IsSetNumberOfDeletions()) {
        memset(&m_NumberOfDeletions,UnassignedByte(),sizeof(m_NumberOfDeletions));
    }
#endif
    m_set_State[0] |= 0x400000;
    return m_NumberOfDeletions;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetNumberOfInsertions(void) const
{
    return ((m_set_State[0] & 0x3000000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetNumberOfInsertions(void) const
{
    return IsSetNumberOfInsertions();
}
 
inline
void CMapLoc_Base::C_Attlist::ResetNumberOfInsertions(void)
{
    m_NumberOfInsertions = 0;
    m_set_State[0] &= ~0x3000000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfInsertions CMapLoc_Base::C_Attlist::GetNumberOfInsertions(void) const
{
    if (!CanGetNumberOfInsertions()) {
        ThrowUnassigned(12);
    }
    return m_NumberOfInsertions;
}
 
inline
void CMapLoc_Base::C_Attlist::SetNumberOfInsertions(CMapLoc_Base::C_Attlist::TNumberOfInsertions value)
{
    m_NumberOfInsertions = value;
    m_set_State[0] |= 0x3000000;
}
 
inline
CMapLoc_Base::C_Attlist::TNumberOfInsertions& CMapLoc_Base::C_Attlist::SetNumberOfInsertions(void)
{
#ifdef _DEBUG
    if (!IsSetNumberOfInsertions()) {
        memset(&m_NumberOfInsertions,UnassignedByte(),sizeof(m_NumberOfInsertions));
    }
#endif
    m_set_State[0] |= 0x1000000;
    return m_NumberOfInsertions;
}
 
inline
bool CMapLoc_Base::C_Attlist::IsSetRefAllele(void) const
{
    return ((m_set_State[0] & 0xc000000) != 0);
}
 
inline
bool CMapLoc_Base::C_Attlist::CanGetRefAllele(void) const
{
    return IsSetRefAllele();
}
 
inline
const CMapLoc_Base::C_Attlist::TRefAllele& CMapLoc_Base::C_Attlist::GetRefAllele(void) const
{
    if (!CanGetRefAllele()) {
        ThrowUnassigned(13);
    }
    return m_RefAllele;
}
 
inline
void CMapLoc_Base::C_Attlist::SetRefAllele(const CMapLoc_Base::C_Attlist::TRefAllele& value)
{
    m_RefAllele = value;
    m_set_State[0] |= 0xc000000;
}
 
inline
void CMapLoc_Base::C_Attlist::SetRefAllele(CMapLoc_Base::C_Attlist::TRefAllele&& value)
{
    m_RefAllele = std::forward<CMapLoc_Base::C_Attlist::TRefAllele>(value);
    m_set_State[0] |= 0xc000000;
}
 
inline
CMapLoc_Base::C_Attlist::TRefAllele& CMapLoc_Base::C_Attlist::SetRefAllele(void)
{
#ifdef _DEBUG
    if (!IsSetRefAllele()) {
        m_RefAllele = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x4000000;
    return m_RefAllele;
}
 
inline
bool CMapLoc_Base::IsSetAttlist(void) const
{
    return m_Attlist.NotEmpty();
}
 
inline
bool CMapLoc_Base::CanGetAttlist(void) const
{
    return true;
}
 
inline
const CMapLoc_Base::TAttlist& CMapLoc_Base::GetAttlist(void) const
{
    if ( !m_Attlist ) {
        const_cast<CMapLoc_Base*>(this)->ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
CMapLoc_Base::TAttlist& CMapLoc_Base::SetAttlist(void)
{
    if ( !m_Attlist ) {
        ResetAttlist();
    }
    return (*m_Attlist);
}
 
inline
bool CMapLoc_Base::IsSetFxnSet(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CMapLoc_Base::CanGetFxnSet(void) const
{
    return true;
}
 
inline
const CMapLoc_Base::TFxnSet& CMapLoc_Base::GetFxnSet(void) const
{
    return m_FxnSet;
}
 
inline
CMapLoc_Base::TFxnSet& CMapLoc_Base::SetFxnSet(void)
{
    m_set_State[0] |= 0x4;
    return m_FxnSet;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_DOCSUM_MAPLOC_BASE_HPP