SimpleVariant_.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:
 *   'varrep.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/varrep/SimpleVariant.hpp>
#include <objects/varrep/AaLocation.hpp>
#include <objects/varrep/Conversion.hpp>
#include <objects/varrep/Deletion.hpp>
#include <objects/varrep/Delins.hpp>
#include <objects/varrep/Duplication.hpp>
#include <objects/varrep/Frameshift.hpp>
#include <objects/varrep/Insertion.hpp>
#include <objects/varrep/Inversion.hpp>
#include <objects/varrep/NaIdentity.hpp>
#include <objects/varrep/NaSub.hpp>
#include <objects/varrep/ProteinExtension.hpp>
#include <objects/varrep/ProteinSub.hpp>
#include <objects/varrep/Repeat.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CSimpleVariant_Base::C_Type::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CSimpleVariant_Base::C_Type::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Na_identity:
    case e_Na_sub:
    case e_Prot_sub:
    case e_Prot_silent:
    case e_Del:
    case e_Dup:
    case e_Inv:
    case e_Ins:
    case e_Conv:
    case e_Delins:
    case e_Repeat:
    case e_Prot_ext:
    case e_Frameshift:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CSimpleVariant_Base::C_Type::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Na_identity:
        (m_object = new(pool) ncbi::objects::CNaIdentity())->AddReference();
        break;
    case e_Na_sub:
        (m_object = new(pool) ncbi::objects::CNaSub())->AddReference();
        break;
    case e_Prot_sub:
        (m_object = new(pool) ncbi::objects::CProteinSub())->AddReference();
        break;
    case e_Prot_silent:
        (m_object = new(pool) ncbi::objects::CAaLocation())->AddReference();
        break;
    case e_Del:
        (m_object = new(pool) ncbi::objects::CDeletion())->AddReference();
        break;
    case e_Dup:
        (m_object = new(pool) ncbi::objects::CDuplication())->AddReference();
        break;
    case e_Inv:
        (m_object = new(pool) ncbi::objects::CInversion())->AddReference();
        break;
    case e_Ins:
        (m_object = new(pool) ncbi::objects::CInsertion())->AddReference();
        break;
    case e_Conv:
        (m_object = new(pool) ncbi::objects::CConversion())->AddReference();
        break;
    case e_Delins:
        (m_object = new(pool) ncbi::objects::CDelins())->AddReference();
        break;
    case e_Repeat:
        (m_object = new(pool) ncbi::objects::CRepeat())->AddReference();
        break;
    case e_Prot_ext:
        (m_object = new(pool) ncbi::objects::CProteinExtension())->AddReference();
        break;
    case e_Frameshift:
        (m_object = new(pool) ncbi::objects::CFrameshift())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CSimpleVariant_Base::C_Type::sm_SelectionNames[] = {
    "not set",
    "na-identity",
    "na-sub",
    "prot-sub",
    "prot-silent",
    "del",
    "dup",
    "inv",
    "ins",
    "conv",
    "delins",
    "repeat",
    "prot-ext",
    "frameshift"
};
 
NCBI_NS_STD::string CSimpleVariant_Base::C_Type::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CSimpleVariant_Base::C_Type::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 CSimpleVariant_Base::C_Type::TNa_identity& CSimpleVariant_Base::C_Type::GetNa_identity(void) const
{
    CheckSelected(e_Na_identity);
    return *static_cast<const TNa_identity*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TNa_identity& CSimpleVariant_Base::C_Type::SetNa_identity(void)
{
    Select(e_Na_identity, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNa_identity*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetNa_identity(CSimpleVariant_Base::C_Type::TNa_identity& value)
{
    TNa_identity* ptr = &value;
    if ( m_choice != e_Na_identity || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Na_identity;
    }
}
 
const CSimpleVariant_Base::C_Type::TNa_sub& CSimpleVariant_Base::C_Type::GetNa_sub(void) const
{
    CheckSelected(e_Na_sub);
    return *static_cast<const TNa_sub*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TNa_sub& CSimpleVariant_Base::C_Type::SetNa_sub(void)
{
    Select(e_Na_sub, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNa_sub*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetNa_sub(CSimpleVariant_Base::C_Type::TNa_sub& value)
{
    TNa_sub* ptr = &value;
    if ( m_choice != e_Na_sub || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Na_sub;
    }
}
 
const CSimpleVariant_Base::C_Type::TProt_sub& CSimpleVariant_Base::C_Type::GetProt_sub(void) const
{
    CheckSelected(e_Prot_sub);
    return *static_cast<const TProt_sub*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TProt_sub& CSimpleVariant_Base::C_Type::SetProt_sub(void)
{
    Select(e_Prot_sub, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TProt_sub*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetProt_sub(CSimpleVariant_Base::C_Type::TProt_sub& value)
{
    TProt_sub* ptr = &value;
    if ( m_choice != e_Prot_sub || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Prot_sub;
    }
}
 
const CSimpleVariant_Base::C_Type::TProt_silent& CSimpleVariant_Base::C_Type::GetProt_silent(void) const
{
    CheckSelected(e_Prot_silent);
    return *static_cast<const TProt_silent*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TProt_silent& CSimpleVariant_Base::C_Type::SetProt_silent(void)
{
    Select(e_Prot_silent, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TProt_silent*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetProt_silent(CSimpleVariant_Base::C_Type::TProt_silent& value)
{
    TProt_silent* ptr = &value;
    if ( m_choice != e_Prot_silent || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Prot_silent;
    }
}
 
const CSimpleVariant_Base::C_Type::TDel& CSimpleVariant_Base::C_Type::GetDel(void) const
{
    CheckSelected(e_Del);
    return *static_cast<const TDel*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TDel& CSimpleVariant_Base::C_Type::SetDel(void)
{
    Select(e_Del, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDel*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetDel(CSimpleVariant_Base::C_Type::TDel& value)
{
    TDel* ptr = &value;
    if ( m_choice != e_Del || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Del;
    }
}
 
const CSimpleVariant_Base::C_Type::TDup& CSimpleVariant_Base::C_Type::GetDup(void) const
{
    CheckSelected(e_Dup);
    return *static_cast<const TDup*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TDup& CSimpleVariant_Base::C_Type::SetDup(void)
{
    Select(e_Dup, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDup*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetDup(CSimpleVariant_Base::C_Type::TDup& value)
{
    TDup* ptr = &value;
    if ( m_choice != e_Dup || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Dup;
    }
}
 
const CSimpleVariant_Base::C_Type::TInv& CSimpleVariant_Base::C_Type::GetInv(void) const
{
    CheckSelected(e_Inv);
    return *static_cast<const TInv*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TInv& CSimpleVariant_Base::C_Type::SetInv(void)
{
    Select(e_Inv, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TInv*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetInv(CSimpleVariant_Base::C_Type::TInv& value)
{
    TInv* ptr = &value;
    if ( m_choice != e_Inv || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Inv;
    }
}
 
const CSimpleVariant_Base::C_Type::TIns& CSimpleVariant_Base::C_Type::GetIns(void) const
{
    CheckSelected(e_Ins);
    return *static_cast<const TIns*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TIns& CSimpleVariant_Base::C_Type::SetIns(void)
{
    Select(e_Ins, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TIns*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetIns(CSimpleVariant_Base::C_Type::TIns& value)
{
    TIns* ptr = &value;
    if ( m_choice != e_Ins || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Ins;
    }
}
 
const CSimpleVariant_Base::C_Type::TConv& CSimpleVariant_Base::C_Type::GetConv(void) const
{
    CheckSelected(e_Conv);
    return *static_cast<const TConv*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TConv& CSimpleVariant_Base::C_Type::SetConv(void)
{
    Select(e_Conv, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TConv*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetConv(CSimpleVariant_Base::C_Type::TConv& value)
{
    TConv* ptr = &value;
    if ( m_choice != e_Conv || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Conv;
    }
}
 
const CSimpleVariant_Base::C_Type::TDelins& CSimpleVariant_Base::C_Type::GetDelins(void) const
{
    CheckSelected(e_Delins);
    return *static_cast<const TDelins*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TDelins& CSimpleVariant_Base::C_Type::SetDelins(void)
{
    Select(e_Delins, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDelins*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetDelins(CSimpleVariant_Base::C_Type::TDelins& value)
{
    TDelins* ptr = &value;
    if ( m_choice != e_Delins || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Delins;
    }
}
 
const CSimpleVariant_Base::C_Type::TRepeat& CSimpleVariant_Base::C_Type::GetRepeat(void) const
{
    CheckSelected(e_Repeat);
    return *static_cast<const TRepeat*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TRepeat& CSimpleVariant_Base::C_Type::SetRepeat(void)
{
    Select(e_Repeat, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TRepeat*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetRepeat(CSimpleVariant_Base::C_Type::TRepeat& value)
{
    TRepeat* ptr = &value;
    if ( m_choice != e_Repeat || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Repeat;
    }
}
 
const CSimpleVariant_Base::C_Type::TProt_ext& CSimpleVariant_Base::C_Type::GetProt_ext(void) const
{
    CheckSelected(e_Prot_ext);
    return *static_cast<const TProt_ext*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TProt_ext& CSimpleVariant_Base::C_Type::SetProt_ext(void)
{
    Select(e_Prot_ext, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TProt_ext*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetProt_ext(CSimpleVariant_Base::C_Type::TProt_ext& value)
{
    TProt_ext* ptr = &value;
    if ( m_choice != e_Prot_ext || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Prot_ext;
    }
}
 
const CSimpleVariant_Base::C_Type::TFrameshift& CSimpleVariant_Base::C_Type::GetFrameshift(void) const
{
    CheckSelected(e_Frameshift);
    return *static_cast<const TFrameshift*>(m_object);
}
 
CSimpleVariant_Base::C_Type::TFrameshift& CSimpleVariant_Base::C_Type::SetFrameshift(void)
{
    Select(e_Frameshift, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFrameshift*>(m_object);
}
 
void CSimpleVariant_Base::C_Type::SetFrameshift(CSimpleVariant_Base::C_Type::TFrameshift& value)
{
    TFrameshift* ptr = &value;
    if ( m_choice != e_Frameshift || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Frameshift;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CSimpleVariant_Base::C_Type)
{
    SET_INTERNAL_NAME("SimpleVariant", "type");
    SET_CHOICE_MODULE("NCBI-VariationIRep");
    ADD_NAMED_REF_CHOICE_VARIANT("na-identity", m_object, CNaIdentity);
    ADD_NAMED_REF_CHOICE_VARIANT("na-sub", m_object, CNaSub);
    ADD_NAMED_REF_CHOICE_VARIANT("prot-sub", m_object, CProteinSub);
    ADD_NAMED_REF_CHOICE_VARIANT("prot-silent", m_object, CAaLocation);
    ADD_NAMED_REF_CHOICE_VARIANT("del", m_object, CDeletion);
    ADD_NAMED_REF_CHOICE_VARIANT("dup", m_object, CDuplication);
    ADD_NAMED_REF_CHOICE_VARIANT("inv", m_object, CInversion);
    ADD_NAMED_REF_CHOICE_VARIANT("ins", m_object, CInsertion);
    ADD_NAMED_REF_CHOICE_VARIANT("conv", m_object, CConversion);
    ADD_NAMED_REF_CHOICE_VARIANT("delins", m_object, CDelins);
    ADD_NAMED_REF_CHOICE_VARIANT("repeat", m_object, CRepeat);
    ADD_NAMED_REF_CHOICE_VARIANT("prot-ext", m_object, CProteinExtension);
    ADD_NAMED_REF_CHOICE_VARIANT("frameshift", m_object, CFrameshift);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eASN);
}
END_CHOICE_INFO
 
// constructor
CSimpleVariant_Base::C_Type::C_Type(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CSimpleVariant_Base::C_Type::~C_Type(void)
{
    Reset();
}
 
 
void CSimpleVariant_Base::ResetType(void)
{
    if ( !m_Type ) {
        m_Type.Reset(new TType());
        return;
    }
    (*m_Type).Reset();
}
 
void CSimpleVariant_Base::SetType(CSimpleVariant_Base::TType& value)
{
    m_Type.Reset(&value);
}
 
void CSimpleVariant_Base::Reset(void)
{
    ResetType();
    ResetFuzzy();
}
 
BEGIN_NAMED_BASE_CLASS_INFO("SimpleVariant", CSimpleVariant)
{
    SET_CLASS_MODULE("NCBI-VariationIRep");
    ADD_NAMED_REF_MEMBER("type", m_Type, C_Type);
    ADD_NAMED_STD_MEMBER("fuzzy", m_Fuzzy)->SetDefault(new TFuzzy(false))->SetSetFlag(MEMBER_PTR(m_set_State[0]))->SetOptional();
    info->RandomOrder();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eASN);
}
END_CLASS_INFO
 
// constructor
CSimpleVariant_Base::CSimpleVariant_Base(void)
    : m_Fuzzy(false)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetType();
    }
}
 
// destructor
CSimpleVariant_Base::~CSimpleVariant_Base(void)
{
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE