MsrowExpression_.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/MsrowExpression.hpp>
#include <objtools/eutils/efetch/Abs.hpp>
#include <objtools/eutils/efetch/And.hpp>
#include <objtools/eutils/efetch/Apply.hpp>
#include <objtools/eutils/efetch/Approx.hpp>
#include <objtools/eutils/efetch/Arccos.hpp>
#include <objtools/eutils/efetch/Arccosh.hpp>
#include <objtools/eutils/efetch/Arccot.hpp>
#include <objtools/eutils/efetch/Arccoth.hpp>
#include <objtools/eutils/efetch/Arccsc.hpp>
#include <objtools/eutils/efetch/Arccsch.hpp>
#include <objtools/eutils/efetch/Arcsec.hpp>
#include <objtools/eutils/efetch/Arcsech.hpp>
#include <objtools/eutils/efetch/Arcsin.hpp>
#include <objtools/eutils/efetch/Arcsinh.hpp>
#include <objtools/eutils/efetch/Arctan.hpp>
#include <objtools/eutils/efetch/Arctanh.hpp>
#include <objtools/eutils/efetch/Arg.hpp>
#include <objtools/eutils/efetch/Bind.hpp>
#include <objtools/eutils/efetch/Card.hpp>
#include <objtools/eutils/efetch/Cartesianproduct.hpp>
#include <objtools/eutils/efetch/Cbytes.hpp>
#include <objtools/eutils/efetch/Ceiling.hpp>
#include <objtools/eutils/efetch/Cerror.hpp>
#include <objtools/eutils/efetch/Ci.hpp>
#include <objtools/eutils/efetch/Cn.hpp>
#include <objtools/eutils/efetch/Codomain.hpp>
#include <objtools/eutils/efetch/Complexes.hpp>
#include <objtools/eutils/efetch/Compose.hpp>
#include <objtools/eutils/efetch/Conjugate.hpp>
#include <objtools/eutils/efetch/Cos.hpp>
#include <objtools/eutils/efetch/Cosh.hpp>
#include <objtools/eutils/efetch/Cot.hpp>
#include <objtools/eutils/efetch/Coth.hpp>
#include <objtools/eutils/efetch/Cs.hpp>
#include <objtools/eutils/efetch/Csc.hpp>
#include <objtools/eutils/efetch/Csch.hpp>
#include <objtools/eutils/efetch/Csymbol.hpp>
#include <objtools/eutils/efetch/Curl.hpp>
#include <objtools/eutils/efetch/Declare.hpp>
#include <objtools/eutils/efetch/Determinant.hpp>
#include <objtools/eutils/efetch/Diff.hpp>
#include <objtools/eutils/efetch/Divergence.hpp>
#include <objtools/eutils/efetch/Divide.hpp>
#include <objtools/eutils/efetch/Domain.hpp>
#include <objtools/eutils/efetch/Emptyset.hpp>
#include <objtools/eutils/efetch/Eq.hpp>
#include <objtools/eutils/efetch/Equivalent.hpp>
#include <objtools/eutils/efetch/Eulergamma.hpp>
#include <objtools/eutils/efetch/Exists.hpp>
#include <objtools/eutils/efetch/Exp.hpp>
#include <objtools/eutils/efetch/Exponentiale.hpp>
#include <objtools/eutils/efetch/Factorial.hpp>
#include <objtools/eutils/efetch/Factorof.hpp>
#include <objtools/eutils/efetch/False.hpp>
#include <objtools/eutils/efetch/Floor.hpp>
#include <objtools/eutils/efetch/Fn.hpp>
#include <objtools/eutils/efetch/Forall.hpp>
#include <objtools/eutils/efetch/Gcd.hpp>
#include <objtools/eutils/efetch/Geq.hpp>
#include <objtools/eutils/efetch/Grad.hpp>
#include <objtools/eutils/efetch/Gt.hpp>
#include <objtools/eutils/efetch/Ident.hpp>
#include <objtools/eutils/efetch/Image.hpp>
#include <objtools/eutils/efetch/Imaginary.hpp>
#include <objtools/eutils/efetch/Imaginaryi.hpp>
#include <objtools/eutils/efetch/Implies.hpp>
#include <objtools/eutils/efetch/In.hpp>
#include <objtools/eutils/efetch/Infinity.hpp>
#include <objtools/eutils/efetch/Int.hpp>
#include <objtools/eutils/efetch/Integers.hpp>
#include <objtools/eutils/efetch/Intersect.hpp>
#include <objtools/eutils/efetch/Interval.hpp>
#include <objtools/eutils/efetch/Inverse.hpp>
#include <objtools/eutils/efetch/Lambda.hpp>
#include <objtools/eutils/efetch/Laplacian.hpp>
#include <objtools/eutils/efetch/Lcm.hpp>
#include <objtools/eutils/efetch/Leq.hpp>
#include <objtools/eutils/efetch/Limit.hpp>
#include <objtools/eutils/efetch/List.hpp>
#include <objtools/eutils/efetch/Ln.hpp>
#include <objtools/eutils/efetch/Log.hpp>
#include <objtools/eutils/efetch/Lt.hpp>
#include <objtools/eutils/efetch/Maction.hpp>
#include <objtools/eutils/efetch/Maligngroup.hpp>
#include <objtools/eutils/efetch/Malignmark.hpp>
#include <objtools/eutils/efetch/Matrix.hpp>
#include <objtools/eutils/efetch/Matrixrow.hpp>
#include <objtools/eutils/efetch/Max.hpp>
#include <objtools/eutils/efetch/Mean.hpp>
#include <objtools/eutils/efetch/Median.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/Mi.hpp>
#include <objtools/eutils/efetch/Min.hpp>
#include <objtools/eutils/efetch/Minus.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/Mode.hpp>
#include <objtools/eutils/efetch/Moment.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/Naturalnumbers.hpp>
#include <objtools/eutils/efetch/Neq.hpp>
#include <objtools/eutils/efetch/None.hpp>
#include <objtools/eutils/efetch/Not.hpp>
#include <objtools/eutils/efetch/Notanumber.hpp>
#include <objtools/eutils/efetch/Notin.hpp>
#include <objtools/eutils/efetch/Notprsubset.hpp>
#include <objtools/eutils/efetch/Notsubset.hpp>
#include <objtools/eutils/efetch/Or.hpp>
#include <objtools/eutils/efetch/Outerproduct.hpp>
#include <objtools/eutils/efetch/Partialdiff.hpp>
#include <objtools/eutils/efetch/Pi.hpp>
#include <objtools/eutils/efetch/Piecewise.hpp>
#include <objtools/eutils/efetch/Plus.hpp>
#include <objtools/eutils/efetch/Power.hpp>
#include <objtools/eutils/efetch/Primes.hpp>
#include <objtools/eutils/efetch/Product.hpp>
#include <objtools/eutils/efetch/Prsubset.hpp>
#include <objtools/eutils/efetch/Quotient.hpp>
#include <objtools/eutils/efetch/Rationals.hpp>
#include <objtools/eutils/efetch/Real.hpp>
#include <objtools/eutils/efetch/Reals.hpp>
#include <objtools/eutils/efetch/Reln.hpp>
#include <objtools/eutils/efetch/Rem.hpp>
#include <objtools/eutils/efetch/Root.hpp>
#include <objtools/eutils/efetch/Scalarproduct.hpp>
#include <objtools/eutils/efetch/Sdev.hpp>
#include <objtools/eutils/efetch/Sec.hpp>
#include <objtools/eutils/efetch/Sech.hpp>
#include <objtools/eutils/efetch/Selector.hpp>
#include <objtools/eutils/efetch/Semantics.hpp>
#include <objtools/eutils/efetch/Set.hpp>
#include <objtools/eutils/efetch/Setdiff.hpp>
#include <objtools/eutils/efetch/Share.hpp>
#include <objtools/eutils/efetch/Sin.hpp>
#include <objtools/eutils/efetch/Sinh.hpp>
#include <objtools/eutils/efetch/Subset.hpp>
#include <objtools/eutils/efetch/Sum.hpp>
#include <objtools/eutils/efetch/Tan.hpp>
#include <objtools/eutils/efetch/Tanh.hpp>
#include <objtools/eutils/efetch/Tendsto.hpp>
#include <objtools/eutils/efetch/Times.hpp>
#include <objtools/eutils/efetch/Transpose.hpp>
#include <objtools/eutils/efetch/True.hpp>
#include <objtools/eutils/efetch/Union.hpp>
#include <objtools/eutils/efetch/Variance.hpp>
#include <objtools/eutils/efetch/Vector.hpp>
#include <objtools/eutils/efetch/Vectorproduct.hpp>
#include <objtools/eutils/efetch/Xor.hpp>
BEGIN_NCBI_SCOPE
 
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// generated classes
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Reln:
    case e_Fn:
    case e_Declare:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Reln:
        (m_object = new(pool) ncbi::objects::CReln())->AddReference();
        break;
    case e_Fn:
        (m_object = new(pool) ncbi::objects::CFn())->AddReference();
        break;
    case e_Declare:
        (m_object = new(pool) ncbi::objects::CDeclare())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::sm_SelectionNames[] = {
    "not set",
    "reln",
    "fn",
    "declare"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TReln& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::GetReln(void) const
{
    CheckSelected(e_Reln);
    return *static_cast<const TReln*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TReln& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetReln(void)
{
    Select(e_Reln, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TReln*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetReln(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TReln& value)
{
    TReln* ptr = &value;
    if ( m_choice != e_Reln || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Reln;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TFn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::GetFn(void) const
{
    CheckSelected(e_Fn);
    return *static_cast<const TFn*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TFn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetFn(void)
{
    Select(e_Fn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFn*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetFn(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TFn& value)
{
    TFn* ptr = &value;
    if ( m_choice != e_Fn || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Fn;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TDeclare& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::GetDeclare(void) const
{
    CheckSelected(e_Declare);
    return *static_cast<const TDeclare*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TDeclare& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetDeclare(void)
{
    Select(e_Declare, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDeclare*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::SetDeclare(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::TDeclare& value)
{
    TDeclare* ptr = &value;
    if ( m_choice != e_Declare || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Declare;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp", "DeprecatedContExp");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("reln", m_object, CReln)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("fn", m_object, CFn)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("declare", m_object, CDeclare)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::C_DeprecatedContExp(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_DeprecatedContExp::~C_DeprecatedContExp(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::ResetInterval(void)
{
    if ( !m_Interval ) {
        m_Interval.Reset(new TInterval());
        return;
    }
    (*m_Interval).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::SetInterval(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::TInterval& value)
{
    m_Interval.Reset(&value);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::Reset(void)
{
    ResetInterval();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.interval", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("interval", m_Interval, CInterval)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::C_Interval_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetInterval();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Interval_mmlclass::~C_Interval_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Inverse:
    case e_Ident:
    case e_Domain:
    case e_Codomain:
    case e_Image:
    case e_Ln:
    case e_Log:
    case e_Moment:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Inverse:
        (m_object = new(pool) ncbi::objects::CInverse())->AddReference();
        break;
    case e_Ident:
        (m_object = new(pool) ncbi::objects::CIdent())->AddReference();
        break;
    case e_Domain:
        (m_object = new(pool) ncbi::objects::CDomain())->AddReference();
        break;
    case e_Codomain:
        (m_object = new(pool) ncbi::objects::CCodomain())->AddReference();
        break;
    case e_Image:
        (m_object = new(pool) ncbi::objects::CImage())->AddReference();
        break;
    case e_Ln:
        (m_object = new(pool) ncbi::objects::CLn())->AddReference();
        break;
    case e_Log:
        (m_object = new(pool) ncbi::objects::CLog())->AddReference();
        break;
    case e_Moment:
        (m_object = new(pool) ncbi::objects::CMoment())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::sm_SelectionNames[] = {
    "not set",
    "inverse",
    "ident",
    "domain",
    "codomain",
    "image",
    "ln",
    "log",
    "moment"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TInverse& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetInverse(void) const
{
    CheckSelected(e_Inverse);
    return *static_cast<const TInverse*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TInverse& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetInverse(void)
{
    Select(e_Inverse, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TInverse& value = *static_cast<TInverse*>(m_object);
    value.SetInverse();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TIdent& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetIdent(void) const
{
    CheckSelected(e_Ident);
    return *static_cast<const TIdent*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TIdent& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetIdent(void)
{
    Select(e_Ident, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TIdent& value = *static_cast<TIdent*>(m_object);
    value.SetIdent();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TDomain& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetDomain(void) const
{
    CheckSelected(e_Domain);
    return *static_cast<const TDomain*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TDomain& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetDomain(void)
{
    Select(e_Domain, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TDomain& value = *static_cast<TDomain*>(m_object);
    value.SetDomain();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TCodomain& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetCodomain(void) const
{
    CheckSelected(e_Codomain);
    return *static_cast<const TCodomain*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TCodomain& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetCodomain(void)
{
    Select(e_Codomain, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TCodomain& value = *static_cast<TCodomain*>(m_object);
    value.SetCodomain();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TImage& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetImage(void) const
{
    CheckSelected(e_Image);
    return *static_cast<const TImage*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TImage& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetImage(void)
{
    Select(e_Image, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TImage& value = *static_cast<TImage*>(m_object);
    value.SetImage();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetLn(void) const
{
    CheckSelected(e_Ln);
    return *static_cast<const TLn*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetLn(void)
{
    Select(e_Ln, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLn& value = *static_cast<TLn*>(m_object);
    value.SetLn();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLog& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetLog(void) const
{
    CheckSelected(e_Log);
    return *static_cast<const TLog*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLog& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetLog(void)
{
    Select(e_Log, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TLog& value = *static_cast<TLog*>(m_object);
    value.SetLog();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TMoment& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::GetMoment(void) const
{
    CheckSelected(e_Moment);
    return *static_cast<const TMoment*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TMoment& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::SetMoment(void)
{
    Select(e_Moment, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::TMoment& value = *static_cast<TMoment*>(m_object);
    value.SetMoment();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-functional", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("inverse", m_object, CInverse)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("ident", m_object, CIdent)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("domain", m_object, CDomain)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("codomain", m_object, CCodomain)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("image", m_object, CImage)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("ln", m_object, CLn)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("log", m_object, CLog)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("moment", m_object, CMoment)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::C_Unary_functional_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_functional_mmlclass::~C_Unary_functional_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::ResetLambda(void)
{
    if ( !m_Lambda ) {
        m_Lambda.Reset(new TLambda());
        return;
    }
    (*m_Lambda).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::SetLambda(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::TLambda& value)
{
    m_Lambda.Reset(&value);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::Reset(void)
{
    ResetLambda();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.lambda", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("lambda", m_Lambda, CLambda)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::C_Lambda_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetLambda();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Lambda_mmlclass::~C_Lambda_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::IsSetCompose(void) const
{
    return m_Compose ? m_Compose->IsSetCompose() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::ResetCompose(void)
{
    if ( !m_Compose ) {
        m_Compose.Reset(new TCompose());
        return;
    }
    (*m_Compose).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::SetCompose(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::TCompose& value)
{
    m_Compose.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::TCompose& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::SetCompose(void)
{
    if ( !m_Compose ) {
        ResetCompose();
    }
    m_Compose->SetCompose();
    return (*m_Compose);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::Reset(void)
{
    ResetCompose();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-functional", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("compose", m_Compose, CCompose)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::C_Nary_functional_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetCompose();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_functional_mmlclass::~C_Nary_functional_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Quotient:
    case e_Divide:
    case e_Minus:
    case e_Power:
    case e_Rem:
    case e_Root:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Quotient:
        (m_object = new(pool) ncbi::objects::CQuotient())->AddReference();
        break;
    case e_Divide:
        (m_object = new(pool) ncbi::objects::CDivide())->AddReference();
        break;
    case e_Minus:
        (m_object = new(pool) ncbi::objects::CMinus())->AddReference();
        break;
    case e_Power:
        (m_object = new(pool) ncbi::objects::CPower())->AddReference();
        break;
    case e_Rem:
        (m_object = new(pool) ncbi::objects::CRem())->AddReference();
        break;
    case e_Root:
        (m_object = new(pool) ncbi::objects::CRoot())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "quotient",
    "divide",
    "minus",
    "power",
    "rem",
    "root"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TQuotient& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetQuotient(void) const
{
    CheckSelected(e_Quotient);
    return *static_cast<const TQuotient*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TQuotient& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetQuotient(void)
{
    Select(e_Quotient, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TQuotient& value = *static_cast<TQuotient*>(m_object);
    value.SetQuotient();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TDivide& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetDivide(void) const
{
    CheckSelected(e_Divide);
    return *static_cast<const TDivide*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TDivide& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetDivide(void)
{
    Select(e_Divide, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TDivide& value = *static_cast<TDivide*>(m_object);
    value.SetDivide();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TMinus& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetMinus(void) const
{
    CheckSelected(e_Minus);
    return *static_cast<const TMinus*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TMinus& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetMinus(void)
{
    Select(e_Minus, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TMinus& value = *static_cast<TMinus*>(m_object);
    value.SetMinus();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TPower& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetPower(void) const
{
    CheckSelected(e_Power);
    return *static_cast<const TPower*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TPower& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetPower(void)
{
    Select(e_Power, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TPower& value = *static_cast<TPower*>(m_object);
    value.SetPower();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRem& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetRem(void) const
{
    CheckSelected(e_Rem);
    return *static_cast<const TRem*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRem& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetRem(void)
{
    Select(e_Rem, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRem& value = *static_cast<TRem*>(m_object);
    value.SetRem();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRoot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::GetRoot(void) const
{
    CheckSelected(e_Root);
    return *static_cast<const TRoot*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRoot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::SetRoot(void)
{
    Select(e_Root, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::TRoot& value = *static_cast<TRoot*>(m_object);
    value.SetRoot();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.binary-arith", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("quotient", m_object, CQuotient)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("divide", m_object, CDivide)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("minus", m_object, CMinus)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("power", m_object, CPower)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("rem", m_object, CRem)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("root", m_object, CRoot)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::C_Binary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_arith_mmlclass::~C_Binary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Factorial:
    case e_Abs:
    case e_Conjugate:
    case e_Arg:
    case e_Real:
    case e_Imaginary:
    case e_Floor:
    case e_Ceiling:
    case e_Exp:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Factorial:
        (m_object = new(pool) ncbi::objects::CFactorial())->AddReference();
        break;
    case e_Abs:
        (m_object = new(pool) ncbi::objects::CAbs())->AddReference();
        break;
    case e_Conjugate:
        (m_object = new(pool) ncbi::objects::CConjugate())->AddReference();
        break;
    case e_Arg:
        (m_object = new(pool) ncbi::objects::CArg())->AddReference();
        break;
    case e_Real:
        (m_object = new(pool) ncbi::objects::CReal())->AddReference();
        break;
    case e_Imaginary:
        (m_object = new(pool) ncbi::objects::CImaginary())->AddReference();
        break;
    case e_Floor:
        (m_object = new(pool) ncbi::objects::CFloor())->AddReference();
        break;
    case e_Ceiling:
        (m_object = new(pool) ncbi::objects::CCeiling())->AddReference();
        break;
    case e_Exp:
        (m_object = new(pool) ncbi::objects::CExp())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "factorial",
    "abs",
    "conjugate",
    "arg",
    "real",
    "imaginary",
    "floor",
    "ceiling",
    "exp"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFactorial& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetFactorial(void) const
{
    CheckSelected(e_Factorial);
    return *static_cast<const TFactorial*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFactorial& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetFactorial(void)
{
    Select(e_Factorial, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFactorial& value = *static_cast<TFactorial*>(m_object);
    value.SetFactorial();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TAbs& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetAbs(void) const
{
    CheckSelected(e_Abs);
    return *static_cast<const TAbs*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TAbs& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetAbs(void)
{
    Select(e_Abs, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TAbs& value = *static_cast<TAbs*>(m_object);
    value.SetAbs();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TConjugate& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetConjugate(void) const
{
    CheckSelected(e_Conjugate);
    return *static_cast<const TConjugate*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TConjugate& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetConjugate(void)
{
    Select(e_Conjugate, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TConjugate& value = *static_cast<TConjugate*>(m_object);
    value.SetConjugate();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TArg& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetArg(void) const
{
    CheckSelected(e_Arg);
    return *static_cast<const TArg*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TArg& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetArg(void)
{
    Select(e_Arg, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TArg& value = *static_cast<TArg*>(m_object);
    value.SetArg();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TReal& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetReal(void) const
{
    CheckSelected(e_Real);
    return *static_cast<const TReal*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TReal& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetReal(void)
{
    Select(e_Real, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TReal& value = *static_cast<TReal*>(m_object);
    value.SetReal();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TImaginary& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetImaginary(void) const
{
    CheckSelected(e_Imaginary);
    return *static_cast<const TImaginary*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TImaginary& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetImaginary(void)
{
    Select(e_Imaginary, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TImaginary& value = *static_cast<TImaginary*>(m_object);
    value.SetImaginary();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFloor& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetFloor(void) const
{
    CheckSelected(e_Floor);
    return *static_cast<const TFloor*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFloor& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetFloor(void)
{
    Select(e_Floor, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TFloor& value = *static_cast<TFloor*>(m_object);
    value.SetFloor();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TCeiling& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetCeiling(void) const
{
    CheckSelected(e_Ceiling);
    return *static_cast<const TCeiling*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TCeiling& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetCeiling(void)
{
    Select(e_Ceiling, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TCeiling& value = *static_cast<TCeiling*>(m_object);
    value.SetCeiling();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TExp& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::GetExp(void) const
{
    CheckSelected(e_Exp);
    return *static_cast<const TExp*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TExp& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::SetExp(void)
{
    Select(e_Exp, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::TExp& value = *static_cast<TExp*>(m_object);
    value.SetExp();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-arith", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("factorial", m_object, CFactorial)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("abs", m_object, CAbs)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("conjugate", m_object, CConjugate)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arg", m_object, CArg)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("real", m_object, CReal)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("imaginary", m_object, CImaginary)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("floor", m_object, CFloor)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("ceiling", m_object, CCeiling)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("exp", m_object, CExp)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::C_Unary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_arith_mmlclass::~C_Unary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Max:
    case e_Min:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Max:
        (m_object = new(pool) ncbi::objects::CMax())->AddReference();
        break;
    case e_Min:
        (m_object = new(pool) ncbi::objects::CMin())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::sm_SelectionNames[] = {
    "not set",
    "max",
    "min"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMax& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::GetMax(void) const
{
    CheckSelected(e_Max);
    return *static_cast<const TMax*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMax& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::SetMax(void)
{
    Select(e_Max, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMax& value = *static_cast<TMax*>(m_object);
    value.SetMax();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::GetMin(void) const
{
    CheckSelected(e_Min);
    return *static_cast<const TMin*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::SetMin(void)
{
    Select(e_Min, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::TMin& value = *static_cast<TMin*>(m_object);
    value.SetMin();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-minmax", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("max", m_object, CMax)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("min", m_object, CMin)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::C_Nary_minmax_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_minmax_mmlclass::~C_Nary_minmax_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Plus:
    case e_Times:
    case e_Gcd:
    case e_Lcm:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Plus:
        (m_object = new(pool) ncbi::objects::CPlus())->AddReference();
        break;
    case e_Times:
        (m_object = new(pool) ncbi::objects::CTimes())->AddReference();
        break;
    case e_Gcd:
        (m_object = new(pool) ncbi::objects::CGcd())->AddReference();
        break;
    case e_Lcm:
        (m_object = new(pool) ncbi::objects::CLcm())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "plus",
    "times",
    "gcd",
    "lcm"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TPlus& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::GetPlus(void) const
{
    CheckSelected(e_Plus);
    return *static_cast<const TPlus*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TPlus& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::SetPlus(void)
{
    Select(e_Plus, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TPlus& value = *static_cast<TPlus*>(m_object);
    value.SetPlus();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TTimes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::GetTimes(void) const
{
    CheckSelected(e_Times);
    return *static_cast<const TTimes*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TTimes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::SetTimes(void)
{
    Select(e_Times, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TTimes& value = *static_cast<TTimes*>(m_object);
    value.SetTimes();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TGcd& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::GetGcd(void) const
{
    CheckSelected(e_Gcd);
    return *static_cast<const TGcd*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TGcd& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::SetGcd(void)
{
    Select(e_Gcd, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TGcd& value = *static_cast<TGcd*>(m_object);
    value.SetGcd();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TLcm& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::GetLcm(void) const
{
    CheckSelected(e_Lcm);
    return *static_cast<const TLcm*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TLcm& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::SetLcm(void)
{
    Select(e_Lcm, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::TLcm& value = *static_cast<TLcm*>(m_object);
    value.SetLcm();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-arith", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("plus", m_object, CPlus)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("times", m_object, CTimes)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("gcd", m_object, CGcd)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("lcm", m_object, CLcm)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::C_Nary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_arith_mmlclass::~C_Nary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_And:
    case e_Or:
    case e_Xor:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_And:
        (m_object = new(pool) ncbi::objects::CAnd())->AddReference();
        break;
    case e_Or:
        (m_object = new(pool) ncbi::objects::COr())->AddReference();
        break;
    case e_Xor:
        (m_object = new(pool) ncbi::objects::CXor())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::sm_SelectionNames[] = {
    "not set",
    "and",
    "or",
    "xor"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TAnd& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::GetAnd(void) const
{
    CheckSelected(e_And);
    return *static_cast<const TAnd*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TAnd& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::SetAnd(void)
{
    Select(e_And, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TAnd& value = *static_cast<TAnd*>(m_object);
    value.SetAnd();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TOr& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::GetOr(void) const
{
    CheckSelected(e_Or);
    return *static_cast<const TOr*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TOr& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::SetOr(void)
{
    Select(e_Or, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TOr& value = *static_cast<TOr*>(m_object);
    value.SetOr();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TXor& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::GetXor(void) const
{
    CheckSelected(e_Xor);
    return *static_cast<const TXor*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TXor& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::SetXor(void)
{
    Select(e_Xor, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::TXor& value = *static_cast<TXor*>(m_object);
    value.SetXor();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-logical", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("and", m_object, CAnd)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("or", m_object, COr)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("xor", m_object, CXor)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::C_Nary_logical_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_logical_mmlclass::~C_Nary_logical_mmlclass(void)
{
    Reset();
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::IsSetNot(void) const
{
    return m_Not ? m_Not->IsSetNot() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::ResetNot(void)
{
    if ( !m_Not ) {
        m_Not.Reset(new TNot());
        return;
    }
    (*m_Not).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::SetNot(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::TNot& value)
{
    m_Not.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::TNot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::SetNot(void)
{
    if ( !m_Not ) {
        ResetNot();
    }
    m_Not->SetNot();
    return (*m_Not);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::Reset(void)
{
    ResetNot();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-logical", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("not", m_Not, CNot)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::C_Unary_logical_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetNot();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_logical_mmlclass::~C_Unary_logical_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Implies:
    case e_Equivalent:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Implies:
        (m_object = new(pool) ncbi::objects::CImplies())->AddReference();
        break;
    case e_Equivalent:
        (m_object = new(pool) ncbi::objects::CEquivalent())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::sm_SelectionNames[] = {
    "not set",
    "implies",
    "equivalent"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TImplies& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::GetImplies(void) const
{
    CheckSelected(e_Implies);
    return *static_cast<const TImplies*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TImplies& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::SetImplies(void)
{
    Select(e_Implies, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TImplies& value = *static_cast<TImplies*>(m_object);
    value.SetImplies();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TEquivalent& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::GetEquivalent(void) const
{
    CheckSelected(e_Equivalent);
    return *static_cast<const TEquivalent*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TEquivalent& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::SetEquivalent(void)
{
    Select(e_Equivalent, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::TEquivalent& value = *static_cast<TEquivalent*>(m_object);
    value.SetEquivalent();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.binary-logical", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("implies", m_object, CImplies)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("equivalent", m_object, CEquivalent)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::C_Binary_logical_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_logical_mmlclass::~C_Binary_logical_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Forall:
    case e_Exists:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Forall:
        (m_object = new(pool) ncbi::objects::CForall())->AddReference();
        break;
    case e_Exists:
        (m_object = new(pool) ncbi::objects::CExists())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::sm_SelectionNames[] = {
    "not set",
    "forall",
    "exists"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TForall& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::GetForall(void) const
{
    CheckSelected(e_Forall);
    return *static_cast<const TForall*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TForall& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::SetForall(void)
{
    Select(e_Forall, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TForall& value = *static_cast<TForall*>(m_object);
    value.SetForall();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TExists& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::GetExists(void) const
{
    CheckSelected(e_Exists);
    return *static_cast<const TExists*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TExists& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::SetExists(void)
{
    Select(e_Exists, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::TExists& value = *static_cast<TExists*>(m_object);
    value.SetExists();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.quantifier", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("forall", m_object, CForall)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("exists", m_object, CExists)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::C_Quantifier_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Quantifier_mmlclass::~C_Quantifier_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Eq:
    case e_Gt:
    case e_Lt:
    case e_Geq:
    case e_Leq:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Eq:
        (m_object = new(pool) ncbi::objects::CEq())->AddReference();
        break;
    case e_Gt:
        (m_object = new(pool) ncbi::objects::CGt())->AddReference();
        break;
    case e_Lt:
        (m_object = new(pool) ncbi::objects::CLt())->AddReference();
        break;
    case e_Geq:
        (m_object = new(pool) ncbi::objects::CGeq())->AddReference();
        break;
    case e_Leq:
        (m_object = new(pool) ncbi::objects::CLeq())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "eq",
    "gt",
    "lt",
    "geq",
    "leq"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TEq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::GetEq(void) const
{
    CheckSelected(e_Eq);
    return *static_cast<const TEq*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TEq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SetEq(void)
{
    Select(e_Eq, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TEq& value = *static_cast<TEq*>(m_object);
    value.SetEq();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGt& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::GetGt(void) const
{
    CheckSelected(e_Gt);
    return *static_cast<const TGt*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGt& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SetGt(void)
{
    Select(e_Gt, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGt& value = *static_cast<TGt*>(m_object);
    value.SetGt();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLt& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::GetLt(void) const
{
    CheckSelected(e_Lt);
    return *static_cast<const TLt*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLt& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SetLt(void)
{
    Select(e_Lt, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLt& value = *static_cast<TLt*>(m_object);
    value.SetLt();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::GetGeq(void) const
{
    CheckSelected(e_Geq);
    return *static_cast<const TGeq*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SetGeq(void)
{
    Select(e_Geq, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TGeq& value = *static_cast<TGeq*>(m_object);
    value.SetGeq();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::GetLeq(void) const
{
    CheckSelected(e_Leq);
    return *static_cast<const TLeq*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::SetLeq(void)
{
    Select(e_Leq, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::TLeq& value = *static_cast<TLeq*>(m_object);
    value.SetLeq();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-reln", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("eq", m_object, CEq)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("gt", m_object, CGt)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("lt", m_object, CLt)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("geq", m_object, CGeq)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("leq", m_object, CLeq)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::C_Nary_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_reln_mmlclass::~C_Nary_reln_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Neq:
    case e_Approx:
    case e_Factorof:
    case e_Tendsto:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Neq:
        (m_object = new(pool) ncbi::objects::CNeq())->AddReference();
        break;
    case e_Approx:
        (m_object = new(pool) ncbi::objects::CApprox())->AddReference();
        break;
    case e_Factorof:
        (m_object = new(pool) ncbi::objects::CFactorof())->AddReference();
        break;
    case e_Tendsto:
        (m_object = new(pool) ncbi::objects::CTendsto())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "neq",
    "approx",
    "factorof",
    "tendsto"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TNeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::GetNeq(void) const
{
    CheckSelected(e_Neq);
    return *static_cast<const TNeq*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TNeq& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::SetNeq(void)
{
    Select(e_Neq, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TNeq& value = *static_cast<TNeq*>(m_object);
    value.SetNeq();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TApprox& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::GetApprox(void) const
{
    CheckSelected(e_Approx);
    return *static_cast<const TApprox*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TApprox& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::SetApprox(void)
{
    Select(e_Approx, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TApprox& value = *static_cast<TApprox*>(m_object);
    value.SetApprox();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TFactorof& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::GetFactorof(void) const
{
    CheckSelected(e_Factorof);
    return *static_cast<const TFactorof*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TFactorof& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::SetFactorof(void)
{
    Select(e_Factorof, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TFactorof& value = *static_cast<TFactorof*>(m_object);
    value.SetFactorof();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TTendsto& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::GetTendsto(void) const
{
    CheckSelected(e_Tendsto);
    return *static_cast<const TTendsto*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TTendsto& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::SetTendsto(void)
{
    Select(e_Tendsto, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::TTendsto& value = *static_cast<TTendsto*>(m_object);
    value.SetTendsto();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.binary-reln", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("neq", m_object, CNeq)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("approx", m_object, CApprox)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("factorof", m_object, CFactorof)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("tendsto", m_object, CTendsto)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::C_Binary_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_reln_mmlclass::~C_Binary_reln_mmlclass(void)
{
    Reset();
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::IsSetInt(void) const
{
    return m_Int ? m_Int->IsSetInt() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::ResetInt(void)
{
    if ( !m_Int ) {
        m_Int.Reset(new TInt());
        return;
    }
    (*m_Int).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::SetInt(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::TInt& value)
{
    m_Int.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::TInt& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::SetInt(void)
{
    if ( !m_Int ) {
        ResetInt();
    }
    m_Int->SetInt();
    return (*m_Int);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::Reset(void)
{
    ResetInt();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.int", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("int", m_Int, CInt)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::C_Int_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetInt();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Int_mmlclass::~C_Int_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::IsSetDiff(void) const
{
    return m_Diff ? m_Diff->IsSetDiff() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::ResetDiff(void)
{
    if ( !m_Diff ) {
        m_Diff.Reset(new TDiff());
        return;
    }
    (*m_Diff).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::SetDiff(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::TDiff& value)
{
    m_Diff.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::TDiff& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::SetDiff(void)
{
    if ( !m_Diff ) {
        ResetDiff();
    }
    m_Diff->SetDiff();
    return (*m_Diff);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::Reset(void)
{
    ResetDiff();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.Differential-Operator", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("diff", m_Diff, CDiff)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::C_Differential_Operator_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetDiff();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Differential_Operator_mmlclass::~C_Differential_Operator_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::IsSetPartialdiff(void) const
{
    return m_Partialdiff ? m_Partialdiff->IsSetPartialdiff() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::ResetPartialdiff(void)
{
    if ( !m_Partialdiff ) {
        m_Partialdiff.Reset(new TPartialdiff());
        return;
    }
    (*m_Partialdiff).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::SetPartialdiff(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::TPartialdiff& value)
{
    m_Partialdiff.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::TPartialdiff& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::SetPartialdiff(void)
{
    if ( !m_Partialdiff ) {
        ResetPartialdiff();
    }
    m_Partialdiff->SetPartialdiff();
    return (*m_Partialdiff);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::Reset(void)
{
    ResetPartialdiff();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.partialdiff", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("partialdiff", m_Partialdiff, CPartialdiff)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::C_Partialdiff_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetPartialdiff();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Partialdiff_mmlclass::~C_Partialdiff_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Divergence:
    case e_Grad:
    case e_Curl:
    case e_Laplacian:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Divergence:
        (m_object = new(pool) ncbi::objects::CDivergence())->AddReference();
        break;
    case e_Grad:
        (m_object = new(pool) ncbi::objects::CGrad())->AddReference();
        break;
    case e_Curl:
        (m_object = new(pool) ncbi::objects::CCurl())->AddReference();
        break;
    case e_Laplacian:
        (m_object = new(pool) ncbi::objects::CLaplacian())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::sm_SelectionNames[] = {
    "not set",
    "divergence",
    "grad",
    "curl",
    "laplacian"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::GetDivergence(void) const
{
    CheckSelected(e_Divergence);
    return *static_cast<const TDivergence*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::SetDivergence(void)
{
    Select(e_Divergence, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& value = *static_cast<TDivergence*>(m_object);
    value.SetDivergence();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::GetGrad(void) const
{
    CheckSelected(e_Grad);
    return *static_cast<const TGrad*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::SetGrad(void)
{
    Select(e_Grad, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& value = *static_cast<TGrad*>(m_object);
    value.SetGrad();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::GetCurl(void) const
{
    CheckSelected(e_Curl);
    return *static_cast<const TCurl*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::SetCurl(void)
{
    Select(e_Curl, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& value = *static_cast<TCurl*>(m_object);
    value.SetCurl();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TLaplacian& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::GetLaplacian(void) const
{
    CheckSelected(e_Laplacian);
    return *static_cast<const TLaplacian*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TLaplacian& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::SetLaplacian(void)
{
    Select(e_Laplacian, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::TLaplacian& value = *static_cast<TLaplacian*>(m_object);
    value.SetLaplacian();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-veccalc", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("divergence", m_object, CDivergence)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("grad", m_object, CGrad)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("curl", m_object, CCurl)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("laplacian", m_object, CLaplacian)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::C_Unary_veccalc_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_veccalc_mmlclass::~C_Unary_veccalc_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Set:
    case e_List:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Set:
        (m_object = new(pool) ncbi::objects::CSet())->AddReference();
        break;
    case e_List:
        (m_object = new(pool) ncbi::objects::CList())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::sm_SelectionNames[] = {
    "not set",
    "set",
    "list"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TSet& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::GetSet(void) const
{
    CheckSelected(e_Set);
    return *static_cast<const TSet*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TSet& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetSet(void)
{
    Select(e_Set, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSet*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetSet(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TSet& value)
{
    TSet* ptr = &value;
    if ( m_choice != e_Set || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Set;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TList& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::GetList(void) const
{
    CheckSelected(e_List);
    return *static_cast<const TList*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TList& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetList(void)
{
    Select(e_List, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TList*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetList(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::TList& value)
{
    TList* ptr = &value;
    if ( m_choice != e_List || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_List;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-setlist-constructor", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("set", m_object, CSet)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("list", m_object, CList)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::C_Nary_setlist_constructor_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_setlist_constructor_mmlclass::~C_Nary_setlist_constructor_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Union:
    case e_Intersect:
    case e_Cartesianproduct:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Union:
        (m_object = new(pool) ncbi::objects::CUnion())->AddReference();
        break;
    case e_Intersect:
        (m_object = new(pool) ncbi::objects::CIntersect())->AddReference();
        break;
    case e_Cartesianproduct:
        (m_object = new(pool) ncbi::objects::CCartesianproduct())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "union",
    "intersect",
    "cartesianproduct"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TUnion& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::GetUnion(void) const
{
    CheckSelected(e_Union);
    return *static_cast<const TUnion*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TUnion& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::SetUnion(void)
{
    Select(e_Union, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TUnion& value = *static_cast<TUnion*>(m_object);
    value.SetUnion();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TIntersect& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::GetIntersect(void) const
{
    CheckSelected(e_Intersect);
    return *static_cast<const TIntersect*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TIntersect& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::SetIntersect(void)
{
    Select(e_Intersect, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TIntersect& value = *static_cast<TIntersect*>(m_object);
    value.SetIntersect();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TCartesianproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::GetCartesianproduct(void) const
{
    CheckSelected(e_Cartesianproduct);
    return *static_cast<const TCartesianproduct*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TCartesianproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::SetCartesianproduct(void)
{
    Select(e_Cartesianproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::TCartesianproduct& value = *static_cast<TCartesianproduct*>(m_object);
    value.SetCartesianproduct();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-set", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("union", m_object, CUnion)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("intersect", m_object, CIntersect)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cartesianproduct", m_object, CCartesianproduct)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::C_Nary_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_mmlclass::~C_Nary_set_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_In:
    case e_Notin:
    case e_Notsubset:
    case e_Notprsubset:
    case e_Setdiff:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_In:
        (m_object = new(pool) ncbi::objects::CIn())->AddReference();
        break;
    case e_Notin:
        (m_object = new(pool) ncbi::objects::CNotin())->AddReference();
        break;
    case e_Notsubset:
        (m_object = new(pool) ncbi::objects::CNotsubset())->AddReference();
        break;
    case e_Notprsubset:
        (m_object = new(pool) ncbi::objects::CNotprsubset())->AddReference();
        break;
    case e_Setdiff:
        (m_object = new(pool) ncbi::objects::CSetdiff())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "in",
    "notin",
    "notsubset",
    "notprsubset",
    "setdiff"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TIn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::GetIn(void) const
{
    CheckSelected(e_In);
    return *static_cast<const TIn*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TIn& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SetIn(void)
{
    Select(e_In, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TIn& value = *static_cast<TIn*>(m_object);
    value.SetIn();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::GetNotin(void) const
{
    CheckSelected(e_Notin);
    return *static_cast<const TNotin*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SetNotin(void)
{
    Select(e_Notin, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotin& value = *static_cast<TNotin*>(m_object);
    value.SetNotin();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::GetNotsubset(void) const
{
    CheckSelected(e_Notsubset);
    return *static_cast<const TNotsubset*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SetNotsubset(void)
{
    Select(e_Notsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotsubset& value = *static_cast<TNotsubset*>(m_object);
    value.SetNotsubset();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::GetNotprsubset(void) const
{
    CheckSelected(e_Notprsubset);
    return *static_cast<const TNotprsubset*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SetNotprsubset(void)
{
    Select(e_Notprsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& value = *static_cast<TNotprsubset*>(m_object);
    value.SetNotprsubset();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TSetdiff& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::GetSetdiff(void) const
{
    CheckSelected(e_Setdiff);
    return *static_cast<const TSetdiff*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TSetdiff& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::SetSetdiff(void)
{
    Select(e_Setdiff, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::TSetdiff& value = *static_cast<TSetdiff*>(m_object);
    value.SetSetdiff();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.binary-set", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("in", m_object, CIn)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("notin", m_object, CNotin)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("notsubset", m_object, CNotsubset)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("notprsubset", m_object, CNotprsubset)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("setdiff", m_object, CSetdiff)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::C_Binary_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_set_mmlclass::~C_Binary_set_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Subset:
    case e_Prsubset:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Subset:
        (m_object = new(pool) ncbi::objects::CSubset())->AddReference();
        break;
    case e_Prsubset:
        (m_object = new(pool) ncbi::objects::CPrsubset())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "subset",
    "prsubset"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::GetSubset(void) const
{
    CheckSelected(e_Subset);
    return *static_cast<const TSubset*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::SetSubset(void)
{
    Select(e_Subset, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& value = *static_cast<TSubset*>(m_object);
    value.SetSubset();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TPrsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::GetPrsubset(void) const
{
    CheckSelected(e_Prsubset);
    return *static_cast<const TPrsubset*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TPrsubset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::SetPrsubset(void)
{
    Select(e_Prsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::TPrsubset& value = *static_cast<TPrsubset*>(m_object);
    value.SetPrsubset();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-set-reln", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("subset", m_object, CSubset)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("prsubset", m_object, CPrsubset)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::C_Nary_set_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_set_reln_mmlclass::~C_Nary_set_reln_mmlclass(void)
{
    Reset();
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::IsSetCard(void) const
{
    return m_Card ? m_Card->IsSetCard() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::ResetCard(void)
{
    if ( !m_Card ) {
        m_Card.Reset(new TCard());
        return;
    }
    (*m_Card).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::SetCard(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::TCard& value)
{
    m_Card.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::TCard& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::SetCard(void)
{
    if ( !m_Card ) {
        ResetCard();
    }
    m_Card->SetCard();
    return (*m_Card);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::Reset(void)
{
    ResetCard();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-set", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("card", m_Card, CCard)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::C_Unary_set_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetCard();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_set_mmlclass::~C_Unary_set_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::IsSetSum(void) const
{
    return m_Sum ? m_Sum->IsSetSum() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::ResetSum(void)
{
    if ( !m_Sum ) {
        m_Sum.Reset(new TSum());
        return;
    }
    (*m_Sum).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::SetSum(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::TSum& value)
{
    m_Sum.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::TSum& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::SetSum(void)
{
    if ( !m_Sum ) {
        ResetSum();
    }
    m_Sum->SetSum();
    return (*m_Sum);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::Reset(void)
{
    ResetSum();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.sum", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("sum", m_Sum, CSum)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::C_Sum_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetSum();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Sum_mmlclass::~C_Sum_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::IsSetProduct(void) const
{
    return m_Product ? m_Product->IsSetProduct() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::ResetProduct(void)
{
    if ( !m_Product ) {
        m_Product.Reset(new TProduct());
        return;
    }
    (*m_Product).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::SetProduct(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::TProduct& value)
{
    m_Product.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::TProduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::SetProduct(void)
{
    if ( !m_Product ) {
        ResetProduct();
    }
    m_Product->SetProduct();
    return (*m_Product);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::Reset(void)
{
    ResetProduct();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.product", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("product", m_Product, CProduct)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::C_Product_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetProduct();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Product_mmlclass::~C_Product_mmlclass(void)
{
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::IsSetLimit(void) const
{
    return m_Limit ? m_Limit->IsSetLimit() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::ResetLimit(void)
{
    if ( !m_Limit ) {
        m_Limit.Reset(new TLimit());
        return;
    }
    (*m_Limit).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::SetLimit(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::TLimit& value)
{
    m_Limit.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::TLimit& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::SetLimit(void)
{
    if ( !m_Limit ) {
        ResetLimit();
    }
    m_Limit->SetLimit();
    return (*m_Limit);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::Reset(void)
{
    ResetLimit();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.limit", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("limit", m_Limit, CLimit)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::C_Limit_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetLimit();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Limit_mmlclass::~C_Limit_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Sin:
    case e_Cos:
    case e_Tan:
    case e_Sec:
    case e_Csc:
    case e_Cot:
    case e_Sinh:
    case e_Cosh:
    case e_Tanh:
    case e_Sech:
    case e_Csch:
    case e_Coth:
    case e_Arcsin:
    case e_Arccos:
    case e_Arctan:
    case e_Arccosh:
    case e_Arccot:
    case e_Arccoth:
    case e_Arccsc:
    case e_Arccsch:
    case e_Arcsec:
    case e_Arcsech:
    case e_Arcsinh:
    case e_Arctanh:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Sin:
        (m_object = new(pool) ncbi::objects::CSin())->AddReference();
        break;
    case e_Cos:
        (m_object = new(pool) ncbi::objects::CCos())->AddReference();
        break;
    case e_Tan:
        (m_object = new(pool) ncbi::objects::CTan())->AddReference();
        break;
    case e_Sec:
        (m_object = new(pool) ncbi::objects::CSec())->AddReference();
        break;
    case e_Csc:
        (m_object = new(pool) ncbi::objects::CCsc())->AddReference();
        break;
    case e_Cot:
        (m_object = new(pool) ncbi::objects::CCot())->AddReference();
        break;
    case e_Sinh:
        (m_object = new(pool) ncbi::objects::CSinh())->AddReference();
        break;
    case e_Cosh:
        (m_object = new(pool) ncbi::objects::CCosh())->AddReference();
        break;
    case e_Tanh:
        (m_object = new(pool) ncbi::objects::CTanh())->AddReference();
        break;
    case e_Sech:
        (m_object = new(pool) ncbi::objects::CSech())->AddReference();
        break;
    case e_Csch:
        (m_object = new(pool) ncbi::objects::CCsch())->AddReference();
        break;
    case e_Coth:
        (m_object = new(pool) ncbi::objects::CCoth())->AddReference();
        break;
    case e_Arcsin:
        (m_object = new(pool) ncbi::objects::CArcsin())->AddReference();
        break;
    case e_Arccos:
        (m_object = new(pool) ncbi::objects::CArccos())->AddReference();
        break;
    case e_Arctan:
        (m_object = new(pool) ncbi::objects::CArctan())->AddReference();
        break;
    case e_Arccosh:
        (m_object = new(pool) ncbi::objects::CArccosh())->AddReference();
        break;
    case e_Arccot:
        (m_object = new(pool) ncbi::objects::CArccot())->AddReference();
        break;
    case e_Arccoth:
        (m_object = new(pool) ncbi::objects::CArccoth())->AddReference();
        break;
    case e_Arccsc:
        (m_object = new(pool) ncbi::objects::CArccsc())->AddReference();
        break;
    case e_Arccsch:
        (m_object = new(pool) ncbi::objects::CArccsch())->AddReference();
        break;
    case e_Arcsec:
        (m_object = new(pool) ncbi::objects::CArcsec())->AddReference();
        break;
    case e_Arcsech:
        (m_object = new(pool) ncbi::objects::CArcsech())->AddReference();
        break;
    case e_Arcsinh:
        (m_object = new(pool) ncbi::objects::CArcsinh())->AddReference();
        break;
    case e_Arctanh:
        (m_object = new(pool) ncbi::objects::CArctanh())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::sm_SelectionNames[] = {
    "not set",
    "sin",
    "cos",
    "tan",
    "sec",
    "csc",
    "cot",
    "sinh",
    "cosh",
    "tanh",
    "sech",
    "csch",
    "coth",
    "arcsin",
    "arccos",
    "arctan",
    "arccosh",
    "arccot",
    "arccoth",
    "arccsc",
    "arccsch",
    "arcsec",
    "arcsech",
    "arcsinh",
    "arctanh"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetSin(void) const
{
    CheckSelected(e_Sin);
    return *static_cast<const TSin*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetSin(void)
{
    Select(e_Sin, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSin& value = *static_cast<TSin*>(m_object);
    value.SetSin();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCos& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCos(void) const
{
    CheckSelected(e_Cos);
    return *static_cast<const TCos*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCos& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCos(void)
{
    Select(e_Cos, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCos& value = *static_cast<TCos*>(m_object);
    value.SetCos();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTan& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetTan(void) const
{
    CheckSelected(e_Tan);
    return *static_cast<const TTan*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTan& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetTan(void)
{
    Select(e_Tan, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTan& value = *static_cast<TTan*>(m_object);
    value.SetTan();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSec& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetSec(void) const
{
    CheckSelected(e_Sec);
    return *static_cast<const TSec*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSec& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetSec(void)
{
    Select(e_Sec, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSec& value = *static_cast<TSec*>(m_object);
    value.SetSec();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsc& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCsc(void) const
{
    CheckSelected(e_Csc);
    return *static_cast<const TCsc*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsc& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCsc(void)
{
    Select(e_Csc, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsc& value = *static_cast<TCsc*>(m_object);
    value.SetCsc();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCot(void) const
{
    CheckSelected(e_Cot);
    return *static_cast<const TCot*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCot(void)
{
    Select(e_Cot, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCot& value = *static_cast<TCot*>(m_object);
    value.SetCot();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSinh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetSinh(void) const
{
    CheckSelected(e_Sinh);
    return *static_cast<const TSinh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSinh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetSinh(void)
{
    Select(e_Sinh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSinh& value = *static_cast<TSinh*>(m_object);
    value.SetSinh();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCosh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCosh(void) const
{
    CheckSelected(e_Cosh);
    return *static_cast<const TCosh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCosh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCosh(void)
{
    Select(e_Cosh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCosh& value = *static_cast<TCosh*>(m_object);
    value.SetCosh();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTanh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetTanh(void) const
{
    CheckSelected(e_Tanh);
    return *static_cast<const TTanh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTanh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetTanh(void)
{
    Select(e_Tanh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TTanh& value = *static_cast<TTanh*>(m_object);
    value.SetTanh();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSech& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetSech(void) const
{
    CheckSelected(e_Sech);
    return *static_cast<const TSech*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSech& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetSech(void)
{
    Select(e_Sech, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TSech& value = *static_cast<TSech*>(m_object);
    value.SetSech();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsch& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCsch(void) const
{
    CheckSelected(e_Csch);
    return *static_cast<const TCsch*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsch& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCsch(void)
{
    Select(e_Csch, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCsch& value = *static_cast<TCsch*>(m_object);
    value.SetCsch();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCoth& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetCoth(void) const
{
    CheckSelected(e_Coth);
    return *static_cast<const TCoth*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCoth& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetCoth(void)
{
    Select(e_Coth, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TCoth& value = *static_cast<TCoth*>(m_object);
    value.SetCoth();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArcsin(void) const
{
    CheckSelected(e_Arcsin);
    return *static_cast<const TArcsin*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArcsin(void)
{
    Select(e_Arcsin, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& value = *static_cast<TArcsin*>(m_object);
    value.SetArcsin();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccos& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccos(void) const
{
    CheckSelected(e_Arccos);
    return *static_cast<const TArccos*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccos& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccos(void)
{
    Select(e_Arccos, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccos& value = *static_cast<TArccos*>(m_object);
    value.SetArccos();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctan& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArctan(void) const
{
    CheckSelected(e_Arctan);
    return *static_cast<const TArctan*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctan& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArctan(void)
{
    Select(e_Arctan, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctan& value = *static_cast<TArctan*>(m_object);
    value.SetArctan();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccosh(void) const
{
    CheckSelected(e_Arccosh);
    return *static_cast<const TArccosh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccosh(void)
{
    Select(e_Arccosh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& value = *static_cast<TArccosh*>(m_object);
    value.SetArccosh();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccot(void) const
{
    CheckSelected(e_Arccot);
    return *static_cast<const TArccot*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccot& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccot(void)
{
    Select(e_Arccot, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccot& value = *static_cast<TArccot*>(m_object);
    value.SetArccot();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccoth(void) const
{
    CheckSelected(e_Arccoth);
    return *static_cast<const TArccoth*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccoth(void)
{
    Select(e_Arccoth, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& value = *static_cast<TArccoth*>(m_object);
    value.SetArccoth();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccsc(void) const
{
    CheckSelected(e_Arccsc);
    return *static_cast<const TArccsc*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccsc(void)
{
    Select(e_Arccsc, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& value = *static_cast<TArccsc*>(m_object);
    value.SetArccsc();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArccsch(void) const
{
    CheckSelected(e_Arccsch);
    return *static_cast<const TArccsch*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArccsch(void)
{
    Select(e_Arccsch, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& value = *static_cast<TArccsch*>(m_object);
    value.SetArccsch();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArcsec(void) const
{
    CheckSelected(e_Arcsec);
    return *static_cast<const TArcsec*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArcsec(void)
{
    Select(e_Arcsec, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& value = *static_cast<TArcsec*>(m_object);
    value.SetArcsec();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArcsech(void) const
{
    CheckSelected(e_Arcsech);
    return *static_cast<const TArcsech*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArcsech(void)
{
    Select(e_Arcsech, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& value = *static_cast<TArcsech*>(m_object);
    value.SetArcsech();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArcsinh(void) const
{
    CheckSelected(e_Arcsinh);
    return *static_cast<const TArcsinh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArcsinh(void)
{
    Select(e_Arcsinh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& value = *static_cast<TArcsinh*>(m_object);
    value.SetArcsinh();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctanh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::GetArctanh(void) const
{
    CheckSelected(e_Arctanh);
    return *static_cast<const TArctanh*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctanh& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::SetArctanh(void)
{
    Select(e_Arctanh, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::TArctanh& value = *static_cast<TArctanh*>(m_object);
    value.SetArctanh();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-elementary", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("sin", m_object, CSin)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cos", m_object, CCos)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("tan", m_object, CTan)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("sec", m_object, CSec)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("csc", m_object, CCsc)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cot", m_object, CCot)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("sinh", m_object, CSinh)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cosh", m_object, CCosh)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("tanh", m_object, CTanh)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("sech", m_object, CSech)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("csch", m_object, CCsch)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("coth", m_object, CCoth)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arcsin", m_object, CArcsin)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccos", m_object, CArccos)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arctan", m_object, CArctan)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccosh", m_object, CArccosh)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccot", m_object, CArccot)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccoth", m_object, CArccoth)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccsc", m_object, CArccsc)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arccsch", m_object, CArccsch)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arcsec", m_object, CArcsec)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arcsech", m_object, CArcsech)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arcsinh", m_object, CArcsinh)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("arctanh", m_object, CArctanh)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::C_Unary_elementary_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_elementary_mmlclass::~C_Unary_elementary_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Mean:
    case e_Sdev:
    case e_Variance:
    case e_Median:
    case e_Mode:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Mean:
        (m_object = new(pool) ncbi::objects::CMean())->AddReference();
        break;
    case e_Sdev:
        (m_object = new(pool) ncbi::objects::CSdev())->AddReference();
        break;
    case e_Variance:
        (m_object = new(pool) ncbi::objects::CVariance())->AddReference();
        break;
    case e_Median:
        (m_object = new(pool) ncbi::objects::CMedian())->AddReference();
        break;
    case e_Mode:
        (m_object = new(pool) ncbi::objects::CMode())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::sm_SelectionNames[] = {
    "not set",
    "mean",
    "sdev",
    "variance",
    "median",
    "mode"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMean& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::GetMean(void) const
{
    CheckSelected(e_Mean);
    return *static_cast<const TMean*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMean& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SetMean(void)
{
    Select(e_Mean, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMean& value = *static_cast<TMean*>(m_object);
    value.SetMean();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TSdev& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::GetSdev(void) const
{
    CheckSelected(e_Sdev);
    return *static_cast<const TSdev*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TSdev& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SetSdev(void)
{
    Select(e_Sdev, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TSdev& value = *static_cast<TSdev*>(m_object);
    value.SetSdev();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TVariance& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::GetVariance(void) const
{
    CheckSelected(e_Variance);
    return *static_cast<const TVariance*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TVariance& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SetVariance(void)
{
    Select(e_Variance, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TVariance& value = *static_cast<TVariance*>(m_object);
    value.SetVariance();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMedian& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::GetMedian(void) const
{
    CheckSelected(e_Median);
    return *static_cast<const TMedian*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMedian& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SetMedian(void)
{
    Select(e_Median, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMedian& value = *static_cast<TMedian*>(m_object);
    value.SetMedian();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMode& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::GetMode(void) const
{
    CheckSelected(e_Mode);
    return *static_cast<const TMode*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMode& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::SetMode(void)
{
    Select(e_Mode, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::TMode& value = *static_cast<TMode*>(m_object);
    value.SetMode();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-stats", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("mean", m_object, CMean)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("sdev", m_object, CSdev)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("variance", m_object, CVariance)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("median", m_object, CMedian)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("mode", m_object, CMode)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::C_Nary_stats_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_stats_mmlclass::~C_Nary_stats_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Vector:
    case e_Matrix:
    case e_Matrixrow:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Vector:
        (m_object = new(pool) ncbi::objects::CVector())->AddReference();
        break;
    case e_Matrix:
        (m_object = new(pool) ncbi::objects::CMatrix())->AddReference();
        break;
    case e_Matrixrow:
        (m_object = new(pool) ncbi::objects::CMatrixrow())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::sm_SelectionNames[] = {
    "not set",
    "vector",
    "matrix",
    "matrixrow"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TVector& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::GetVector(void) const
{
    CheckSelected(e_Vector);
    return *static_cast<const TVector*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TVector& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetVector(void)
{
    Select(e_Vector, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TVector*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetVector(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TVector& value)
{
    TVector* ptr = &value;
    if ( m_choice != e_Vector || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Vector;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrix& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::GetMatrix(void) const
{
    CheckSelected(e_Matrix);
    return *static_cast<const TMatrix*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrix& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetMatrix(void)
{
    Select(e_Matrix, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMatrix*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetMatrix(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrix& value)
{
    TMatrix* ptr = &value;
    if ( m_choice != e_Matrix || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Matrix;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrixrow& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::GetMatrixrow(void) const
{
    CheckSelected(e_Matrixrow);
    return *static_cast<const TMatrixrow*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrixrow& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetMatrixrow(void)
{
    Select(e_Matrixrow, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMatrixrow*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::SetMatrixrow(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::TMatrixrow& value)
{
    TMatrixrow* ptr = &value;
    if ( m_choice != e_Matrixrow || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Matrixrow;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-constructor", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("vector", m_object, CVector)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("matrix", m_object, CMatrix)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("matrixrow", m_object, CMatrixrow)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::C_Nary_constructor_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_constructor_mmlclass::~C_Nary_constructor_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Determinant:
    case e_Transpose:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Determinant:
        (m_object = new(pool) ncbi::objects::CDeterminant())->AddReference();
        break;
    case e_Transpose:
        (m_object = new(pool) ncbi::objects::CTranspose())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::sm_SelectionNames[] = {
    "not set",
    "determinant",
    "transpose"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::GetDeterminant(void) const
{
    CheckSelected(e_Determinant);
    return *static_cast<const TDeterminant*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::SetDeterminant(void)
{
    Select(e_Determinant, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& value = *static_cast<TDeterminant*>(m_object);
    value.SetDeterminant();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TTranspose& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::GetTranspose(void) const
{
    CheckSelected(e_Transpose);
    return *static_cast<const TTranspose*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TTranspose& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::SetTranspose(void)
{
    Select(e_Transpose, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::TTranspose& value = *static_cast<TTranspose*>(m_object);
    value.SetTranspose();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.unary-linalg", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("determinant", m_object, CDeterminant)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("transpose", m_object, CTranspose)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::C_Unary_linalg_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Unary_linalg_mmlclass::~C_Unary_linalg_mmlclass(void)
{
    Reset();
}
 
 
bool CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::IsSetSelector(void) const
{
    return m_Selector ? m_Selector->IsSetSelector() : false;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::ResetSelector(void)
{
    if ( !m_Selector ) {
        m_Selector.Reset(new TSelector());
        return;
    }
    (*m_Selector).Reset();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::SetSelector(CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::TSelector& value)
{
    m_Selector.Reset(&value);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::TSelector& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::SetSelector(void)
{
    if ( !m_Selector ) {
        ResetSelector();
    }
    m_Selector->SetSelector();
    return (*m_Selector);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::Reset(void)
{
    ResetSelector();
}
 
BEGIN_NAMED_CLASS_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.nary-linalg", "mmlclass");
    SET_CLASS_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_MEMBER("selector", m_Selector, CSelector)->SetNsQualified(true);
    info->RandomOrder();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CLASS_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::C_Nary_linalg_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetSelector();
    }
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Nary_linalg_mmlclass::~C_Nary_linalg_mmlclass(void)
{
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Vectorproduct:
    case e_Scalarproduct:
    case e_Outerproduct:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Vectorproduct:
        (m_object = new(pool) ncbi::objects::CVectorproduct())->AddReference();
        break;
    case e_Scalarproduct:
        (m_object = new(pool) ncbi::objects::CScalarproduct())->AddReference();
        break;
    case e_Outerproduct:
        (m_object = new(pool) ncbi::objects::COuterproduct())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::sm_SelectionNames[] = {
    "not set",
    "vectorproduct",
    "scalarproduct",
    "outerproduct"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::GetVectorproduct(void) const
{
    CheckSelected(e_Vectorproduct);
    return *static_cast<const TVectorproduct*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::SetVectorproduct(void)
{
    Select(e_Vectorproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& value = *static_cast<TVectorproduct*>(m_object);
    value.SetVectorproduct();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::GetScalarproduct(void) const
{
    CheckSelected(e_Scalarproduct);
    return *static_cast<const TScalarproduct*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::SetScalarproduct(void)
{
    Select(e_Scalarproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& value = *static_cast<TScalarproduct*>(m_object);
    value.SetScalarproduct();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TOuterproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::GetOuterproduct(void) const
{
    CheckSelected(e_Outerproduct);
    return *static_cast<const TOuterproduct*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TOuterproduct& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::SetOuterproduct(void)
{
    Select(e_Outerproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::TOuterproduct& value = *static_cast<TOuterproduct*>(m_object);
    value.SetOuterproduct();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.binary-linalg", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("vectorproduct", m_object, CVectorproduct)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("scalarproduct", m_object, CScalarproduct)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("outerproduct", m_object, COuterproduct)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::C_Binary_linalg_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Binary_linalg_mmlclass::~C_Binary_linalg_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Integers:
    case e_Reals:
    case e_Rationals:
    case e_Naturalnumbers:
    case e_Complexes:
    case e_Primes:
    case e_Emptyset:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Integers:
        (m_object = new(pool) ncbi::objects::CIntegers())->AddReference();
        break;
    case e_Reals:
        (m_object = new(pool) ncbi::objects::CReals())->AddReference();
        break;
    case e_Rationals:
        (m_object = new(pool) ncbi::objects::CRationals())->AddReference();
        break;
    case e_Naturalnumbers:
        (m_object = new(pool) ncbi::objects::CNaturalnumbers())->AddReference();
        break;
    case e_Complexes:
        (m_object = new(pool) ncbi::objects::CComplexes())->AddReference();
        break;
    case e_Primes:
        (m_object = new(pool) ncbi::objects::CPrimes())->AddReference();
        break;
    case e_Emptyset:
        (m_object = new(pool) ncbi::objects::CEmptyset())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "integers",
    "reals",
    "rationals",
    "naturalnumbers",
    "complexes",
    "primes",
    "emptyset"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TIntegers& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetIntegers(void) const
{
    CheckSelected(e_Integers);
    return *static_cast<const TIntegers*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TIntegers& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetIntegers(void)
{
    Select(e_Integers, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TIntegers& value = *static_cast<TIntegers*>(m_object);
    value.SetIntegers();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TReals& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetReals(void) const
{
    CheckSelected(e_Reals);
    return *static_cast<const TReals*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TReals& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetReals(void)
{
    Select(e_Reals, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TReals& value = *static_cast<TReals*>(m_object);
    value.SetReals();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TRationals& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetRationals(void) const
{
    CheckSelected(e_Rationals);
    return *static_cast<const TRationals*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TRationals& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetRationals(void)
{
    Select(e_Rationals, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TRationals& value = *static_cast<TRationals*>(m_object);
    value.SetRationals();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetNaturalnumbers(void) const
{
    CheckSelected(e_Naturalnumbers);
    return *static_cast<const TNaturalnumbers*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetNaturalnumbers(void)
{
    Select(e_Naturalnumbers, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& value = *static_cast<TNaturalnumbers*>(m_object);
    value.SetNaturalnumbers();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TComplexes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetComplexes(void) const
{
    CheckSelected(e_Complexes);
    return *static_cast<const TComplexes*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TComplexes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetComplexes(void)
{
    Select(e_Complexes, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TComplexes& value = *static_cast<TComplexes*>(m_object);
    value.SetComplexes();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TPrimes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetPrimes(void) const
{
    CheckSelected(e_Primes);
    return *static_cast<const TPrimes*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TPrimes& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetPrimes(void)
{
    Select(e_Primes, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TPrimes& value = *static_cast<TPrimes*>(m_object);
    value.SetPrimes();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TEmptyset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::GetEmptyset(void) const
{
    CheckSelected(e_Emptyset);
    return *static_cast<const TEmptyset*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TEmptyset& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::SetEmptyset(void)
{
    Select(e_Emptyset, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::TEmptyset& value = *static_cast<TEmptyset*>(m_object);
    value.SetEmptyset();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.constant-set", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("integers", m_object, CIntegers)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("reals", m_object, CReals)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("rationals", m_object, CRationals)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("naturalnumbers", m_object, CNaturalnumbers)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("complexes", m_object, CComplexes)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("primes", m_object, CPrimes)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("emptyset", m_object, CEmptyset)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::C_Constant_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_set_mmlclass::~C_Constant_set_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Exponentiale:
    case e_Imaginaryi:
    case e_Notanumber:
    case e_True:
    case e_False:
    case e_Pi:
    case e_Eulergamma:
    case e_Infinity:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Exponentiale:
        (m_object = new(pool) ncbi::objects::CExponentiale())->AddReference();
        break;
    case e_Imaginaryi:
        (m_object = new(pool) ncbi::objects::CImaginaryi())->AddReference();
        break;
    case e_Notanumber:
        (m_object = new(pool) ncbi::objects::CNotanumber())->AddReference();
        break;
    case e_True:
        (m_object = new(pool) ncbi::objects::CTrue())->AddReference();
        break;
    case e_False:
        (m_object = new(pool) ncbi::objects::CFalse())->AddReference();
        break;
    case e_Pi:
        (m_object = new(pool) ncbi::objects::CPi())->AddReference();
        break;
    case e_Eulergamma:
        (m_object = new(pool) ncbi::objects::CEulergamma())->AddReference();
        break;
    case e_Infinity:
        (m_object = new(pool) ncbi::objects::CInfinity())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "exponentiale",
    "imaginaryi",
    "notanumber",
    "true",
    "false",
    "pi",
    "eulergamma",
    "infinity"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetExponentiale(void) const
{
    CheckSelected(e_Exponentiale);
    return *static_cast<const TExponentiale*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetExponentiale(void)
{
    Select(e_Exponentiale, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& value = *static_cast<TExponentiale*>(m_object);
    value.SetExponentiale();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetImaginaryi(void) const
{
    CheckSelected(e_Imaginaryi);
    return *static_cast<const TImaginaryi*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetImaginaryi(void)
{
    Select(e_Imaginaryi, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& value = *static_cast<TImaginaryi*>(m_object);
    value.SetImaginaryi();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetNotanumber(void) const
{
    CheckSelected(e_Notanumber);
    return *static_cast<const TNotanumber*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetNotanumber(void)
{
    Select(e_Notanumber, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& value = *static_cast<TNotanumber*>(m_object);
    value.SetNotanumber();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TTrue& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetTrue(void) const
{
    CheckSelected(e_True);
    return *static_cast<const TTrue*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TTrue& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetTrue(void)
{
    Select(e_True, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TTrue& value = *static_cast<TTrue*>(m_object);
    value.SetTrue();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TFalse& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetFalse(void) const
{
    CheckSelected(e_False);
    return *static_cast<const TFalse*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TFalse& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetFalse(void)
{
    Select(e_False, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TFalse& value = *static_cast<TFalse*>(m_object);
    value.SetFalse();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TPi& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetPi(void) const
{
    CheckSelected(e_Pi);
    return *static_cast<const TPi*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TPi& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetPi(void)
{
    Select(e_Pi, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TPi& value = *static_cast<TPi*>(m_object);
    value.SetPi();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetEulergamma(void) const
{
    CheckSelected(e_Eulergamma);
    return *static_cast<const TEulergamma*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetEulergamma(void)
{
    Select(e_Eulergamma, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& value = *static_cast<TEulergamma*>(m_object);
    value.SetEulergamma();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TInfinity& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::GetInfinity(void) const
{
    CheckSelected(e_Infinity);
    return *static_cast<const TInfinity*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TInfinity& CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::SetInfinity(void)
{
    Select(e_Infinity, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::TInfinity& value = *static_cast<TInfinity*>(m_object);
    value.SetInfinity();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.ContExp.constant-arith", "mmlclass");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("exponentiale", m_object, CExponentiale)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("imaginaryi", m_object, CImaginaryi)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("notanumber", m_object, CNotanumber)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("true", m_object, CTrue)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("false", m_object, CFalse)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("pi", m_object, CPi)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("eulergamma", m_object, CEulergamma)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("infinity", m_object, CInfinity)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::C_Constant_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_Constant_arith_mmlclass::~C_Constant_arith_mmlclass(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_Piecewise:
    case e_DeprecatedContExp:
    case e_Interval_mmlclass:
    case e_Unary_functional_mmlclass:
    case e_Lambda_mmlclass:
    case e_Nary_functional_mmlclass:
    case e_Binary_arith_mmlclass:
    case e_Unary_arith_mmlclass:
    case e_Nary_minmax_mmlclass:
    case e_Nary_arith_mmlclass:
    case e_Nary_logical_mmlclass:
    case e_Unary_logical_mmlclass:
    case e_Binary_logical_mmlclass:
    case e_Quantifier_mmlclass:
    case e_Nary_reln_mmlclass:
    case e_Binary_reln_mmlclass:
    case e_Int_mmlclass:
    case e_Differential_Operator_mmlclass:
    case e_Partialdiff_mmlclass:
    case e_Unary_veccalc_mmlclass:
    case e_Nary_setlist_constructor_mmlclass:
    case e_Nary_set_mmlclass:
    case e_Binary_set_mmlclass:
    case e_Nary_set_reln_mmlclass:
    case e_Unary_set_mmlclass:
    case e_Sum_mmlclass:
    case e_Product_mmlclass:
    case e_Limit_mmlclass:
    case e_Unary_elementary_mmlclass:
    case e_Nary_stats_mmlclass:
    case e_Nary_constructor_mmlclass:
    case e_Unary_linalg_mmlclass:
    case e_Nary_linalg_mmlclass:
    case e_Binary_linalg_mmlclass:
    case e_Constant_set_mmlclass:
    case e_Constant_arith_mmlclass:
    case e_Semantics:
    case e_Cn:
    case e_Ci:
    case e_Csymbol:
    case e_Apply:
    case e_Bind:
    case e_Share:
    case e_Cerror:
    case e_Cbytes:
    case e_Cs:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_Piecewise:
        (m_object = new(pool) ncbi::objects::CPiecewise())->AddReference();
        break;
    case e_DeprecatedContExp:
        (m_object = new(pool) C_DeprecatedContExp())->AddReference();
        break;
    case e_Interval_mmlclass:
        (m_object = new(pool) C_Interval_mmlclass())->AddReference();
        break;
    case e_Unary_functional_mmlclass:
        (m_object = new(pool) C_Unary_functional_mmlclass())->AddReference();
        break;
    case e_Lambda_mmlclass:
        (m_object = new(pool) C_Lambda_mmlclass())->AddReference();
        break;
    case e_Nary_functional_mmlclass:
        (m_object = new(pool) C_Nary_functional_mmlclass())->AddReference();
        break;
    case e_Binary_arith_mmlclass:
        (m_object = new(pool) C_Binary_arith_mmlclass())->AddReference();
        break;
    case e_Unary_arith_mmlclass:
        (m_object = new(pool) C_Unary_arith_mmlclass())->AddReference();
        break;
    case e_Nary_minmax_mmlclass:
        (m_object = new(pool) C_Nary_minmax_mmlclass())->AddReference();
        break;
    case e_Nary_arith_mmlclass:
        (m_object = new(pool) C_Nary_arith_mmlclass())->AddReference();
        break;
    case e_Nary_logical_mmlclass:
        (m_object = new(pool) C_Nary_logical_mmlclass())->AddReference();
        break;
    case e_Unary_logical_mmlclass:
        (m_object = new(pool) C_Unary_logical_mmlclass())->AddReference();
        break;
    case e_Binary_logical_mmlclass:
        (m_object = new(pool) C_Binary_logical_mmlclass())->AddReference();
        break;
    case e_Quantifier_mmlclass:
        (m_object = new(pool) C_Quantifier_mmlclass())->AddReference();
        break;
    case e_Nary_reln_mmlclass:
        (m_object = new(pool) C_Nary_reln_mmlclass())->AddReference();
        break;
    case e_Binary_reln_mmlclass:
        (m_object = new(pool) C_Binary_reln_mmlclass())->AddReference();
        break;
    case e_Int_mmlclass:
        (m_object = new(pool) C_Int_mmlclass())->AddReference();
        break;
    case e_Differential_Operator_mmlclass:
        (m_object = new(pool) C_Differential_Operator_mmlclass())->AddReference();
        break;
    case e_Partialdiff_mmlclass:
        (m_object = new(pool) C_Partialdiff_mmlclass())->AddReference();
        break;
    case e_Unary_veccalc_mmlclass:
        (m_object = new(pool) C_Unary_veccalc_mmlclass())->AddReference();
        break;
    case e_Nary_setlist_constructor_mmlclass:
        (m_object = new(pool) C_Nary_setlist_constructor_mmlclass())->AddReference();
        break;
    case e_Nary_set_mmlclass:
        (m_object = new(pool) C_Nary_set_mmlclass())->AddReference();
        break;
    case e_Binary_set_mmlclass:
        (m_object = new(pool) C_Binary_set_mmlclass())->AddReference();
        break;
    case e_Nary_set_reln_mmlclass:
        (m_object = new(pool) C_Nary_set_reln_mmlclass())->AddReference();
        break;
    case e_Unary_set_mmlclass:
        (m_object = new(pool) C_Unary_set_mmlclass())->AddReference();
        break;
    case e_Sum_mmlclass:
        (m_object = new(pool) C_Sum_mmlclass())->AddReference();
        break;
    case e_Product_mmlclass:
        (m_object = new(pool) C_Product_mmlclass())->AddReference();
        break;
    case e_Limit_mmlclass:
        (m_object = new(pool) C_Limit_mmlclass())->AddReference();
        break;
    case e_Unary_elementary_mmlclass:
        (m_object = new(pool) C_Unary_elementary_mmlclass())->AddReference();
        break;
    case e_Nary_stats_mmlclass:
        (m_object = new(pool) C_Nary_stats_mmlclass())->AddReference();
        break;
    case e_Nary_constructor_mmlclass:
        (m_object = new(pool) C_Nary_constructor_mmlclass())->AddReference();
        break;
    case e_Unary_linalg_mmlclass:
        (m_object = new(pool) C_Unary_linalg_mmlclass())->AddReference();
        break;
    case e_Nary_linalg_mmlclass:
        (m_object = new(pool) C_Nary_linalg_mmlclass())->AddReference();
        break;
    case e_Binary_linalg_mmlclass:
        (m_object = new(pool) C_Binary_linalg_mmlclass())->AddReference();
        break;
    case e_Constant_set_mmlclass:
        (m_object = new(pool) C_Constant_set_mmlclass())->AddReference();
        break;
    case e_Constant_arith_mmlclass:
        (m_object = new(pool) C_Constant_arith_mmlclass())->AddReference();
        break;
    case e_Semantics:
        (m_object = new(pool) ncbi::objects::CSemantics())->AddReference();
        break;
    case e_Cn:
        (m_object = new(pool) ncbi::objects::CCn())->AddReference();
        break;
    case e_Ci:
        (m_object = new(pool) ncbi::objects::CCi())->AddReference();
        break;
    case e_Csymbol:
        (m_object = new(pool) ncbi::objects::CCsymbol())->AddReference();
        break;
    case e_Apply:
        (m_object = new(pool) ncbi::objects::CApply())->AddReference();
        break;
    case e_Bind:
        (m_object = new(pool) ncbi::objects::CBind())->AddReference();
        break;
    case e_Share:
        (m_object = new(pool) ncbi::objects::CShare())->AddReference();
        break;
    case e_Cerror:
        (m_object = new(pool) ncbi::objects::CCerror())->AddReference();
        break;
    case e_Cbytes:
        (m_object = new(pool) ncbi::objects::CCbytes())->AddReference();
        break;
    case e_Cs:
        (m_object = new(pool) ncbi::objects::CCs())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::C_ContExp::sm_SelectionNames[] = {
    "not set",
    "piecewise",
    "DeprecatedContExp",
    "interval.mmlclass",
    "unary-functional.mmlclass",
    "lambda.mmlclass",
    "nary-functional.mmlclass",
    "binary-arith.mmlclass",
    "unary-arith.mmlclass",
    "nary-minmax.mmlclass",
    "nary-arith.mmlclass",
    "nary-logical.mmlclass",
    "unary-logical.mmlclass",
    "binary-logical.mmlclass",
    "quantifier.mmlclass",
    "nary-reln.mmlclass",
    "binary-reln.mmlclass",
    "int.mmlclass",
    "Differential-Operator.mmlclass",
    "partialdiff.mmlclass",
    "unary-veccalc.mmlclass",
    "nary-setlist-constructor.mmlclass",
    "nary-set.mmlclass",
    "binary-set.mmlclass",
    "nary-set-reln.mmlclass",
    "unary-set.mmlclass",
    "sum.mmlclass",
    "product.mmlclass",
    "limit.mmlclass",
    "unary-elementary.mmlclass",
    "nary-stats.mmlclass",
    "nary-constructor.mmlclass",
    "unary-linalg.mmlclass",
    "nary-linalg.mmlclass",
    "binary-linalg.mmlclass",
    "constant-set.mmlclass",
    "constant-arith.mmlclass",
    "semantics",
    "cn",
    "ci",
    "csymbol",
    "apply",
    "bind",
    "share",
    "cerror",
    "cbytes",
    "cs"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::C_ContExp::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::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 CMsrowExpression_Base::C_MathExpression::C_ContExp::TPiecewise& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetPiecewise(void) const
{
    CheckSelected(e_Piecewise);
    return *static_cast<const TPiecewise*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TPiecewise& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetPiecewise(void)
{
    Select(e_Piecewise, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPiecewise*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetPiecewise(CMsrowExpression_Base::C_MathExpression::C_ContExp::TPiecewise& value)
{
    TPiecewise* ptr = &value;
    if ( m_choice != e_Piecewise || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Piecewise;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TDeprecatedContExp& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetDeprecatedContExp(void) const
{
    CheckSelected(e_DeprecatedContExp);
    return *static_cast<const TDeprecatedContExp*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TDeprecatedContExp& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetDeprecatedContExp(void)
{
    Select(e_DeprecatedContExp, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDeprecatedContExp*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetDeprecatedContExp(CMsrowExpression_Base::C_MathExpression::C_ContExp::TDeprecatedContExp& value)
{
    TDeprecatedContExp* ptr = &value;
    if ( m_choice != e_DeprecatedContExp || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_DeprecatedContExp;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TInterval_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetInterval_mmlclass(void) const
{
    CheckSelected(e_Interval_mmlclass);
    return *static_cast<const TInterval_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TInterval_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetInterval_mmlclass(void)
{
    Select(e_Interval_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TInterval_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetInterval_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TInterval_mmlclass& value)
{
    TInterval_mmlclass* ptr = &value;
    if ( m_choice != e_Interval_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Interval_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_functional_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_functional_mmlclass(void) const
{
    CheckSelected(e_Unary_functional_mmlclass);
    return *static_cast<const TUnary_functional_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_functional_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_functional_mmlclass(void)
{
    Select(e_Unary_functional_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_functional_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_functional_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_functional_mmlclass& value)
{
    TUnary_functional_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_functional_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_functional_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TLambda_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetLambda_mmlclass(void) const
{
    CheckSelected(e_Lambda_mmlclass);
    return *static_cast<const TLambda_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TLambda_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetLambda_mmlclass(void)
{
    Select(e_Lambda_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TLambda_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetLambda_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TLambda_mmlclass& value)
{
    TLambda_mmlclass* ptr = &value;
    if ( m_choice != e_Lambda_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Lambda_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_functional_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_functional_mmlclass(void) const
{
    CheckSelected(e_Nary_functional_mmlclass);
    return *static_cast<const TNary_functional_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_functional_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_functional_mmlclass(void)
{
    Select(e_Nary_functional_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_functional_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_functional_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_functional_mmlclass& value)
{
    TNary_functional_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_functional_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_functional_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBinary_arith_mmlclass(void) const
{
    CheckSelected(e_Binary_arith_mmlclass);
    return *static_cast<const TBinary_arith_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_arith_mmlclass(void)
{
    Select(e_Binary_arith_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBinary_arith_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_arith_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_arith_mmlclass& value)
{
    TBinary_arith_mmlclass* ptr = &value;
    if ( m_choice != e_Binary_arith_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Binary_arith_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_arith_mmlclass(void) const
{
    CheckSelected(e_Unary_arith_mmlclass);
    return *static_cast<const TUnary_arith_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_arith_mmlclass(void)
{
    Select(e_Unary_arith_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_arith_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_arith_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_arith_mmlclass& value)
{
    TUnary_arith_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_arith_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_arith_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_minmax_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_minmax_mmlclass(void) const
{
    CheckSelected(e_Nary_minmax_mmlclass);
    return *static_cast<const TNary_minmax_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_minmax_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_minmax_mmlclass(void)
{
    Select(e_Nary_minmax_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_minmax_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_minmax_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_minmax_mmlclass& value)
{
    TNary_minmax_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_minmax_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_minmax_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_arith_mmlclass(void) const
{
    CheckSelected(e_Nary_arith_mmlclass);
    return *static_cast<const TNary_arith_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_arith_mmlclass(void)
{
    Select(e_Nary_arith_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_arith_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_arith_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_arith_mmlclass& value)
{
    TNary_arith_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_arith_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_arith_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_logical_mmlclass(void) const
{
    CheckSelected(e_Nary_logical_mmlclass);
    return *static_cast<const TNary_logical_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_logical_mmlclass(void)
{
    Select(e_Nary_logical_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_logical_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_logical_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_logical_mmlclass& value)
{
    TNary_logical_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_logical_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_logical_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_logical_mmlclass(void) const
{
    CheckSelected(e_Unary_logical_mmlclass);
    return *static_cast<const TUnary_logical_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_logical_mmlclass(void)
{
    Select(e_Unary_logical_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_logical_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_logical_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_logical_mmlclass& value)
{
    TUnary_logical_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_logical_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_logical_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBinary_logical_mmlclass(void) const
{
    CheckSelected(e_Binary_logical_mmlclass);
    return *static_cast<const TBinary_logical_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_logical_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_logical_mmlclass(void)
{
    Select(e_Binary_logical_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBinary_logical_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_logical_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_logical_mmlclass& value)
{
    TBinary_logical_mmlclass* ptr = &value;
    if ( m_choice != e_Binary_logical_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Binary_logical_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TQuantifier_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetQuantifier_mmlclass(void) const
{
    CheckSelected(e_Quantifier_mmlclass);
    return *static_cast<const TQuantifier_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TQuantifier_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetQuantifier_mmlclass(void)
{
    Select(e_Quantifier_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TQuantifier_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetQuantifier_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TQuantifier_mmlclass& value)
{
    TQuantifier_mmlclass* ptr = &value;
    if ( m_choice != e_Quantifier_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Quantifier_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_reln_mmlclass(void) const
{
    CheckSelected(e_Nary_reln_mmlclass);
    return *static_cast<const TNary_reln_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_reln_mmlclass(void)
{
    Select(e_Nary_reln_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_reln_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_reln_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_reln_mmlclass& value)
{
    TNary_reln_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_reln_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_reln_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBinary_reln_mmlclass(void) const
{
    CheckSelected(e_Binary_reln_mmlclass);
    return *static_cast<const TBinary_reln_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_reln_mmlclass(void)
{
    Select(e_Binary_reln_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBinary_reln_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_reln_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_reln_mmlclass& value)
{
    TBinary_reln_mmlclass* ptr = &value;
    if ( m_choice != e_Binary_reln_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Binary_reln_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TInt_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetInt_mmlclass(void) const
{
    CheckSelected(e_Int_mmlclass);
    return *static_cast<const TInt_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TInt_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetInt_mmlclass(void)
{
    Select(e_Int_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TInt_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetInt_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TInt_mmlclass& value)
{
    TInt_mmlclass* ptr = &value;
    if ( m_choice != e_Int_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Int_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TDifferential_Operator_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetDifferential_Operator_mmlclass(void) const
{
    CheckSelected(e_Differential_Operator_mmlclass);
    return *static_cast<const TDifferential_Operator_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TDifferential_Operator_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetDifferential_Operator_mmlclass(void)
{
    Select(e_Differential_Operator_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDifferential_Operator_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetDifferential_Operator_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TDifferential_Operator_mmlclass& value)
{
    TDifferential_Operator_mmlclass* ptr = &value;
    if ( m_choice != e_Differential_Operator_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Differential_Operator_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TPartialdiff_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetPartialdiff_mmlclass(void) const
{
    CheckSelected(e_Partialdiff_mmlclass);
    return *static_cast<const TPartialdiff_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TPartialdiff_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetPartialdiff_mmlclass(void)
{
    Select(e_Partialdiff_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPartialdiff_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetPartialdiff_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TPartialdiff_mmlclass& value)
{
    TPartialdiff_mmlclass* ptr = &value;
    if ( m_choice != e_Partialdiff_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Partialdiff_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_veccalc_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_veccalc_mmlclass(void) const
{
    CheckSelected(e_Unary_veccalc_mmlclass);
    return *static_cast<const TUnary_veccalc_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_veccalc_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_veccalc_mmlclass(void)
{
    Select(e_Unary_veccalc_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_veccalc_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_veccalc_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_veccalc_mmlclass& value)
{
    TUnary_veccalc_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_veccalc_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_veccalc_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_setlist_constructor_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_setlist_constructor_mmlclass(void) const
{
    CheckSelected(e_Nary_setlist_constructor_mmlclass);
    return *static_cast<const TNary_setlist_constructor_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_setlist_constructor_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_setlist_constructor_mmlclass(void)
{
    Select(e_Nary_setlist_constructor_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_setlist_constructor_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_setlist_constructor_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_setlist_constructor_mmlclass& value)
{
    TNary_setlist_constructor_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_setlist_constructor_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_setlist_constructor_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_set_mmlclass(void) const
{
    CheckSelected(e_Nary_set_mmlclass);
    return *static_cast<const TNary_set_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_set_mmlclass(void)
{
    Select(e_Nary_set_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_set_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_set_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_mmlclass& value)
{
    TNary_set_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_set_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_set_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBinary_set_mmlclass(void) const
{
    CheckSelected(e_Binary_set_mmlclass);
    return *static_cast<const TBinary_set_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_set_mmlclass(void)
{
    Select(e_Binary_set_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBinary_set_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_set_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_set_mmlclass& value)
{
    TBinary_set_mmlclass* ptr = &value;
    if ( m_choice != e_Binary_set_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Binary_set_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_set_reln_mmlclass(void) const
{
    CheckSelected(e_Nary_set_reln_mmlclass);
    return *static_cast<const TNary_set_reln_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_reln_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_set_reln_mmlclass(void)
{
    Select(e_Nary_set_reln_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_set_reln_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_set_reln_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_set_reln_mmlclass& value)
{
    TNary_set_reln_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_set_reln_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_set_reln_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_set_mmlclass(void) const
{
    CheckSelected(e_Unary_set_mmlclass);
    return *static_cast<const TUnary_set_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_set_mmlclass(void)
{
    Select(e_Unary_set_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_set_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_set_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_set_mmlclass& value)
{
    TUnary_set_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_set_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_set_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TSum_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetSum_mmlclass(void) const
{
    CheckSelected(e_Sum_mmlclass);
    return *static_cast<const TSum_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TSum_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetSum_mmlclass(void)
{
    Select(e_Sum_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSum_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetSum_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TSum_mmlclass& value)
{
    TSum_mmlclass* ptr = &value;
    if ( m_choice != e_Sum_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Sum_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TProduct_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetProduct_mmlclass(void) const
{
    CheckSelected(e_Product_mmlclass);
    return *static_cast<const TProduct_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TProduct_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetProduct_mmlclass(void)
{
    Select(e_Product_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TProduct_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetProduct_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TProduct_mmlclass& value)
{
    TProduct_mmlclass* ptr = &value;
    if ( m_choice != e_Product_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Product_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TLimit_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetLimit_mmlclass(void) const
{
    CheckSelected(e_Limit_mmlclass);
    return *static_cast<const TLimit_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TLimit_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetLimit_mmlclass(void)
{
    Select(e_Limit_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TLimit_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetLimit_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TLimit_mmlclass& value)
{
    TLimit_mmlclass* ptr = &value;
    if ( m_choice != e_Limit_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Limit_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_elementary_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_elementary_mmlclass(void) const
{
    CheckSelected(e_Unary_elementary_mmlclass);
    return *static_cast<const TUnary_elementary_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_elementary_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_elementary_mmlclass(void)
{
    Select(e_Unary_elementary_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_elementary_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_elementary_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_elementary_mmlclass& value)
{
    TUnary_elementary_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_elementary_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_elementary_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_stats_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_stats_mmlclass(void) const
{
    CheckSelected(e_Nary_stats_mmlclass);
    return *static_cast<const TNary_stats_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_stats_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_stats_mmlclass(void)
{
    Select(e_Nary_stats_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_stats_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_stats_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_stats_mmlclass& value)
{
    TNary_stats_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_stats_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_stats_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_constructor_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_constructor_mmlclass(void) const
{
    CheckSelected(e_Nary_constructor_mmlclass);
    return *static_cast<const TNary_constructor_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_constructor_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_constructor_mmlclass(void)
{
    Select(e_Nary_constructor_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_constructor_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_constructor_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_constructor_mmlclass& value)
{
    TNary_constructor_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_constructor_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_constructor_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetUnary_linalg_mmlclass(void) const
{
    CheckSelected(e_Unary_linalg_mmlclass);
    return *static_cast<const TUnary_linalg_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_linalg_mmlclass(void)
{
    Select(e_Unary_linalg_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TUnary_linalg_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetUnary_linalg_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TUnary_linalg_mmlclass& value)
{
    TUnary_linalg_mmlclass* ptr = &value;
    if ( m_choice != e_Unary_linalg_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Unary_linalg_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetNary_linalg_mmlclass(void) const
{
    CheckSelected(e_Nary_linalg_mmlclass);
    return *static_cast<const TNary_linalg_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_linalg_mmlclass(void)
{
    Select(e_Nary_linalg_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TNary_linalg_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetNary_linalg_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TNary_linalg_mmlclass& value)
{
    TNary_linalg_mmlclass* ptr = &value;
    if ( m_choice != e_Nary_linalg_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Nary_linalg_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBinary_linalg_mmlclass(void) const
{
    CheckSelected(e_Binary_linalg_mmlclass);
    return *static_cast<const TBinary_linalg_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_linalg_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_linalg_mmlclass(void)
{
    Select(e_Binary_linalg_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBinary_linalg_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBinary_linalg_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBinary_linalg_mmlclass& value)
{
    TBinary_linalg_mmlclass* ptr = &value;
    if ( m_choice != e_Binary_linalg_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Binary_linalg_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetConstant_set_mmlclass(void) const
{
    CheckSelected(e_Constant_set_mmlclass);
    return *static_cast<const TConstant_set_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_set_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetConstant_set_mmlclass(void)
{
    Select(e_Constant_set_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TConstant_set_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetConstant_set_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_set_mmlclass& value)
{
    TConstant_set_mmlclass* ptr = &value;
    if ( m_choice != e_Constant_set_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Constant_set_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetConstant_arith_mmlclass(void) const
{
    CheckSelected(e_Constant_arith_mmlclass);
    return *static_cast<const TConstant_arith_mmlclass*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_arith_mmlclass& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetConstant_arith_mmlclass(void)
{
    Select(e_Constant_arith_mmlclass, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TConstant_arith_mmlclass*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetConstant_arith_mmlclass(CMsrowExpression_Base::C_MathExpression::C_ContExp::TConstant_arith_mmlclass& value)
{
    TConstant_arith_mmlclass* ptr = &value;
    if ( m_choice != e_Constant_arith_mmlclass || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Constant_arith_mmlclass;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TSemantics& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetSemantics(void) const
{
    CheckSelected(e_Semantics);
    return *static_cast<const TSemantics*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TSemantics& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetSemantics(void)
{
    Select(e_Semantics, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSemantics*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetSemantics(CMsrowExpression_Base::C_MathExpression::C_ContExp::TSemantics& value)
{
    TSemantics* ptr = &value;
    if ( m_choice != e_Semantics || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Semantics;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCn& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCn(void) const
{
    CheckSelected(e_Cn);
    return *static_cast<const TCn*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCn& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCn(void)
{
    Select(e_Cn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCn*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCn(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCn& value)
{
    TCn* ptr = &value;
    if ( m_choice != e_Cn || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Cn;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCi& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCi(void) const
{
    CheckSelected(e_Ci);
    return *static_cast<const TCi*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCi& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCi(void)
{
    Select(e_Ci, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCi*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCi(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCi& value)
{
    TCi* ptr = &value;
    if ( m_choice != e_Ci || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Ci;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCsymbol& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCsymbol(void) const
{
    CheckSelected(e_Csymbol);
    return *static_cast<const TCsymbol*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCsymbol& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCsymbol(void)
{
    Select(e_Csymbol, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCsymbol*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCsymbol(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCsymbol& value)
{
    TCsymbol* ptr = &value;
    if ( m_choice != e_Csymbol || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Csymbol;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TApply& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetApply(void) const
{
    CheckSelected(e_Apply);
    return *static_cast<const TApply*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TApply& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetApply(void)
{
    Select(e_Apply, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TApply*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetApply(CMsrowExpression_Base::C_MathExpression::C_ContExp::TApply& value)
{
    TApply* ptr = &value;
    if ( m_choice != e_Apply || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Apply;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TBind& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetBind(void) const
{
    CheckSelected(e_Bind);
    return *static_cast<const TBind*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TBind& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBind(void)
{
    Select(e_Bind, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TBind*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetBind(CMsrowExpression_Base::C_MathExpression::C_ContExp::TBind& value)
{
    TBind* ptr = &value;
    if ( m_choice != e_Bind || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Bind;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TShare& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetShare(void) const
{
    CheckSelected(e_Share);
    return *static_cast<const TShare*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TShare& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetShare(void)
{
    Select(e_Share, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_ContExp::TShare& value = *static_cast<TShare*>(m_object);
    value.SetShare();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCerror& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCerror(void) const
{
    CheckSelected(e_Cerror);
    return *static_cast<const TCerror*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCerror& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCerror(void)
{
    Select(e_Cerror, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCerror*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCerror(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCerror& value)
{
    TCerror* ptr = &value;
    if ( m_choice != e_Cerror || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Cerror;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCbytes& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCbytes(void) const
{
    CheckSelected(e_Cbytes);
    return *static_cast<const TCbytes*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCbytes& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCbytes(void)
{
    Select(e_Cbytes, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCbytes*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCbytes(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCbytes& value)
{
    TCbytes* ptr = &value;
    if ( m_choice != e_Cbytes || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Cbytes;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::C_ContExp::TCs& CMsrowExpression_Base::C_MathExpression::C_ContExp::GetCs(void) const
{
    CheckSelected(e_Cs);
    return *static_cast<const TCs*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_ContExp::TCs& CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCs(void)
{
    Select(e_Cs, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TCs*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_ContExp::SetCs(CMsrowExpression_Base::C_MathExpression::C_ContExp::TCs& value)
{
    TCs* ptr = &value;
    if ( m_choice != e_Cs || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_Cs;
    }
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_ContExp)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression", "ContExp");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("piecewise", m_object, CPiecewise)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("DeprecatedContExp", m_object, C_DeprecatedContExp)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("interval.mmlclass", m_object, C_Interval_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-functional.mmlclass", m_object, C_Unary_functional_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("lambda.mmlclass", m_object, C_Lambda_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-functional.mmlclass", m_object, C_Nary_functional_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("binary-arith.mmlclass", m_object, C_Binary_arith_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-arith.mmlclass", m_object, C_Unary_arith_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-minmax.mmlclass", m_object, C_Nary_minmax_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-arith.mmlclass", m_object, C_Nary_arith_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-logical.mmlclass", m_object, C_Nary_logical_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-logical.mmlclass", m_object, C_Unary_logical_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("binary-logical.mmlclass", m_object, C_Binary_logical_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("quantifier.mmlclass", m_object, C_Quantifier_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-reln.mmlclass", m_object, C_Nary_reln_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("binary-reln.mmlclass", m_object, C_Binary_reln_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("int.mmlclass", m_object, C_Int_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("Differential-Operator.mmlclass", m_object, C_Differential_Operator_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("partialdiff.mmlclass", m_object, C_Partialdiff_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-veccalc.mmlclass", m_object, C_Unary_veccalc_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-setlist-constructor.mmlclass", m_object, C_Nary_setlist_constructor_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-set.mmlclass", m_object, C_Nary_set_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("binary-set.mmlclass", m_object, C_Binary_set_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-set-reln.mmlclass", m_object, C_Nary_set_reln_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-set.mmlclass", m_object, C_Unary_set_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("sum.mmlclass", m_object, C_Sum_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("product.mmlclass", m_object, C_Product_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("limit.mmlclass", m_object, C_Limit_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-elementary.mmlclass", m_object, C_Unary_elementary_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-stats.mmlclass", m_object, C_Nary_stats_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-constructor.mmlclass", m_object, C_Nary_constructor_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("unary-linalg.mmlclass", m_object, C_Unary_linalg_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("nary-linalg.mmlclass", m_object, C_Nary_linalg_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("binary-linalg.mmlclass", m_object, C_Binary_linalg_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("constant-set.mmlclass", m_object, C_Constant_set_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("constant-arith.mmlclass", m_object, C_Constant_arith_mmlclass)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("semantics", m_object, CSemantics)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cn", m_object, CCn)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("ci", m_object, CCi)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("csymbol", m_object, CCsymbol)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("apply", m_object, CApply)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("bind", m_object, CBind)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("share", m_object, CShare)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cerror", m_object, CCerror)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cbytes", m_object, CCbytes)->SetNsQualified(true);
    ADD_NAMED_REF_CHOICE_VARIANT("cs", m_object, CCs)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::C_ContExp(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_ContExp::~C_ContExp(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::sm_SelectionNames[] = {
    "not set",
    "mi",
    "mn",
    "mo",
    "mtext",
    "mspace",
    "ms"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMi& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMi(void) const
{
    CheckSelected(e_Mi);
    return *static_cast<const TMi*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMi& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMi(void)
{
    Select(e_Mi, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMi*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMi(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMn& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMn(void) const
{
    CheckSelected(e_Mn);
    return *static_cast<const TMn*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMn& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMn(void)
{
    Select(e_Mn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMn*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMn(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMo& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMo(void) const
{
    CheckSelected(e_Mo);
    return *static_cast<const TMo*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMo& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMo(void)
{
    Select(e_Mo, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMo*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMo(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMtext& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMtext(void) const
{
    CheckSelected(e_Mtext);
    return *static_cast<const TMtext*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMtext& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMtext(void)
{
    Select(e_Mtext, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMtext*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMtext(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMspace& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMspace(void) const
{
    CheckSelected(e_Mspace);
    return *static_cast<const TMspace*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMspace& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMspace(void)
{
    Select(e_Mspace, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMspace& value = *static_cast<TMspace*>(m_object);
    value.SetMspace();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMs& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::GetMs(void) const
{
    CheckSelected(e_Ms);
    return *static_cast<const TMs*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::TMs& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMs(void)
{
    Select(e_Ms, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMs*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::SetMs(CMsrowExpression_Base::C_MathExpression::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("", CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.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(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::C_TokenExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_TokenExpression::~C_TokenExpression(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::sm_SelectionNames[] = {
    "not set",
    "maligngroup",
    "malignmark"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMaligngroup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::GetMaligngroup(void) const
{
    CheckSelected(e_Maligngroup);
    return *static_cast<const TMaligngroup*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMaligngroup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::SetMaligngroup(void)
{
    Select(e_Maligngroup, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMaligngroup& value = *static_cast<TMaligngroup*>(m_object);
    value.SetMaligngroup();
    return value;
}
 
const CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMalignmark& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::GetMalignmark(void) const
{
    CheckSelected(e_Malignmark);
    return *static_cast<const TMalignmark*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMalignmark& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::SetMalignmark(void)
{
    Select(e_Malignmark, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::TMalignmark& value = *static_cast<TMalignmark*>(m_object);
    value.SetMalignmark();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression.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(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::C_MalignExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_MalignExpression::~C_MalignExpression(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TTokenExpression& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetTokenExpression(void) const
{
    CheckSelected(e_TokenExpression);
    return *static_cast<const TTokenExpression*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TTokenExpression& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetTokenExpression(void)
{
    Select(e_TokenExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TTokenExpression*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetTokenExpression(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMalignExpression& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMalignExpression(void) const
{
    CheckSelected(e_MalignExpression);
    return *static_cast<const TMalignExpression*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMalignExpression& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMalignExpression(void)
{
    Select(e_MalignExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMalignExpression*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMalignExpression(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMrow& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMrow(void) const
{
    CheckSelected(e_Mrow);
    return *static_cast<const TMrow*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMrow& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMrow(void)
{
    Select(e_Mrow, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMrow*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMrow(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMfrac& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMfrac(void) const
{
    CheckSelected(e_Mfrac);
    return *static_cast<const TMfrac*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMfrac& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMfrac(void)
{
    Select(e_Mfrac, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMfrac*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMfrac(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsqrt& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMsqrt(void) const
{
    CheckSelected(e_Msqrt);
    return *static_cast<const TMsqrt*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsqrt& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsqrt(void)
{
    Select(e_Msqrt, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsqrt*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsqrt(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMroot& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMroot(void) const
{
    CheckSelected(e_Mroot);
    return *static_cast<const TMroot*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMroot& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMroot(void)
{
    Select(e_Mroot, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMroot*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMroot(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMstyle& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMstyle(void) const
{
    CheckSelected(e_Mstyle);
    return *static_cast<const TMstyle*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMstyle& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMstyle(void)
{
    Select(e_Mstyle, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMstyle*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMstyle(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMerror& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMerror(void) const
{
    CheckSelected(e_Merror);
    return *static_cast<const TMerror*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMerror& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMerror(void)
{
    Select(e_Merror, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMerror*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMerror(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMpadded& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMpadded(void) const
{
    CheckSelected(e_Mpadded);
    return *static_cast<const TMpadded*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMpadded& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMpadded(void)
{
    Select(e_Mpadded, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMpadded*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMpadded(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMphantom& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMphantom(void) const
{
    CheckSelected(e_Mphantom);
    return *static_cast<const TMphantom*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMphantom& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMphantom(void)
{
    Select(e_Mphantom, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMphantom*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMphantom(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMfenced& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMfenced(void) const
{
    CheckSelected(e_Mfenced);
    return *static_cast<const TMfenced*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMfenced& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMfenced(void)
{
    Select(e_Mfenced, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMfenced*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMfenced(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMenclose& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMenclose(void) const
{
    CheckSelected(e_Menclose);
    return *static_cast<const TMenclose*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMenclose& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMenclose(void)
{
    Select(e_Menclose, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMenclose*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMenclose(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsub& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMsub(void) const
{
    CheckSelected(e_Msub);
    return *static_cast<const TMsub*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsub& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsub(void)
{
    Select(e_Msub, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsub*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsub(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMsup(void) const
{
    CheckSelected(e_Msup);
    return *static_cast<const TMsup*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsup(void)
{
    Select(e_Msup, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsup*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsup(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsubsup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMsubsup(void) const
{
    CheckSelected(e_Msubsup);
    return *static_cast<const TMsubsup*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMsubsup& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsubsup(void)
{
    Select(e_Msubsup, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMsubsup*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMsubsup(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMunder& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMunder(void) const
{
    CheckSelected(e_Munder);
    return *static_cast<const TMunder*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMunder& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMunder(void)
{
    Select(e_Munder, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMunder*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMunder(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMover& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMover(void) const
{
    CheckSelected(e_Mover);
    return *static_cast<const TMover*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMover& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMover(void)
{
    Select(e_Mover, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMover*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMover(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMunderover& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMunderover(void) const
{
    CheckSelected(e_Munderover);
    return *static_cast<const TMunderover*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMunderover& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMunderover(void)
{
    Select(e_Munderover, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMunderover*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMunderover(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMmultiscripts& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMmultiscripts(void) const
{
    CheckSelected(e_Mmultiscripts);
    return *static_cast<const TMmultiscripts*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMmultiscripts& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMmultiscripts(void)
{
    Select(e_Mmultiscripts, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMmultiscripts*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMmultiscripts(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMtable& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMtable(void) const
{
    CheckSelected(e_Mtable);
    return *static_cast<const TMtable*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMtable& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMtable(void)
{
    Select(e_Mtable, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMtable*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMtable(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMstack& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMstack(void) const
{
    CheckSelected(e_Mstack);
    return *static_cast<const TMstack*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMstack& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMstack(void)
{
    Select(e_Mstack, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMstack*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMstack(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMlongdiv& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMlongdiv(void) const
{
    CheckSelected(e_Mlongdiv);
    return *static_cast<const TMlongdiv*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMlongdiv& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMlongdiv(void)
{
    Select(e_Mlongdiv, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMlongdiv*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMlongdiv(CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMaction& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::GetMaction(void) const
{
    CheckSelected(e_Maction);
    return *static_cast<const TMaction*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::TMaction& CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMaction(void)
{
    Select(e_Maction, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMaction*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::SetMaction(CMsrowExpression_Base::C_MathExpression::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("", CMsrowExpression_Base::C_MathExpression::C_PresentationExpression)
{
    SET_INTERNAL_NAME("MsrowExpression.MathExpression", "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(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::C_PresentationExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::C_PresentationExpression::~C_PresentationExpression(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::C_MathExpression::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::C_MathExpression::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_ContExp:
    case e_PresentationExpression:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::C_MathExpression::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_ContExp:
        (m_object = new(pool) C_ContExp())->AddReference();
        break;
    case e_PresentationExpression:
        (m_object = new(pool) C_PresentationExpression())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::C_MathExpression::sm_SelectionNames[] = {
    "not set",
    "ContExp",
    "PresentationExpression"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::C_MathExpression::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_Base::C_MathExpression::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 CMsrowExpression_Base::C_MathExpression::TContExp& CMsrowExpression_Base::C_MathExpression::GetContExp(void) const
{
    CheckSelected(e_ContExp);
    return *static_cast<const TContExp*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::TContExp& CMsrowExpression_Base::C_MathExpression::SetContExp(void)
{
    Select(e_ContExp, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TContExp*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::SetContExp(CMsrowExpression_Base::C_MathExpression::TContExp& value)
{
    TContExp* ptr = &value;
    if ( m_choice != e_ContExp || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_ContExp;
    }
}
 
const CMsrowExpression_Base::C_MathExpression::TPresentationExpression& CMsrowExpression_Base::C_MathExpression::GetPresentationExpression(void) const
{
    CheckSelected(e_PresentationExpression);
    return *static_cast<const TPresentationExpression*>(m_object);
}
 
CMsrowExpression_Base::C_MathExpression::TPresentationExpression& CMsrowExpression_Base::C_MathExpression::SetPresentationExpression(void)
{
    Select(e_PresentationExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TPresentationExpression*>(m_object);
}
 
void CMsrowExpression_Base::C_MathExpression::SetPresentationExpression(CMsrowExpression_Base::C_MathExpression::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("", CMsrowExpression_Base::C_MathExpression)
{
    SET_INTERNAL_NAME("MsrowExpression", "MathExpression");
    SET_CHOICE_MODULE("pubmed_mathml3");
    ADD_NAMED_REF_CHOICE_VARIANT("ContExp", m_object, C_ContExp)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("PresentationExpression", m_object, C_PresentationExpression)->SetNotag();
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::C_MathExpression::C_MathExpression(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::C_MathExpression::~C_MathExpression(void)
{
    Reset();
}
 
 
void CMsrowExpression_Base::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CMsrowExpression_Base::ResetSelection(void)
{
    switch ( m_choice ) {
    case e_MathExpression:
    case e_None:
        m_object->RemoveReference();
        break;
    default:
        break;
    }
    m_choice = e_not_set;
}
 
void CMsrowExpression_Base::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    switch ( index ) {
    case e_MathExpression:
        (m_object = new(pool) C_MathExpression())->AddReference();
        break;
    case e_None:
        (m_object = new(pool) ncbi::objects::CNone())->AddReference();
        break;
    default:
        break;
    }
    m_choice = index;
}
 
const char* const CMsrowExpression_Base::sm_SelectionNames[] = {
    "not set",
    "MathExpression",
    "none"
};
 
NCBI_NS_STD::string CMsrowExpression_Base::SelectionName(E_Choice index)
{
    return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
}
 
void CMsrowExpression_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 CMsrowExpression_Base::TMathExpression& CMsrowExpression_Base::GetMathExpression(void) const
{
    CheckSelected(e_MathExpression);
    return *static_cast<const TMathExpression*>(m_object);
}
 
CMsrowExpression_Base::TMathExpression& CMsrowExpression_Base::SetMathExpression(void)
{
    Select(e_MathExpression, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMathExpression*>(m_object);
}
 
void CMsrowExpression_Base::SetMathExpression(CMsrowExpression_Base::TMathExpression& value)
{
    TMathExpression* ptr = &value;
    if ( m_choice != e_MathExpression || m_object != ptr ) {
        ResetSelection();
        (m_object = ptr)->AddReference();
        m_choice = e_MathExpression;
    }
}
 
const CMsrowExpression_Base::TNone& CMsrowExpression_Base::GetNone(void) const
{
    CheckSelected(e_None);
    return *static_cast<const TNone*>(m_object);
}
 
CMsrowExpression_Base::TNone& CMsrowExpression_Base::SetNone(void)
{
    Select(e_None, NCBI_NS_NCBI::eDoNotResetVariant);
    CMsrowExpression_Base::TNone& value = *static_cast<TNone*>(m_object);
    value.SetNone();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_BASE_CHOICE_INFO("", CMsrowExpression)
{
    SET_CHOICE_MODULE("pubmed_mathml3");
    SET_NAMESPACE("http://www.w3.org/1998/Math/MathML")->SetNsQualified(false);
    ADD_NAMED_REF_CHOICE_VARIANT("MathExpression", m_object, C_MathExpression)->SetNotag();
    ADD_NAMED_REF_CHOICE_VARIANT("none", m_object, CNone)->SetNsQualified(true);
    info->CodeVersion(22400);
    info->DataSpec(ncbi::EDataSpec::eXSD);
}
END_CHOICE_INFO
 
// constructor
CMsrowExpression_Base::CMsrowExpression_Base(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CMsrowExpression_Base::~CMsrowExpression_Base(void)
{
    Reset();
}
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE