Bioseq_set_.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 Bioseq_set_.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/seqset/seqset.asn">seqset.asn</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/seqset/seqset.def">seqset.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJECTS_SEQSET_BIOSEQ_SET_BASE_HPP
#define OBJECTS_SEQSET_BIOSEQ_SET_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 CDate;
class CDbtag;
class CObject_id;
class CSeq_annot;
class CSeq_descr;
class CSeq_entry;
 
 
// generated classes
 
 
/** @addtogroup dataspec_NCBI_Seqset
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///*** Sequence Collections ********************************
///*
/// just a collection
///
/// CBioseq_set_Base --
///
 
class NCBI_SEQSET_EXPORT CBioseq_set_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CBioseq_set_Base(void);
    // destructor
    virtual ~CBioseq_set_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    enum EClass {
        eClass_not_set          =   0,
        eClass_nuc_prot         =   1,  ///< nuc acid and coded proteins
        eClass_segset           =   2,  ///< segmented sequence + parts
        eClass_conset           =   3,  ///< constructed sequence + parts
        eClass_parts            =   4,  ///< parts for 2 or 3
        eClass_gibb             =   5,  ///< geninfo backbone
        eClass_gi               =   6,  ///< geninfo
        eClass_genbank          =   7,  ///< converted genbank
        eClass_pir              =   8,  ///< converted pir
        eClass_pub_set          =   9,  ///< all the seqs from a single publication
        eClass_equiv            =  10,  ///< a set of equivalent maps or seqs
        eClass_swissprot        =  11,  ///< converted SWISSPROT
        eClass_pdb_entry        =  12,  ///< a complete PDB entry
        eClass_mut_set          =  13,  ///< set of mutations
        eClass_pop_set          =  14,  ///< population study
        eClass_phy_set          =  15,  ///< phylogenetic study
        eClass_eco_set          =  16,  ///< ecological sample study
        eClass_gen_prod_set     =  17,  ///< genomic products, chrom+mRNA+protein
        eClass_wgs_set          =  18,  ///< whole genome shotgun project
        eClass_named_annot      =  19,  ///< named annotation set
        eClass_named_annot_prod =  20,  ///< with instantiated mRNA+protein
        eClass_read_set         =  21,  ///< set from a single read
        eClass_paired_end_reads =  22,  ///< paired sequences within a read-set
        eClass_small_genome_set =  23,  ///< viral segments or mitochondrial minicircles
        eClass_other            = 255
    };
    
    /// Access to EClass's attributes (values, names) as defined in spec
    static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EClass)(void);
    
    // types
    typedef CObject_id TId;
    typedef CDbtag TColl;
    typedef int TLevel;
    typedef EClass TClass;
    typedef string TRelease;
    typedef CDate TDate;
    typedef CSeq_descr TDescr;
    typedef list< CRef< CSeq_entry > > TSeq_set;
    typedef list< CRef< CSeq_annot > > TAnnot;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_id,
        e_coll,
        e_level,
        e_class,
        e_release,
        e_date,
        e_descr,
        e_seq_set,
        e_annot
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 10> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to Id data member.
    ///
    /// Data member Id is optional;
    /// its type is defined as 'typedef CObject_id TId'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetId(void) const;
 
    /// Check if it is safe to call GetId method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetId(void) const;
 
    /// Reset Id data member.
    void ResetId(void);
 
    /// Get the Id member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TId& GetId(void) const;
 
    /// Assign a value to Id data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetId(TId& value);
 
    /// Assign a value to Id data member.
    ///
    /// @return
    ///   Reference to the data value.
    TId& SetId(void);
 
    /// to identify a collection
    /// Check if a value has been assigned to Coll data member.
    ///
    /// Data member Coll is optional;
    /// its type is defined as 'typedef CDbtag TColl'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetColl(void) const;
 
    /// Check if it is safe to call GetColl method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetColl(void) const;
 
    /// Reset Coll data member.
    void ResetColl(void);
 
    /// Get the Coll member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TColl& GetColl(void) const;
 
    /// Assign a value to Coll data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetColl(TColl& value);
 
    /// Assign a value to Coll data member.
    ///
    /// @return
    ///   Reference to the data value.
    TColl& SetColl(void);
 
    /// nesting level
    /// Check if a value has been assigned to Level data member.
    ///
    /// Data member Level is optional;
    /// its type is defined as 'typedef int TLevel'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetLevel(void) const;
 
    /// Check if it is safe to call GetLevel method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetLevel(void) const;
 
    /// Reset Level data member.
    void ResetLevel(void);
 
    /// Get the Level member data.
    ///
    /// @return
    ///   Copy of the member data.
    TLevel GetLevel(void) const;
 
    /// Assign a value to Level data member.
    ///
    /// @param value
    ///   Value to assign
    void SetLevel(TLevel value);
 
    /// Assign a value to Level data member.
    ///
    /// @return
    ///   Reference to the data value.
    TLevel& SetLevel(void);
 
    /// Check if a value has been assigned to Class data member.
    ///
    /// Data member Class is optional with default eClass_not_set;
    /// its type is defined as 'typedef EClass TClass'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetClass(void) const;
 
    /// Check if it is safe to call GetClass method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetClass(void) const;
 
    /// Reset Class data member.
    void ResetClass(void);
 
    /// Assign default value to Class data member.
    void SetDefaultClass(void);
 
    /// Get the Class member data.
    ///
    /// @return
    ///   Copy of the member data.
    TClass GetClass(void) const;
 
    /// Assign a value to Class data member.
    ///
    /// @param value
    ///   Value to assign
    void SetClass(TClass value);
 
    /// Assign a value to Class data member.
    ///
    /// @return
    ///   Reference to the data value.
    TClass& SetClass(void);
 
    /// Check if a value has been assigned to Release data member.
    ///
    /// Data member Release is optional;
    /// its type is defined as 'typedef string TRelease'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetRelease(void) const;
 
    /// Check if it is safe to call GetRelease method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetRelease(void) const;
 
    /// Reset Release data member.
    void ResetRelease(void);
 
    /// Get the Release member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TRelease& GetRelease(void) const;
 
    /// Assign a value to Release data member.
    ///
    /// @param value
    ///   Value to assign
    void SetRelease(const TRelease& value);
    void SetRelease(TRelease&& value);
 
    /// Assign a value to Release data member.
    ///
    /// @return
    ///   Reference to the data value.
    TRelease& SetRelease(void);
 
    /// Check if a value has been assigned to Date data member.
    ///
    /// Data member Date is optional;
    /// its type is defined as 'typedef CDate 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
    ///   Reference to value.
    void SetDate(TDate& value);
 
    /// Assign a value to Date data member.
    ///
    /// @return
    ///   Reference to the data value.
    TDate& SetDate(void);
 
    /// Check if a value has been assigned to Descr data member.
    ///
    /// Data member Descr is optional;
    /// its type is defined as 'typedef CSeq_descr TDescr'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetDescr(void) const;
 
    /// Check if it is safe to call GetDescr method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetDescr(void) const;
 
    /// Reset Descr data member.
    void ResetDescr(void);
 
    /// Get the Descr member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TDescr& GetDescr(void) const;
 
    /// Assign a value to Descr data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetDescr(TDescr& value);
 
    /// Assign a value to Descr data member.
    ///
    /// @return
    ///   Reference to the data value.
    TDescr& SetDescr(void);
 
    /// Check if a value has been assigned to Seq_set data member.
    ///
    /// Data member Seq_set is mandatory;
    /// its type is defined as 'typedef list< CRef< CSeq_entry > > TSeq_set'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetSeq_set(void) const;
 
    /// Check if it is safe to call GetSeq_set method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetSeq_set(void) const;
 
    /// Reset Seq_set data member.
    void ResetSeq_set(void);
 
    /// Get the Seq_set member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TSeq_set& GetSeq_set(void) const;
 
    /// Assign a value to Seq_set data member.
    ///
    /// @return
    ///   Reference to the data value.
    TSeq_set& SetSeq_set(void);
 
    /// Check if a value has been assigned to Annot data member.
    ///
    /// Data member Annot is optional;
    /// its type is defined as 'typedef list< CRef< CSeq_annot > > TAnnot'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetAnnot(void) const;
 
    /// Check if it is safe to call GetAnnot method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetAnnot(void) const;
 
    /// Reset Annot data member.
    void ResetAnnot(void);
 
    /// Get the Annot member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TAnnot& GetAnnot(void) const;
 
    /// Assign a value to Annot data member.
    ///
    /// @return
    ///   Reference to the data value.
    TAnnot& SetAnnot(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CBioseq_set_Base(const CBioseq_set_Base&);
    CBioseq_set_Base& operator=(const CBioseq_set_Base&);
 
    // data
    Uint4 m_set_State[1];
    CRef< TId > m_Id;
    CRef< TColl > m_Coll;
    int m_Level;
    EClass m_Class;
    string m_Release;
    CRef< TDate > m_Date;
    CRef< TDescr > m_Descr;
    list< CRef< CSeq_entry > > m_Seq_set;
    list< CRef< CSeq_annot > > m_Annot;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
bool CBioseq_set_Base::IsSetId(void) const
{
    return m_Id.NotEmpty();
}
 
inline
bool CBioseq_set_Base::CanGetId(void) const
{
    return IsSetId();
}
 
inline
const CBioseq_set_Base::TId& CBioseq_set_Base::GetId(void) const
{
    if (!CanGetId()) {
        ThrowUnassigned(0);
    }
    return (*m_Id);
}
 
inline
bool CBioseq_set_Base::IsSetColl(void) const
{
    return m_Coll.NotEmpty();
}
 
inline
bool CBioseq_set_Base::CanGetColl(void) const
{
    return IsSetColl();
}
 
inline
const CBioseq_set_Base::TColl& CBioseq_set_Base::GetColl(void) const
{
    if (!CanGetColl()) {
        ThrowUnassigned(1);
    }
    return (*m_Coll);
}
 
inline
bool CBioseq_set_Base::IsSetLevel(void) const
{
    return ((m_set_State[0] & 0x30) != 0);
}
 
inline
bool CBioseq_set_Base::CanGetLevel(void) const
{
    return IsSetLevel();
}
 
inline
void CBioseq_set_Base::ResetLevel(void)
{
    m_Level = 0;
    m_set_State[0] &= ~0x30;
}
 
inline
CBioseq_set_Base::TLevel CBioseq_set_Base::GetLevel(void) const
{
    if (!CanGetLevel()) {
        ThrowUnassigned(2);
    }
    return m_Level;
}
 
inline
void CBioseq_set_Base::SetLevel(CBioseq_set_Base::TLevel value)
{
    m_Level = value;
    m_set_State[0] |= 0x30;
}
 
inline
CBioseq_set_Base::TLevel& CBioseq_set_Base::SetLevel(void)
{
#ifdef _DEBUG
    if (!IsSetLevel()) {
        memset(&m_Level,UnassignedByte(),sizeof(m_Level));
    }
#endif
    m_set_State[0] |= 0x10;
    return m_Level;
}
 
inline
bool CBioseq_set_Base::IsSetClass(void) const
{
    return ((m_set_State[0] & 0xc0) != 0);
}
 
inline
bool CBioseq_set_Base::CanGetClass(void) const
{
    return true;
}
 
inline
void CBioseq_set_Base::ResetClass(void)
{
    m_Class = eClass_not_set;
    m_set_State[0] &= ~0xc0;
}
 
inline
void CBioseq_set_Base::SetDefaultClass(void)
{
    ResetClass();
}
 
inline
CBioseq_set_Base::TClass CBioseq_set_Base::GetClass(void) const
{
    return m_Class;
}
 
inline
void CBioseq_set_Base::SetClass(CBioseq_set_Base::TClass value)
{
    m_Class = value;
    m_set_State[0] |= 0xc0;
}
 
inline
CBioseq_set_Base::TClass& CBioseq_set_Base::SetClass(void)
{
#ifdef _DEBUG
    if (!IsSetClass()) {
        memset(&m_Class,UnassignedByte(),sizeof(m_Class));
    }
#endif
    m_set_State[0] |= 0x40;
    return m_Class;
}
 
inline
bool CBioseq_set_Base::IsSetRelease(void) const
{
    return ((m_set_State[0] & 0x300) != 0);
}
 
inline
bool CBioseq_set_Base::CanGetRelease(void) const
{
    return IsSetRelease();
}
 
inline
const CBioseq_set_Base::TRelease& CBioseq_set_Base::GetRelease(void) const
{
    if (!CanGetRelease()) {
        ThrowUnassigned(4);
    }
    return m_Release;
}
 
inline
void CBioseq_set_Base::SetRelease(const CBioseq_set_Base::TRelease& value)
{
    m_Release = value;
    m_set_State[0] |= 0x300;
}
 
inline
void CBioseq_set_Base::SetRelease(CBioseq_set_Base::TRelease&& value)
{
    m_Release = std::forward<CBioseq_set_Base::TRelease>(value);
    m_set_State[0] |= 0x300;
}
 
inline
CBioseq_set_Base::TRelease& CBioseq_set_Base::SetRelease(void)
{
#ifdef _DEBUG
    if (!IsSetRelease()) {
        m_Release = UnassignedString();
    }
#endif
    m_set_State[0] |= 0x100;
    return m_Release;
}
 
inline
bool CBioseq_set_Base::IsSetDate(void) const
{
    return m_Date.NotEmpty();
}
 
inline
bool CBioseq_set_Base::CanGetDate(void) const
{
    return IsSetDate();
}
 
inline
const CBioseq_set_Base::TDate& CBioseq_set_Base::GetDate(void) const
{
    if (!CanGetDate()) {
        ThrowUnassigned(5);
    }
    return (*m_Date);
}
 
inline
bool CBioseq_set_Base::IsSetDescr(void) const
{
    return m_Descr.NotEmpty();
}
 
inline
bool CBioseq_set_Base::CanGetDescr(void) const
{
    return IsSetDescr();
}
 
inline
const CBioseq_set_Base::TDescr& CBioseq_set_Base::GetDescr(void) const
{
    if (!CanGetDescr()) {
        ThrowUnassigned(6);
    }
    return (*m_Descr);
}
 
inline
bool CBioseq_set_Base::IsSetSeq_set(void) const
{
    return ((m_set_State[0] & 0xc000) != 0);
}
 
inline
bool CBioseq_set_Base::CanGetSeq_set(void) const
{
    return true;
}
 
inline
const CBioseq_set_Base::TSeq_set& CBioseq_set_Base::GetSeq_set(void) const
{
    return m_Seq_set;
}
 
inline
CBioseq_set_Base::TSeq_set& CBioseq_set_Base::SetSeq_set(void)
{
    m_set_State[0] |= 0x4000;
    return m_Seq_set;
}
 
inline
bool CBioseq_set_Base::IsSetAnnot(void) const
{
    return ((m_set_State[0] & 0x30000) != 0);
}
 
inline
bool CBioseq_set_Base::CanGetAnnot(void) const
{
    return true;
}
 
inline
const CBioseq_set_Base::TAnnot& CBioseq_set_Base::GetAnnot(void) const
{
    return m_Annot;
}
 
inline
CBioseq_set_Base::TAnnot& CBioseq_set_Base::SetAnnot(void)
{
    m_set_State[0] |= 0x10000;
    return m_Annot;
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJECTS_SEQSET_BIOSEQ_SET_BASE_HPP