Seq_inst_.hpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/* $Id$
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 */
 
/// @file Seq_inst_.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/seq/seq.asn">seq.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/seq/seq.def">seq.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_SEQ_SEQ_INST_BASE_HPP
#define OBJECTS_SEQ_SEQ_INST_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
BEGIN_NCBI_SCOPE
 
#ifndef BEGIN_objects_SCOPE
#  define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
#  define END_objects_SCOPE END_SCOPE(objects)
#endif
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// forward declarations
class CInt_fuzz;
class CSeq_data;
class CSeq_ext;
class CSeq_hist;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_Sequence
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///*** Instances of sequences *******************************
///*
/// the sequence data itself
///
/// CSeq_inst_Base --
///
 
class NCBI_SEQ_EXPORT CSeq_inst_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CSeq_inst_Base(void);
    // destructor
    virtual ~CSeq_inst_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /// representation class
    enum ERepr {
        eRepr_not_set =   0,  ///< empty
        eRepr_virtual =   1,  ///< no seq data
        eRepr_raw     =   2,  ///< continuous sequence
        eRepr_seg     =   3,  ///< segmented sequence
        eRepr_const   =   4,  ///< constructed sequence
        eRepr_ref     =   5,  ///< reference to another sequence
        eRepr_consen  =   6,  ///< consensus sequence or pattern
        eRepr_map     =   7,  ///< ordered map of any kind
        eRepr_delta   =   8,  ///< sequence made by changes (delta) to others
        eRepr_other   = 255
    };
    
    /// Access to ERepr's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(ERepr)(void);
    
    /// molecule class in living organism
    enum EMol {
        eMol_not_set =   0,  ///<   > cdna = rna
        eMol_dna     =   1,
        eMol_rna     =   2,
        eMol_aa      =   3,
        eMol_na      =   4,  ///< just a nucleic acid
        eMol_other   = 255
    };
    
    /// Access to EMol's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EMol)(void);
    
    /// topology of molecule
    enum ETopology {
        eTopology_not_set  =   0,
        eTopology_linear   =   1,
        eTopology_circular =   2,
        eTopology_tandem   =   3,  ///< some part of tandem repeat
        eTopology_other    = 255
    };
    
    /// Access to ETopology's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(ETopology)(void);
    
    /// strandedness in living organism
    enum EStrand {
        eStrand_not_set =   0,
        eStrand_ss      =   1,  ///< single strand
        eStrand_ds      =   2,  ///< double strand
        eStrand_mixed   =   3,
        eStrand_other   = 255  ///< default ds for DNA, ss for RNA, pept
    };
    
    /// Access to EStrand's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EStrand)(void);
    
    // types
    typedef ERepr TRepr;
    typedef EMol TMol;
    typedef TSeqPos TLength;
    typedef CInt_fuzz TFuzz;
    typedef ETopology TTopology;
    typedef EStrand TStrand;
    typedef CSeq_data TSeq_data;
    typedef CSeq_ext TExt;
    typedef CSeq_hist THist;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_repr,
        e_mol,
        e_length,
        e_fuzz,
        e_topology,
        e_strand,
        e_seq_data,
        e_ext,
        e_hist
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 10> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Repr data member.
    ///
    /// Data member Repr is mandatory;
    /// its type is defined as 'typedef ERepr TRepr'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRepr(void) const;
 
    /// Check if it is safe to call GetRepr method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRepr(void) const;
 
    /// Reset Repr data member.
    void ResetRepr(void);
 
    /// Get the Repr member data.
    ///
    /// @return
    ///   Copy of the member data.
    TRepr GetRepr(void) const;
 
    /// Assign a value to Repr data member.
    ///
    /// @param value
    ///   Value to assign
    void SetRepr(TRepr value);
 
    /// Assign a value to Repr data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRepr& SetRepr(void);
 
    /// Check if a value has been assigned to Mol data member.
    ///
    /// Data member Mol is mandatory;
    /// its type is defined as 'typedef EMol TMol'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetMol(void) const;
 
    /// Check if it is safe to call GetMol method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetMol(void) const;
 
    /// Reset Mol data member.
    void ResetMol(void);
 
    /// Get the Mol member data.
    ///
    /// @return
    ///   Copy of the member data.
    TMol GetMol(void) const;
 
    /// Assign a value to Mol data member.
    ///
    /// @param value
    ///   Value to assign
    void SetMol(TMol value);
 
    /// Assign a value to Mol data member.
    ///
    /// @return
    ///   Reference to the data value.
    TMol& SetMol(void);
 
    /// length of sequence in residues
    /// Check if a value has been assigned to Length data member.
    ///
    /// Data member Length is optional;
    /// its type is defined as 'typedef TSeqPos TLength'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetLength(void) const;
 
    /// Check if it is safe to call GetLength method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetLength(void) const;
 
    /// Reset Length data member.
    void ResetLength(void);
 
    /// Get the Length member data.
    ///
    /// @return
    ///   Copy of the member data.
    TLength GetLength(void) const;
 
    /// Assign a value to Length data member.
    ///
    /// @param value
    ///   Value to assign
    void SetLength(TLength value);
 
    /// Assign a value to Length data member.
    ///
    /// @return
    ///   Reference to the data value.
    TLength& SetLength(void);
 
    /// length uncertainty
    /// Check if a value has been assigned to Fuzz data member.
    ///
    /// Data member Fuzz is optional;
    /// its type is defined as 'typedef CInt_fuzz TFuzz'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetFuzz(void) const;
 
    /// Check if it is safe to call GetFuzz method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetFuzz(void) const;
 
    /// Reset Fuzz data member.
    void ResetFuzz(void);
 
    /// Get the Fuzz member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TFuzz& GetFuzz(void) const;
 
    /// Assign a value to Fuzz data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetFuzz(TFuzz& value);
 
    /// Assign a value to Fuzz data member.
    ///
    /// @return
    ///   Reference to the data value.
    TFuzz& SetFuzz(void);
 
    /// Check if a value has been assigned to Topology data member.
    ///
    /// Data member Topology is optional with default eTopology_linear;
    /// its type is defined as 'typedef ETopology TTopology'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetTopology(void) const;
 
    /// Check if it is safe to call GetTopology method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetTopology(void) const;
 
    /// Reset Topology data member.
    void ResetTopology(void);
 
    /// Assign default value to Topology data member.
    void SetDefaultTopology(void);
 
    /// Get the Topology member data.
    ///
    /// @return
    ///   Copy of the member data.
    TTopology GetTopology(void) const;
 
    /// Assign a value to Topology data member.
    ///
    /// @param value
    ///   Value to assign
    void SetTopology(TTopology value);
 
    /// Assign a value to Topology data member.
    ///
    /// @return
    ///   Reference to the data value.
    TTopology& SetTopology(void);
 
    /// Check if a value has been assigned to Strand data member.
    ///
    /// Data member Strand is optional;
    /// its type is defined as 'typedef EStrand TStrand'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetStrand(void) const;
 
    /// Check if it is safe to call GetStrand method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetStrand(void) const;
 
    /// Reset Strand data member.
    void ResetStrand(void);
 
    /// Get the Strand member data.
    ///
    /// @return
    ///   Copy of the member data.
    TStrand GetStrand(void) const;
 
    /// Assign a value to Strand data member.
    ///
    /// @param value
    ///   Value to assign
    void SetStrand(TStrand value);
 
    /// Assign a value to Strand data member.
    ///
    /// @return
    ///   Reference to the data value.
    TStrand& SetStrand(void);
 
    /// the sequence
    /// Check if a value has been assigned to Seq_data data member.
    ///
    /// Data member Seq_data is optional;
    /// its type is defined as 'typedef CSeq_data TSeq_data'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetSeq_data(void) const;
 
    /// Check if it is safe to call GetSeq_data method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetSeq_data(void) const;
 
    /// Reset Seq_data data member.
    void ResetSeq_data(void);
 
    /// Get the Seq_data member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TSeq_data& GetSeq_data(void) const;
 
    /// Assign a value to Seq_data data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetSeq_data(TSeq_data& value);
 
    /// Assign a value to Seq_data data member.
    ///
    /// @return
    ///   Reference to the data value.
    TSeq_data& SetSeq_data(void);
 
    /// extensions for special types
    /// Check if a value has been assigned to Ext data member.
    ///
    /// Data member Ext is optional;
    /// its type is defined as 'typedef CSeq_ext TExt'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetExt(void) const;
 
    /// Check if it is safe to call GetExt method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetExt(void) const;
 
    /// Reset Ext data member.
    void ResetExt(void);
 
    /// Get the Ext member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TExt& GetExt(void) const;
 
    /// Assign a value to Ext data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetExt(TExt& value);
 
    /// Assign a value to Ext data member.
    ///
    /// @return
    ///   Reference to the data value.
    TExt& SetExt(void);
 
    /// sequence history
    /// Check if a value has been assigned to Hist data member.
    ///
    /// Data member Hist is optional;
    /// its type is defined as 'typedef CSeq_hist THist'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetHist(void) const;
 
    /// Check if it is safe to call GetHist method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetHist(void) const;
 
    /// Reset Hist data member.
    void ResetHist(void);
 
    /// Get the Hist member data.
    ///
    /// @return
    ///   Reference to the member data.
    const THist& GetHist(void) const;
 
    /// Assign a value to Hist data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetHist(THist& value);
 
    /// Assign a value to Hist data member.
    ///
    /// @return
    ///   Reference to the data value.
    THist& SetHist(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CSeq_inst_Base(const CSeq_inst_Base&);
    CSeq_inst_Base& operator=(const CSeq_inst_Base&);
 
    // data
    Uint4 m_set_State[1];
    ERepr m_Repr;
    EMol m_Mol;
    TSeqPos m_Length;
    CRef< TFuzz > m_Fuzz;
    ETopology m_Topology;
    EStrand m_Strand;
    CRef< TSeq_data > m_Seq_data;
    CRef< TExt > m_Ext;
    CRef< THist > m_Hist;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CSeq_inst_Base::IsSetRepr(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CSeq_inst_Base::CanGetRepr(void) const
{
    return IsSetRepr();
}
 
inline
void CSeq_inst_Base::ResetRepr(void)
{
    m_Repr = (ERepr)(0);
    m_set_State[0] &= ~0x3;
}
 
inline
CSeq_inst_Base::TRepr CSeq_inst_Base::GetRepr(void) const
{
    if (!CanGetRepr()) {
        ThrowUnassigned(0);
    }
    return m_Repr;
}
 
inline
void CSeq_inst_Base::SetRepr(CSeq_inst_Base::TRepr value)
{
    m_Repr = value;
    m_set_State[0] |= 0x3;
}
 
inline
CSeq_inst_Base::TRepr& CSeq_inst_Base::SetRepr(void)
{
#ifdef _DEBUG
    if (!IsSetRepr()) {
        memset(&m_Repr,UnassignedByte(),sizeof(m_Repr));
    }
#endif
    m_set_State[0] |= 0x1;
    return m_Repr;
}
 
inline
bool CSeq_inst_Base::IsSetMol(void) const
{
    return ((m_set_State[0] & 0xc) != 0);
}
 
inline
bool CSeq_inst_Base::CanGetMol(void) const
{
    return IsSetMol();
}
 
inline
void CSeq_inst_Base::ResetMol(void)
{
    m_Mol = (EMol)(0);
    m_set_State[0] &= ~0xc;
}
 
inline
CSeq_inst_Base::TMol CSeq_inst_Base::GetMol(void) const
{
    if (!CanGetMol()) {
        ThrowUnassigned(1);
    }
    return m_Mol;
}
 
inline
void CSeq_inst_Base::SetMol(CSeq_inst_Base::TMol value)
{
    m_Mol = value;
    m_set_State[0] |= 0xc;
}
 
inline
CSeq_inst_Base::TMol& CSeq_inst_Base::SetMol(void)
{
#ifdef _DEBUG
    if (!IsSetMol()) {
        memset(&m_Mol,UnassignedByte(),sizeof(m_Mol));
    }
#endif
    m_set_State[0] |= 0x4;
    return m_Mol;
}
 
inline
bool CSeq_inst_Base::IsSetLength(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CSeq_inst_Base::CanGetLength(void) const
{
    return IsSetLength();
}
 
inline
void CSeq_inst_Base::ResetLength(void)
{
    m_Length = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CSeq_inst_Base::TLength CSeq_inst_Base::GetLength(void) const
{
    if (!CanGetLength()) {
        ThrowUnassigned(2);
    }
    return m_Length;
}
 
inline
void CSeq_inst_Base::SetLength(CSeq_inst_Base::TLength value)
{
    m_Length = value;
    m_set_State[0] |= 0x30;
}
 
inline
CSeq_inst_Base::TLength& CSeq_inst_Base::SetLength(void)
{
#ifdef _DEBUG
    if (!IsSetLength()) {
        memset(&m_Length,UnassignedByte(),sizeof(m_Length));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Length;
}
 
inline
bool CSeq_inst_Base::IsSetFuzz(void) const
{
    return m_Fuzz.NotEmpty();
}
 
inline
bool CSeq_inst_Base::CanGetFuzz(void) const
{
    return IsSetFuzz();
}
 
inline
const CSeq_inst_Base::TFuzz& CSeq_inst_Base::GetFuzz(void) const
{
    if (!CanGetFuzz()) {
        ThrowUnassigned(3);
    }
    return (*m_Fuzz);
}
 
inline
bool CSeq_inst_Base::IsSetTopology(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CSeq_inst_Base::CanGetTopology(void) const
{
    return true;
}
 
inline
void CSeq_inst_Base::ResetTopology(void)
{
    m_Topology = eTopology_linear;
    m_set_State[0] &= ~0x300;
}
 
inline
void CSeq_inst_Base::SetDefaultTopology(void)
{
    ResetTopology();
}
 
inline
CSeq_inst_Base::TTopology CSeq_inst_Base::GetTopology(void) const
{
    return m_Topology;
}
 
inline
void CSeq_inst_Base::SetTopology(CSeq_inst_Base::TTopology value)
{
    m_Topology = value;
    m_set_State[0] |= 0x300;
}
 
inline
CSeq_inst_Base::TTopology& CSeq_inst_Base::SetTopology(void)
{
#ifdef _DEBUG
    if (!IsSetTopology()) {
        memset(&m_Topology,UnassignedByte(),sizeof(m_Topology));
    }
#endif
    m_set_State[0] |= 0x100;
    return m_Topology;
}
 
inline
bool CSeq_inst_Base::IsSetStrand(void) const
{
    return ((m_set_State[0] & 0xc00) != 0);
}
 
inline
bool CSeq_inst_Base::CanGetStrand(void) const
{
    return IsSetStrand();
}
 
inline
void CSeq_inst_Base::ResetStrand(void)
{
    m_Strand = (EStrand)(0);
    m_set_State[0] &= ~0xc00;
}
 
inline
CSeq_inst_Base::TStrand CSeq_inst_Base::GetStrand(void) const
{
    if (!CanGetStrand()) {
        ThrowUnassigned(5);
    }
    return m_Strand;
}
 
inline
void CSeq_inst_Base::SetStrand(CSeq_inst_Base::TStrand value)
{
    m_Strand = value;
    m_set_State[0] |= 0xc00;
}
 
inline
CSeq_inst_Base::TStrand& CSeq_inst_Base::SetStrand(void)
{
#ifdef _DEBUG
    if (!IsSetStrand()) {
        memset(&m_Strand,UnassignedByte(),sizeof(m_Strand));
    }
#endif
    m_set_State[0] |= 0x400;
    return m_Strand;
}
 
inline
bool CSeq_inst_Base::IsSetSeq_data(void) const
{
    return m_Seq_data.NotEmpty();
}
 
inline
bool CSeq_inst_Base::CanGetSeq_data(void) const
{
    return IsSetSeq_data();
}
 
inline
const CSeq_inst_Base::TSeq_data& CSeq_inst_Base::GetSeq_data(void) const
{
    if (!CanGetSeq_data()) {
        ThrowUnassigned(6);
    }
    return (*m_Seq_data);
}
 
inline
bool CSeq_inst_Base::IsSetExt(void) const
{
    return m_Ext.NotEmpty();
}
 
inline
bool CSeq_inst_Base::CanGetExt(void) const
{
    return IsSetExt();
}
 
inline
const CSeq_inst_Base::TExt& CSeq_inst_Base::GetExt(void) const
{
    if (!CanGetExt()) {
        ThrowUnassigned(7);
    }
    return (*m_Ext);
}
 
inline
bool CSeq_inst_Base::IsSetHist(void) const
{
    return m_Hist.NotEmpty();
}
 
inline
bool CSeq_inst_Base::CanGetHist(void) const
{
    return IsSetHist();
}
 
inline
const CSeq_inst_Base::THist& CSeq_inst_Base::GetHist(void) const
{
    if (!CanGetHist()) {
        ThrowUnassigned(8);
    }
    return (*m_Hist);
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_SEQ_SEQ_INST_BASE_HPP