Cn_content_.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:
 *   'pubmed_mathml3.xsd'.
 *
 * 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 <objtools/eutils/efetch/Cn_content.hpp>
#include <objtools/eutils/efetch/Maction.hpp>
#include <objtools/eutils/efetch/Maligngroup.hpp>
#include <objtools/eutils/efetch/Malignmark.hpp>
#include <objtools/eutils/efetch/Menclose.hpp>
#include <objtools/eutils/efetch/Merror.hpp>
#include <objtools/eutils/efetch/Mfenced.hpp>
#include <objtools/eutils/efetch/Mfrac.hpp>
#include <objtools/eutils/efetch/Mglyph.hpp>
#include <objtools/eutils/efetch/Mi.hpp>
#include <objtools/eutils/efetch/Mlongdiv.hpp>
#include <objtools/eutils/efetch/Mmultiscripts.hpp>
#include <objtools/eutils/efetch/Mn.hpp>
#include <objtools/eutils/efetch/Mo.hpp>
#include <objtools/eutils/efetch/Mover.hpp>
#include <objtools/eutils/efetch/Mpadded.hpp>
#include <objtools/eutils/efetch/Mphantom.hpp>
#include <objtools/eutils/efetch/Mroot.hpp>
#include <objtools/eutils/efetch/Mrow.hpp>
#include <objtools/eutils/efetch/Ms.hpp>
#include <objtools/eutils/efetch/Mspace.hpp>
#include <objtools/eutils/efetch/Msqrt.hpp>
#include <objtools/eutils/efetch/Mstack.hpp>
#include <objtools/eutils/efetch/Mstyle.hpp>
#include <objtools/eutils/efetch/Msub.hpp>
#include <objtools/eutils/efetch/Msubsup.hpp>
#include <objtools/eutils/efetch/Msup.hpp>
#include <objtools/eutils/efetch/Mtable.hpp>
#include <objtools/eutils/efetch/Mtext.hpp>
#include <objtools/eutils/efetch/Munder.hpp>
#include <objtools/eutils/efetch/Munderover.hpp>
#include <objtools/eutils/efetch/Sep.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Mi:
    case e_Mn:
    case e_Mo:
    case e_Mtext:
    case e_Mspace:
    case e_Ms:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Mi:
        (m_object = new(pool) ncbi::objects::CMi())->AddReference();
        break;
    case e_Mn:
        (m_object = new(pool) ncbi::objects::CMn())->AddReference();
        break;
    case e_Mo:
        (m_object = new(pool) ncbi::objects::CMo())->AddReference();
        break;
    case e_Mtext:
        (m_object = new(pool) ncbi::objects::CMtext())->AddReference();
        break;
    case e_Mspace:
        (m_object = new(pool) ncbi::objects::CMspace())->AddReference();
        break;
    case e_Ms:
        (m_object = new(pool) ncbi::objects::CMs())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::sm_SelectionNames[] = {
    "not set",
    "mi",
    "mn",
    "mo",
    "mtext",
    "mspace",
    "ms"
};
 
NCBI_NS_STD::string CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::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 CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMi& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMi(void) const
{
    CheckSelected(e_Mi);
    return *static_cast<const TMi*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMi& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMi(void)
{
    Select(e_Mi, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMi*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMi(CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMi& value)
{
    TMi* ptr = &value;
    if ( m_choice != e_Mi || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mi;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMn& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMn(void) const
{
    CheckSelected(e_Mn);
    return *static_cast<const TMn*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMn& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMn(void)
{
    Select(e_Mn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMn*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMn(CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMn& value)
{
    TMn* ptr = &value;
    if ( m_choice != e_Mn || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mn;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMo& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMo(void) const
{
    CheckSelected(e_Mo);
    return *static_cast<const TMo*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMo& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMo(void)
{
    Select(e_Mo, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMo*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMo(CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMo& value)
{
    TMo* ptr = &value;
    if ( m_choice != e_Mo || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mo;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMtext& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMtext(void) const
{
    CheckSelected(e_Mtext);
    return *static_cast<const TMtext*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMtext& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMtext(void)
{
    Select(e_Mtext, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMtext*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMtext(CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMtext& value)
{
    TMtext* ptr = &value;
    if ( m_choice != e_Mtext || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mtext;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMspace& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMspace(void) const
{
    CheckSelected(e_Mspace);
    return *static_cast<const TMspace*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMspace& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMspace(void)
{
    Select(e_Mspace, NCBI_NS_NCBI::eDoNotResetVariant);
    CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMspace& value = *static_cast<TMspace*>(m_object);
    value.SetMspace();
    return value;
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMs& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::GetMs(void) const
{
    CheckSelected(e_Ms);
    return *static_cast<const TMs*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMs& CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMs(void)
{
    Select(e_Ms, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMs*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::SetMs(CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::TMs& value)
{
    TMs* ptr = &value;
    if ( m_choice != e_Ms || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Ms;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression)
{
    SET_INTERNAL_NAME("cn.content.E.PresentationExpression", "TokenExpression");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("mi", m_object, CMi)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mn", m_object, CMn)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mo", m_object, CMo)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mtext", m_object, CMtext)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mspace", m_object, CMspace)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("ms", m_object, CMs)->SetNsQualified(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::C_TokenExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CCn_content_Base::C_E::C_PresentationExpression::C_TokenExpression::~C_TokenExpression(void)
{
    Reset();
}
 
 
void CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Maligngroup:
    case e_Malignmark:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Maligngroup:
        (m_object = new(pool) ncbi::objects::CMaligngroup())->AddReference();
        break;
    case e_Malignmark:
        (m_object = new(pool) ncbi::objects::CMalignmark())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::sm_SelectionNames[] = {
    "not set",
    "maligngroup",
    "malignmark"
};
 
NCBI_NS_STD::string CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::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 CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMaligngroup& CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::GetMaligngroup(void) const
{
    CheckSelected(e_Maligngroup);
    return *static_cast<const TMaligngroup*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMaligngroup& CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::SetMaligngroup(void)
{
    Select(e_Maligngroup, NCBI_NS_NCBI::eDoNotResetVariant);
    CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMaligngroup& value = *static_cast<TMaligngroup*>(m_object);
    value.SetMaligngroup();
    return value;
}
 
const CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMalignmark& CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::GetMalignmark(void) const
{
    CheckSelected(e_Malignmark);
    return *static_cast<const TMalignmark*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMalignmark& CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::SetMalignmark(void)
{
    Select(e_Malignmark, NCBI_NS_NCBI::eDoNotResetVariant);
    CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::TMalignmark& value = *static_cast<TMalignmark*>(m_object);
    value.SetMalignmark();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression)
{
    SET_INTERNAL_NAME("cn.content.E.PresentationExpression", "MalignExpression");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("maligngroup", m_object, CMaligngroup)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("malignmark", m_object, CMalignmark)->SetNsQualified(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::C_MalignExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CCn_content_Base::C_E::C_PresentationExpression::C_MalignExpression::~C_MalignExpression(void)
{
    Reset();
}
 
 
void CCn_content_Base::C_E::C_PresentationExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CCn_content_Base::C_E::C_PresentationExpression::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_TokenExpression:
    case e_MalignExpression:
    case e_Mrow:
    case e_Mfrac:
    case e_Msqrt:
    case e_Mroot:
    case e_Mstyle:
    case e_Merror:
    case e_Mpadded:
    case e_Mphantom:
    case e_Mfenced:
    case e_Menclose:
    case e_Msub:
    case e_Msup:
    case e_Msubsup:
    case e_Munder:
    case e_Mover:
    case e_Munderover:
    case e_Mmultiscripts:
    case e_Mtable:
    case e_Mstack:
    case e_Mlongdiv:
    case e_Maction:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CCn_content_Base::C_E::C_PresentationExpression::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_TokenExpression:
        (m_object = new(pool) C_TokenExpression())->AddReference();
        break;
    case e_MalignExpression:
        (m_object = new(pool) C_MalignExpression())->AddReference();
        break;
    case e_Mrow:
        (m_object = new(pool) ncbi::objects::CMrow())->AddReference();
        break;
    case e_Mfrac:
        (m_object = new(pool) ncbi::objects::CMfrac())->AddReference();
        break;
    case e_Msqrt:
        (m_object = new(pool) ncbi::objects::CMsqrt())->AddReference();
        break;
    case e_Mroot:
        (m_object = new(pool) ncbi::objects::CMroot())->AddReference();
        break;
    case e_Mstyle:
        (m_object = new(pool) ncbi::objects::CMstyle())->AddReference();
        break;
    case e_Merror:
        (m_object = new(pool) ncbi::objects::CMerror())->AddReference();
        break;
    case e_Mpadded:
        (m_object = new(pool) ncbi::objects::CMpadded())->AddReference();
        break;
    case e_Mphantom:
        (m_object = new(pool) ncbi::objects::CMphantom())->AddReference();
        break;
    case e_Mfenced:
        (m_object = new(pool) ncbi::objects::CMfenced())->AddReference();
        break;
    case e_Menclose:
        (m_object = new(pool) ncbi::objects::CMenclose())->AddReference();
        break;
    case e_Msub:
        (m_object = new(pool) ncbi::objects::CMsub())->AddReference();
        break;
    case e_Msup:
        (m_object = new(pool) ncbi::objects::CMsup())->AddReference();
        break;
    case e_Msubsup:
        (m_object = new(pool) ncbi::objects::CMsubsup())->AddReference();
        break;
    case e_Munder:
        (m_object = new(pool) ncbi::objects::CMunder())->AddReference();
        break;
    case e_Mover:
        (m_object = new(pool) ncbi::objects::CMover())->AddReference();
        break;
    case e_Munderover:
        (m_object = new(pool) ncbi::objects::CMunderover())->AddReference();
        break;
    case e_Mmultiscripts:
        (m_object = new(pool) ncbi::objects::CMmultiscripts())->AddReference();
        break;
    case e_Mtable:
        (m_object = new(pool) ncbi::objects::CMtable())->AddReference();
        break;
    case e_Mstack:
        (m_object = new(pool) ncbi::objects::CMstack())->AddReference();
        break;
    case e_Mlongdiv:
        (m_object = new(pool) ncbi::objects::CMlongdiv())->AddReference();
        break;
    case e_Maction:
        (m_object = new(pool) ncbi::objects::CMaction())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CCn_content_Base::C_E::C_PresentationExpression::sm_SelectionNames[] = {
    "not set",
    "TokenExpression",
    "MalignExpression",
    "mrow",
    "mfrac",
    "msqrt",
    "mroot",
    "mstyle",
    "merror",
    "mpadded",
    "mphantom",
    "mfenced",
    "menclose",
    "msub",
    "msup",
    "msubsup",
    "munder",
    "mover",
    "munderover",
    "mmultiscripts",
    "mtable",
    "mstack",
    "mlongdiv",
    "maction"
};
 
NCBI_NS_STD::string CCn_content_Base::C_E::C_PresentationExpression::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CCn_content_Base::C_E::C_PresentationExpression::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 CCn_content_Base::C_E::C_PresentationExpression::TTokenExpression& CCn_content_Base::C_E::C_PresentationExpression::GetTokenExpression(void) const
{
    CheckSelected(e_TokenExpression);
    return *static_cast<const TTokenExpression*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TTokenExpression& CCn_content_Base::C_E::C_PresentationExpression::SetTokenExpression(void)
{
    Select(e_TokenExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TTokenExpression*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetTokenExpression(CCn_content_Base::C_E::C_PresentationExpression::TTokenExpression& value)
{
    TTokenExpression* ptr = &value;
    if ( m_choice != e_TokenExpression || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_TokenExpression;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMalignExpression& CCn_content_Base::C_E::C_PresentationExpression::GetMalignExpression(void) const
{
    CheckSelected(e_MalignExpression);
    return *static_cast<const TMalignExpression*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMalignExpression& CCn_content_Base::C_E::C_PresentationExpression::SetMalignExpression(void)
{
    Select(e_MalignExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMalignExpression*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMalignExpression(CCn_content_Base::C_E::C_PresentationExpression::TMalignExpression& value)
{
    TMalignExpression* ptr = &value;
    if ( m_choice != e_MalignExpression || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_MalignExpression;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMrow& CCn_content_Base::C_E::C_PresentationExpression::GetMrow(void) const
{
    CheckSelected(e_Mrow);
    return *static_cast<const TMrow*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMrow& CCn_content_Base::C_E::C_PresentationExpression::SetMrow(void)
{
    Select(e_Mrow, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMrow*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMrow(CCn_content_Base::C_E::C_PresentationExpression::TMrow& value)
{
    TMrow* ptr = &value;
    if ( m_choice != e_Mrow || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mrow;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMfrac& CCn_content_Base::C_E::C_PresentationExpression::GetMfrac(void) const
{
    CheckSelected(e_Mfrac);
    return *static_cast<const TMfrac*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMfrac& CCn_content_Base::C_E::C_PresentationExpression::SetMfrac(void)
{
    Select(e_Mfrac, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMfrac*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMfrac(CCn_content_Base::C_E::C_PresentationExpression::TMfrac& value)
{
    TMfrac* ptr = &value;
    if ( m_choice != e_Mfrac || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mfrac;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMsqrt& CCn_content_Base::C_E::C_PresentationExpression::GetMsqrt(void) const
{
    CheckSelected(e_Msqrt);
    return *static_cast<const TMsqrt*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMsqrt& CCn_content_Base::C_E::C_PresentationExpression::SetMsqrt(void)
{
    Select(e_Msqrt, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsqrt*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMsqrt(CCn_content_Base::C_E::C_PresentationExpression::TMsqrt& value)
{
    TMsqrt* ptr = &value;
    if ( m_choice != e_Msqrt || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Msqrt;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMroot& CCn_content_Base::C_E::C_PresentationExpression::GetMroot(void) const
{
    CheckSelected(e_Mroot);
    return *static_cast<const TMroot*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMroot& CCn_content_Base::C_E::C_PresentationExpression::SetMroot(void)
{
    Select(e_Mroot, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMroot*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMroot(CCn_content_Base::C_E::C_PresentationExpression::TMroot& value)
{
    TMroot* ptr = &value;
    if ( m_choice != e_Mroot || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mroot;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMstyle& CCn_content_Base::C_E::C_PresentationExpression::GetMstyle(void) const
{
    CheckSelected(e_Mstyle);
    return *static_cast<const TMstyle*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMstyle& CCn_content_Base::C_E::C_PresentationExpression::SetMstyle(void)
{
    Select(e_Mstyle, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMstyle*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMstyle(CCn_content_Base::C_E::C_PresentationExpression::TMstyle& value)
{
    TMstyle* ptr = &value;
    if ( m_choice != e_Mstyle || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mstyle;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMerror& CCn_content_Base::C_E::C_PresentationExpression::GetMerror(void) const
{
    CheckSelected(e_Merror);
    return *static_cast<const TMerror*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMerror& CCn_content_Base::C_E::C_PresentationExpression::SetMerror(void)
{
    Select(e_Merror, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMerror*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMerror(CCn_content_Base::C_E::C_PresentationExpression::TMerror& value)
{
    TMerror* ptr = &value;
    if ( m_choice != e_Merror || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Merror;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMpadded& CCn_content_Base::C_E::C_PresentationExpression::GetMpadded(void) const
{
    CheckSelected(e_Mpadded);
    return *static_cast<const TMpadded*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMpadded& CCn_content_Base::C_E::C_PresentationExpression::SetMpadded(void)
{
    Select(e_Mpadded, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMpadded*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMpadded(CCn_content_Base::C_E::C_PresentationExpression::TMpadded& value)
{
    TMpadded* ptr = &value;
    if ( m_choice != e_Mpadded || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mpadded;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMphantom& CCn_content_Base::C_E::C_PresentationExpression::GetMphantom(void) const
{
    CheckSelected(e_Mphantom);
    return *static_cast<const TMphantom*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMphantom& CCn_content_Base::C_E::C_PresentationExpression::SetMphantom(void)
{
    Select(e_Mphantom, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMphantom*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMphantom(CCn_content_Base::C_E::C_PresentationExpression::TMphantom& value)
{
    TMphantom* ptr = &value;
    if ( m_choice != e_Mphantom || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mphantom;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMfenced& CCn_content_Base::C_E::C_PresentationExpression::GetMfenced(void) const
{
    CheckSelected(e_Mfenced);
    return *static_cast<const TMfenced*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMfenced& CCn_content_Base::C_E::C_PresentationExpression::SetMfenced(void)
{
    Select(e_Mfenced, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMfenced*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMfenced(CCn_content_Base::C_E::C_PresentationExpression::TMfenced& value)
{
    TMfenced* ptr = &value;
    if ( m_choice != e_Mfenced || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mfenced;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMenclose& CCn_content_Base::C_E::C_PresentationExpression::GetMenclose(void) const
{
    CheckSelected(e_Menclose);
    return *static_cast<const TMenclose*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMenclose& CCn_content_Base::C_E::C_PresentationExpression::SetMenclose(void)
{
    Select(e_Menclose, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMenclose*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMenclose(CCn_content_Base::C_E::C_PresentationExpression::TMenclose& value)
{
    TMenclose* ptr = &value;
    if ( m_choice != e_Menclose || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Menclose;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMsub& CCn_content_Base::C_E::C_PresentationExpression::GetMsub(void) const
{
    CheckSelected(e_Msub);
    return *static_cast<const TMsub*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMsub& CCn_content_Base::C_E::C_PresentationExpression::SetMsub(void)
{
    Select(e_Msub, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsub*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMsub(CCn_content_Base::C_E::C_PresentationExpression::TMsub& value)
{
    TMsub* ptr = &value;
    if ( m_choice != e_Msub || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Msub;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMsup& CCn_content_Base::C_E::C_PresentationExpression::GetMsup(void) const
{
    CheckSelected(e_Msup);
    return *static_cast<const TMsup*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMsup& CCn_content_Base::C_E::C_PresentationExpression::SetMsup(void)
{
    Select(e_Msup, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsup*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMsup(CCn_content_Base::C_E::C_PresentationExpression::TMsup& value)
{
    TMsup* ptr = &value;
    if ( m_choice != e_Msup || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Msup;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMsubsup& CCn_content_Base::C_E::C_PresentationExpression::GetMsubsup(void) const
{
    CheckSelected(e_Msubsup);
    return *static_cast<const TMsubsup*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMsubsup& CCn_content_Base::C_E::C_PresentationExpression::SetMsubsup(void)
{
    Select(e_Msubsup, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsubsup*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMsubsup(CCn_content_Base::C_E::C_PresentationExpression::TMsubsup& value)
{
    TMsubsup* ptr = &value;
    if ( m_choice != e_Msubsup || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Msubsup;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMunder& CCn_content_Base::C_E::C_PresentationExpression::GetMunder(void) const
{
    CheckSelected(e_Munder);
    return *static_cast<const TMunder*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMunder& CCn_content_Base::C_E::C_PresentationExpression::SetMunder(void)
{
    Select(e_Munder, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMunder*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMunder(CCn_content_Base::C_E::C_PresentationExpression::TMunder& value)
{
    TMunder* ptr = &value;
    if ( m_choice != e_Munder || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Munder;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMover& CCn_content_Base::C_E::C_PresentationExpression::GetMover(void) const
{
    CheckSelected(e_Mover);
    return *static_cast<const TMover*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMover& CCn_content_Base::C_E::C_PresentationExpression::SetMover(void)
{
    Select(e_Mover, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMover*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMover(CCn_content_Base::C_E::C_PresentationExpression::TMover& value)
{
    TMover* ptr = &value;
    if ( m_choice != e_Mover || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mover;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMunderover& CCn_content_Base::C_E::C_PresentationExpression::GetMunderover(void) const
{
    CheckSelected(e_Munderover);
    return *static_cast<const TMunderover*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMunderover& CCn_content_Base::C_E::C_PresentationExpression::SetMunderover(void)
{
    Select(e_Munderover, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMunderover*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMunderover(CCn_content_Base::C_E::C_PresentationExpression::TMunderover& value)
{
    TMunderover* ptr = &value;
    if ( m_choice != e_Munderover || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Munderover;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMmultiscripts& CCn_content_Base::C_E::C_PresentationExpression::GetMmultiscripts(void) const
{
    CheckSelected(e_Mmultiscripts);
    return *static_cast<const TMmultiscripts*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMmultiscripts& CCn_content_Base::C_E::C_PresentationExpression::SetMmultiscripts(void)
{
    Select(e_Mmultiscripts, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMmultiscripts*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMmultiscripts(CCn_content_Base::C_E::C_PresentationExpression::TMmultiscripts& value)
{
    TMmultiscripts* ptr = &value;
    if ( m_choice != e_Mmultiscripts || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mmultiscripts;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMtable& CCn_content_Base::C_E::C_PresentationExpression::GetMtable(void) const
{
    CheckSelected(e_Mtable);
    return *static_cast<const TMtable*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMtable& CCn_content_Base::C_E::C_PresentationExpression::SetMtable(void)
{
    Select(e_Mtable, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMtable*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMtable(CCn_content_Base::C_E::C_PresentationExpression::TMtable& value)
{
    TMtable* ptr = &value;
    if ( m_choice != e_Mtable || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mtable;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMstack& CCn_content_Base::C_E::C_PresentationExpression::GetMstack(void) const
{
    CheckSelected(e_Mstack);
    return *static_cast<const TMstack*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMstack& CCn_content_Base::C_E::C_PresentationExpression::SetMstack(void)
{
    Select(e_Mstack, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMstack*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMstack(CCn_content_Base::C_E::C_PresentationExpression::TMstack& value)
{
    TMstack* ptr = &value;
    if ( m_choice != e_Mstack || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mstack;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMlongdiv& CCn_content_Base::C_E::C_PresentationExpression::GetMlongdiv(void) const
{
    CheckSelected(e_Mlongdiv);
    return *static_cast<const TMlongdiv*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMlongdiv& CCn_content_Base::C_E::C_PresentationExpression::SetMlongdiv(void)
{
    Select(e_Mlongdiv, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMlongdiv*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMlongdiv(CCn_content_Base::C_E::C_PresentationExpression::TMlongdiv& value)
{
    TMlongdiv* ptr = &value;
    if ( m_choice != e_Mlongdiv || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Mlongdiv;
    }
}
 
const CCn_content_Base::C_E::C_PresentationExpression::TMaction& CCn_content_Base::C_E::C_PresentationExpression::GetMaction(void) const
{
    CheckSelected(e_Maction);
    return *static_cast<const TMaction*>(m_object);
}
 
CCn_content_Base::C_E::C_PresentationExpression::TMaction& CCn_content_Base::C_E::C_PresentationExpression::SetMaction(void)
{
    Select(e_Maction, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMaction*>(m_object);
}
 
void CCn_content_Base::C_E::C_PresentationExpression::SetMaction(CCn_content_Base::C_E::C_PresentationExpression::TMaction& value)
{
    TMaction* ptr = &value;
    if ( m_choice != e_Maction || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Maction;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CCn_content_Base::C_E::C_PresentationExpression)
{
    SET_INTERNAL_NAME("cn.content.E", "PresentationExpression");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("TokenExpression", m_object, C_TokenExpression)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("MalignExpression", m_object, C_MalignExpression)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("mrow", m_object, CMrow)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mfrac", m_object, CMfrac)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("msqrt", m_object, CMsqrt)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mroot", m_object, CMroot)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mstyle", m_object, CMstyle)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("merror", m_object, CMerror)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mpadded", m_object, CMpadded)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mphantom", m_object, CMphantom)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mfenced", m_object, CMfenced)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("menclose", m_object, CMenclose)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("msub", m_object, CMsub)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("msup", m_object, CMsup)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("msubsup", m_object, CMsubsup)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("munder", m_object, CMunder)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mover", m_object, CMover)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("munderover", m_object, CMunderover)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mmultiscripts", m_object, CMmultiscripts)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mtable", m_object, CMtable)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mstack", m_object, CMstack)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mlongdiv", m_object, CMlongdiv)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("maction", m_object, CMaction)->SetNsQualified(true);
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CCn_content_Base::C_E::C_PresentationExpression::C_PresentationExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CCn_content_Base::C_E::C_PresentationExpression::~C_PresentationExpression(void)
{
    Reset();
}
 
 
void CCn_content_Base::C_E::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CCn_content_Base::C_E::ResetSelection(void)
{
    switch ( m_choice ) {
    case e__CharData:
        m_string.Destruct();
        break;
    case e_Mglyph:
    case e_Sep:
    case e_PresentationExpression:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CCn_content_Base::C_E::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Mglyph:
        (m_object = new(pool) ncbi::objects::CMglyph())->AddReference();
        break;
    case e_Sep:
        (m_object = new(pool) ncbi::objects::CSep())->AddReference();
        break;
    case e_PresentationExpression:
        (m_object = new(pool) C_PresentationExpression())->AddReference();
        break;
    case e__CharData:
        m_string.Construct();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CCn_content_Base::C_E::sm_SelectionNames[] = {
    "not set",
    "-CharData",
    "mglyph",
    "sep",
    "PresentationExpression"
};
 
NCBI_NS_STD::string CCn_content_Base::C_E::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CCn_content_Base::C_E::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]));
}
 
void CCn_content_Base::C_E::Set_CharData(const CCn_content_Base::C_E::T_CharData& value)
{
    Select(e__CharData, NCBI_NS_NCBI::eDoNotResetVariant);
    *m_string = value;
}
 
const CCn_content_Base::C_E::TMglyph& CCn_content_Base::C_E::GetMglyph(void) const
{
    CheckSelected(e_Mglyph);
    return *static_cast<const TMglyph*>(m_object);
}
 
CCn_content_Base::C_E::TMglyph& CCn_content_Base::C_E::SetMglyph(void)
{
    Select(e_Mglyph, NCBI_NS_NCBI::eDoNotResetVariant);
    CCn_content_Base::C_E::TMglyph& value = *static_cast<TMglyph*>(m_object);
    value.SetMglyph();
    return value;
}
 
const CCn_content_Base::C_E::TSep& CCn_content_Base::C_E::GetSep(void) const
{
    CheckSelected(e_Sep);
    return *static_cast<const TSep*>(m_object);
}
 
CCn_content_Base::C_E::TSep& CCn_content_Base::C_E::SetSep(void)
{
    Select(e_Sep, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSep*>(m_object);
}
 
void CCn_content_Base::C_E::SetSep(CCn_content_Base::C_E::TSep& value)
{
    TSep* ptr = &value;
    if ( m_choice != e_Sep || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Sep;
    }
}
 
const CCn_content_Base::C_E::TPresentationExpression& CCn_content_Base::C_E::GetPresentationExpression(void) const
{
    CheckSelected(e_PresentationExpression);
    return *static_cast<const TPresentationExpression*>(m_object);
}
 
CCn_content_Base::C_E::TPresentationExpression& CCn_content_Base::C_E::SetPresentationExpression(void)
{
    Select(e_PresentationExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPresentationExpression*>(m_object);
}
 
void CCn_content_Base::C_E::SetPresentationExpression(CCn_content_Base::C_E::TPresentationExpression& value)
{
    TPresentationExpression* ptr = &value;
    if ( m_choice != e_PresentationExpression || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_PresentationExpression;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CCn_content_Base::C_E)
{
    SET_INTERNAL_NAME("cn.content", "E");
    SET_CHOICE_MODULE("pubmed_mathml3");
    SET_NAMESPACE("http://www.w3.org/1998/Math/MathML")->SetNsQualified(false);
    ADD_NAMED_BUF_CHOICE_VARIANT("-CharData", m_string, STD, (string))->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("mglyph", m_object, CMglyph)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("sep", m_object, CSep)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("PresentationExpression", m_object, C_PresentationExpression)->SetNotag();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CCn_content_Base::C_E::C_E(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CCn_content_Base::C_E::~C_E(void)
{
    Reset();
}
 
 
void CCn_content_Base::Reset(void)
{
    m_data.clear();
    m_set_State[0] &= ~0x3;
}
 
BEGIN_NAMED_BASE_IMPLICIT_CLASS_INFO("cn.content", CCn_content)
{
    SET_CLASS_MODULE("pubmed_mathml3");
    SET_NAMESPACE("http://www.w3.org/1998/Math/MathML")->SetNsQualified(false);
    ADD_NAMED_MEMBER("", m_data, STL_list, (STL_CRef, (CLASS, (C_E))))->SetSetFlag(MEMBER_PTR(m_set_State[0]));
    info->RandomOrder();
    info->CodeVersion(22301);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CCn_content_Base::CCn_content_Base(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
}
 
// destructor
CCn_content_Base::~CCn_content_Base(void)
{
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE