ID2S_Seq_loc_.cpp

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 Description:
 *   This code was generated by application DATATOOL
 *   using the following specifications:
 *   'seqsplit.asn'.
 *
 * ATTENTION:
 *   Don't edit or commit this file into CVS as this file will
 *   be overridden (by DATATOOL) without warning!
 * ===========================================================================
 */
 
// standard includes
#include <ncbi_pch.hpp>
#include <serial/serialimpl.hpp>
 
// generated includes
#include <objects/seqsplit/ID2S_Seq_loc.hpp>
#include <objects/seqloc/Seq_id.hpp>
#include <objects/seqsplit/ID2S_Gi_Interval.hpp>
#include <objects/seqsplit/ID2S_Gi_Ints.hpp>
#include <objects/seqsplit/ID2S_Gi_Range.hpp>
#include <objects/seqsplit/ID2S_Seq_id_Interval.hpp>
#include <objects/seqsplit/ID2S_Seq_id_Ints.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CID2S_Seq_loc_Base::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CID2S_Seq_loc_Base::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Loc_set:
        m_Loc_set.Destruct();
        break;
    case e_Whole_seq_id:
    case e_Whole_gi_range:
    case e_Gi_interval:
    case e_Seq_id_interval:
    case e_Gi_ints:
    case e_Seq_id_ints:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CID2S_Seq_loc_Base::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Whole_gi:
        m_Whole_gi = 0;
        break;
    case e_Whole_seq_id:
        (m_object = new(pool) ncbi::objects::CSeq_id())->AddReference();
        break;
    case e_Whole_gi_range:
        (m_object = new(pool) ncbi::objects::CID2S_Gi_Range())->AddReference();
        break;
    case e_Gi_interval:
        (m_object = new(pool) ncbi::objects::CID2S_Gi_Interval())->AddReference();
        break;
    case e_Seq_id_interval:
        (m_object = new(pool) ncbi::objects::CID2S_Seq_id_Interval())->AddReference();
        break;
    case e_Gi_ints:
        (m_object = new(pool) ncbi::objects::CID2S_Gi_Ints())->AddReference();
        break;
    case e_Seq_id_ints:
        (m_object = new(pool) ncbi::objects::CID2S_Seq_id_Ints())->AddReference();
        break;
    case e_Loc_set:
        m_Loc_set.Construct();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CID2S_Seq_loc_Base::sm_SelectionNames[] = {
    "not set",
    "whole-gi",
    "whole-seq-id",
    "whole-gi-range",
    "gi-interval",
    "seq-id-interval",
    "gi-ints",
    "seq-id-ints",
    "loc-set"
};
 
NCBI_NS_STD::string CID2S_Seq_loc_Base::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CID2S_Seq_loc_Base::ThrowInvalidSelection(E_Choice index) const
{
    throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
const CID2S_Seq_loc_Base::TWhole_seq_id& CID2S_Seq_loc_Base::GetWhole_seq_id(void) const
{
    CheckSelected(e_Whole_seq_id);
    return *static_cast<const TWhole_seq_id*>(m_object);
}
 
CID2S_Seq_loc_Base::TWhole_seq_id& CID2S_Seq_loc_Base::SetWhole_seq_id(void)
{
    Select(e_Whole_seq_id, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TWhole_seq_id*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetWhole_seq_id(CID2S_Seq_loc_Base::TWhole_seq_id& value)
{
    TWhole_seq_id* ptr = &value;
    if ( m_choice != e_Whole_seq_id || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Whole_seq_id;
    }
}
 
const CID2S_Seq_loc_Base::TWhole_gi_range& CID2S_Seq_loc_Base::GetWhole_gi_range(void) const
{
    CheckSelected(e_Whole_gi_range);
    return *static_cast<const TWhole_gi_range*>(m_object);
}
 
CID2S_Seq_loc_Base::TWhole_gi_range& CID2S_Seq_loc_Base::SetWhole_gi_range(void)
{
    Select(e_Whole_gi_range, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TWhole_gi_range*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetWhole_gi_range(CID2S_Seq_loc_Base::TWhole_gi_range& value)
{
    TWhole_gi_range* ptr = &value;
    if ( m_choice != e_Whole_gi_range || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Whole_gi_range;
    }
}
 
const CID2S_Seq_loc_Base::TGi_interval& CID2S_Seq_loc_Base::GetGi_interval(void) const
{
    CheckSelected(e_Gi_interval);
    return *static_cast<const TGi_interval*>(m_object);
}
 
CID2S_Seq_loc_Base::TGi_interval& CID2S_Seq_loc_Base::SetGi_interval(void)
{
    Select(e_Gi_interval, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TGi_interval*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetGi_interval(CID2S_Seq_loc_Base::TGi_interval& value)
{
    TGi_interval* ptr = &value;
    if ( m_choice != e_Gi_interval || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Gi_interval;
    }
}
 
const CID2S_Seq_loc_Base::TSeq_id_interval& CID2S_Seq_loc_Base::GetSeq_id_interval(void) const
{
    CheckSelected(e_Seq_id_interval);
    return *static_cast<const TSeq_id_interval*>(m_object);
}
 
CID2S_Seq_loc_Base::TSeq_id_interval& CID2S_Seq_loc_Base::SetSeq_id_interval(void)
{
    Select(e_Seq_id_interval, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSeq_id_interval*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetSeq_id_interval(CID2S_Seq_loc_Base::TSeq_id_interval& value)
{
    TSeq_id_interval* ptr = &value;
    if ( m_choice != e_Seq_id_interval || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Seq_id_interval;
    }
}
 
const CID2S_Seq_loc_Base::TGi_ints& CID2S_Seq_loc_Base::GetGi_ints(void) const
{
    CheckSelected(e_Gi_ints);
    return *static_cast<const TGi_ints*>(m_object);
}
 
CID2S_Seq_loc_Base::TGi_ints& CID2S_Seq_loc_Base::SetGi_ints(void)
{
    Select(e_Gi_ints, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TGi_ints*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetGi_ints(CID2S_Seq_loc_Base::TGi_ints& value)
{
    TGi_ints* ptr = &value;
    if ( m_choice != e_Gi_ints || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Gi_ints;
    }
}
 
const CID2S_Seq_loc_Base::TSeq_id_ints& CID2S_Seq_loc_Base::GetSeq_id_ints(void) const
{
    CheckSelected(e_Seq_id_ints);
    return *static_cast<const TSeq_id_ints*>(m_object);
}
 
CID2S_Seq_loc_Base::TSeq_id_ints& CID2S_Seq_loc_Base::SetSeq_id_ints(void)
{
    Select(e_Seq_id_ints, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSeq_id_ints*>(m_object);
}
 
void CID2S_Seq_loc_Base::SetSeq_id_ints(CID2S_Seq_loc_Base::TSeq_id_ints& value)
{
    TSeq_id_ints* ptr = &value;
    if ( m_choice != e_Seq_id_ints || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Seq_id_ints;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_BASE_CHOICE_INFO("ID2S-Seq-loc", CID2S_Seq_loc)
{
    SET_CHOICE_MODULE("NCBI-Seq-split");
    ADD_NAMED_STD_CHOICE_VARIANT("whole-gi", m_Whole_gi);
    ADD_NAMED_REF_CHOICE_VARIANT("whole-seq-id", m_object, CSeq_id);
    ADD_NAMED_REF_CHOICE_VARIANT("whole-gi-range", m_object, CID2S_Gi_Range);
    ADD_NAMED_REF_CHOICE_VARIANT("gi-interval", m_object, CID2S_Gi_Interval);
    ADD_NAMED_REF_CHOICE_VARIANT("seq-id-interval", m_object, CID2S_Seq_id_Interval);
    ADD_NAMED_REF_CHOICE_VARIANT("gi-ints", m_object, CID2S_Gi_Ints);
    ADD_NAMED_REF_CHOICE_VARIANT("seq-id-ints", m_object, CID2S_Seq_id_Ints);
    ADD_NAMED_BUF_CHOICE_VARIANT("loc-set", m_Loc_set, STL_list_set, (STL_CRef, (CLASS, (CID2S_Seq_loc))));
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eASN);
}
END_CHOICE_INFO
 
// constructor
CID2S_Seq_loc_Base::CID2S_Seq_loc_Base(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CID2S_Seq_loc_Base::~CID2S_Seq_loc_Base(void)
{
    Reset();
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE