ImpliedMrow_.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/ImpliedMrow.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/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 CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::sm_SelectionNames[] = {
    "not set",
    "reln",
    "fn",
    "declare"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TReln& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::GetReln(void) const
{
    CheckSelected(e_Reln);
    return *static_cast<const TReln*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TReln& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetReln(void)
{
    Select(e_Reln, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TReln*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetReln(CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TFn& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::GetFn(void) const
{
    CheckSelected(e_Fn);
    return *static_cast<const TFn*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TFn& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetFn(void)
{
    Select(e_Fn, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TFn*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetFn(CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TDeclare& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::GetDeclare(void) const
{
    CheckSelected(e_Declare);
    return *static_cast<const TDeclare*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::TDeclare& CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetDeclare(void)
{
    Select(e_Declare, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TDeclare*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::SetDeclare(CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::C_DeprecatedContExp(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_DeprecatedContExp::~C_DeprecatedContExp(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::ResetInterval(void)
{
    if ( !m_Interval ) {
        m_Interval.Reset(new TInterval());
        return;
    }
    (*m_Interval).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::SetInterval(CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::TInterval& value)
{
    m_Interval.Reset(&value);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::Reset(void)
{
    ResetInterval();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::C_Interval_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetInterval();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Interval_mmlclass::~C_Interval_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::sm_SelectionNames[] = {
    "not set",
    "inverse",
    "ident",
    "domain",
    "codomain",
    "image",
    "ln",
    "log",
    "moment"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TInverse& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetInverse(void) const
{
    CheckSelected(e_Inverse);
    return *static_cast<const TInverse*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TInverse& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetInverse(void)
{
    Select(e_Inverse, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TInverse& value = *static_cast<TInverse*>(m_object);
    value.SetInverse();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TIdent& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetIdent(void) const
{
    CheckSelected(e_Ident);
    return *static_cast<const TIdent*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TIdent& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetIdent(void)
{
    Select(e_Ident, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TIdent& value = *static_cast<TIdent*>(m_object);
    value.SetIdent();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TDomain& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetDomain(void) const
{
    CheckSelected(e_Domain);
    return *static_cast<const TDomain*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TDomain& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetDomain(void)
{
    Select(e_Domain, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TDomain& value = *static_cast<TDomain*>(m_object);
    value.SetDomain();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TCodomain& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetCodomain(void) const
{
    CheckSelected(e_Codomain);
    return *static_cast<const TCodomain*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TCodomain& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetCodomain(void)
{
    Select(e_Codomain, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TCodomain& value = *static_cast<TCodomain*>(m_object);
    value.SetCodomain();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TImage& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetImage(void) const
{
    CheckSelected(e_Image);
    return *static_cast<const TImage*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TImage& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetImage(void)
{
    Select(e_Image, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TImage& value = *static_cast<TImage*>(m_object);
    value.SetImage();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLn& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetLn(void) const
{
    CheckSelected(e_Ln);
    return *static_cast<const TLn*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLn& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetLn(void)
{
    Select(e_Ln, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLn& value = *static_cast<TLn*>(m_object);
    value.SetLn();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLog& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetLog(void) const
{
    CheckSelected(e_Log);
    return *static_cast<const TLog*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLog& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetLog(void)
{
    Select(e_Log, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TLog& value = *static_cast<TLog*>(m_object);
    value.SetLog();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TMoment& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::GetMoment(void) const
{
    CheckSelected(e_Moment);
    return *static_cast<const TMoment*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::TMoment& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::SetMoment(void)
{
    Select(e_Moment, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::C_Unary_functional_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_functional_mmlclass::~C_Unary_functional_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::ResetLambda(void)
{
    if ( !m_Lambda ) {
        m_Lambda.Reset(new TLambda());
        return;
    }
    (*m_Lambda).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::SetLambda(CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::TLambda& value)
{
    m_Lambda.Reset(&value);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::Reset(void)
{
    ResetLambda();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::C_Lambda_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetLambda();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Lambda_mmlclass::~C_Lambda_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::IsSetCompose(void) const
{
    return m_Compose ? m_Compose->IsSetCompose() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::ResetCompose(void)
{
    if ( !m_Compose ) {
        m_Compose.Reset(new TCompose());
        return;
    }
    (*m_Compose).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::SetCompose(CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::TCompose& value)
{
    m_Compose.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::TCompose& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::SetCompose(void)
{
    if ( !m_Compose ) {
        ResetCompose();
    }
    m_Compose->SetCompose();
    return (*m_Compose);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::Reset(void)
{
    ResetCompose();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::C_Nary_functional_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetCompose();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_functional_mmlclass::~C_Nary_functional_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "quotient",
    "divide",
    "minus",
    "power",
    "rem",
    "root"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TQuotient& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetQuotient(void) const
{
    CheckSelected(e_Quotient);
    return *static_cast<const TQuotient*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TQuotient& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetQuotient(void)
{
    Select(e_Quotient, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TQuotient& value = *static_cast<TQuotient*>(m_object);
    value.SetQuotient();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TDivide& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetDivide(void) const
{
    CheckSelected(e_Divide);
    return *static_cast<const TDivide*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TDivide& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetDivide(void)
{
    Select(e_Divide, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TDivide& value = *static_cast<TDivide*>(m_object);
    value.SetDivide();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TMinus& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetMinus(void) const
{
    CheckSelected(e_Minus);
    return *static_cast<const TMinus*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TMinus& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetMinus(void)
{
    Select(e_Minus, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TMinus& value = *static_cast<TMinus*>(m_object);
    value.SetMinus();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TPower& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetPower(void) const
{
    CheckSelected(e_Power);
    return *static_cast<const TPower*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TPower& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetPower(void)
{
    Select(e_Power, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TPower& value = *static_cast<TPower*>(m_object);
    value.SetPower();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TRem& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetRem(void) const
{
    CheckSelected(e_Rem);
    return *static_cast<const TRem*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TRem& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetRem(void)
{
    Select(e_Rem, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TRem& value = *static_cast<TRem*>(m_object);
    value.SetRem();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TRoot& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::GetRoot(void) const
{
    CheckSelected(e_Root);
    return *static_cast<const TRoot*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::TRoot& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::SetRoot(void)
{
    Select(e_Root, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::C_Binary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_arith_mmlclass::~C_Binary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "factorial",
    "abs",
    "conjugate",
    "arg",
    "real",
    "imaginary",
    "floor",
    "ceiling",
    "exp"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFactorial& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetFactorial(void) const
{
    CheckSelected(e_Factorial);
    return *static_cast<const TFactorial*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFactorial& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetFactorial(void)
{
    Select(e_Factorial, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFactorial& value = *static_cast<TFactorial*>(m_object);
    value.SetFactorial();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TAbs& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetAbs(void) const
{
    CheckSelected(e_Abs);
    return *static_cast<const TAbs*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TAbs& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetAbs(void)
{
    Select(e_Abs, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TAbs& value = *static_cast<TAbs*>(m_object);
    value.SetAbs();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TConjugate& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetConjugate(void) const
{
    CheckSelected(e_Conjugate);
    return *static_cast<const TConjugate*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TConjugate& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetConjugate(void)
{
    Select(e_Conjugate, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TConjugate& value = *static_cast<TConjugate*>(m_object);
    value.SetConjugate();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TArg& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetArg(void) const
{
    CheckSelected(e_Arg);
    return *static_cast<const TArg*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TArg& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetArg(void)
{
    Select(e_Arg, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TArg& value = *static_cast<TArg*>(m_object);
    value.SetArg();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TReal& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetReal(void) const
{
    CheckSelected(e_Real);
    return *static_cast<const TReal*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TReal& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetReal(void)
{
    Select(e_Real, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TReal& value = *static_cast<TReal*>(m_object);
    value.SetReal();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TImaginary& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetImaginary(void) const
{
    CheckSelected(e_Imaginary);
    return *static_cast<const TImaginary*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TImaginary& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetImaginary(void)
{
    Select(e_Imaginary, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TImaginary& value = *static_cast<TImaginary*>(m_object);
    value.SetImaginary();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFloor& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetFloor(void) const
{
    CheckSelected(e_Floor);
    return *static_cast<const TFloor*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFloor& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetFloor(void)
{
    Select(e_Floor, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TFloor& value = *static_cast<TFloor*>(m_object);
    value.SetFloor();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TCeiling& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetCeiling(void) const
{
    CheckSelected(e_Ceiling);
    return *static_cast<const TCeiling*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TCeiling& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetCeiling(void)
{
    Select(e_Ceiling, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TCeiling& value = *static_cast<TCeiling*>(m_object);
    value.SetCeiling();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TExp& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::GetExp(void) const
{
    CheckSelected(e_Exp);
    return *static_cast<const TExp*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::TExp& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::SetExp(void)
{
    Select(e_Exp, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::C_Unary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_arith_mmlclass::~C_Unary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::sm_SelectionNames[] = {
    "not set",
    "max",
    "min"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::TMax& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::GetMax(void) const
{
    CheckSelected(e_Max);
    return *static_cast<const TMax*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::TMax& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::SetMax(void)
{
    Select(e_Max, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::TMax& value = *static_cast<TMax*>(m_object);
    value.SetMax();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::TMin& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::GetMin(void) const
{
    CheckSelected(e_Min);
    return *static_cast<const TMin*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::TMin& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::SetMin(void)
{
    Select(e_Min, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::C_Nary_minmax_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_minmax_mmlclass::~C_Nary_minmax_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "plus",
    "times",
    "gcd",
    "lcm"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TPlus& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::GetPlus(void) const
{
    CheckSelected(e_Plus);
    return *static_cast<const TPlus*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TPlus& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::SetPlus(void)
{
    Select(e_Plus, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TPlus& value = *static_cast<TPlus*>(m_object);
    value.SetPlus();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TTimes& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::GetTimes(void) const
{
    CheckSelected(e_Times);
    return *static_cast<const TTimes*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TTimes& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::SetTimes(void)
{
    Select(e_Times, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TTimes& value = *static_cast<TTimes*>(m_object);
    value.SetTimes();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TGcd& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::GetGcd(void) const
{
    CheckSelected(e_Gcd);
    return *static_cast<const TGcd*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TGcd& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::SetGcd(void)
{
    Select(e_Gcd, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TGcd& value = *static_cast<TGcd*>(m_object);
    value.SetGcd();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TLcm& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::GetLcm(void) const
{
    CheckSelected(e_Lcm);
    return *static_cast<const TLcm*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::TLcm& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::SetLcm(void)
{
    Select(e_Lcm, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::C_Nary_arith_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_arith_mmlclass::~C_Nary_arith_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::sm_SelectionNames[] = {
    "not set",
    "and",
    "or",
    "xor"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TAnd& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::GetAnd(void) const
{
    CheckSelected(e_And);
    return *static_cast<const TAnd*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TAnd& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::SetAnd(void)
{
    Select(e_And, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TAnd& value = *static_cast<TAnd*>(m_object);
    value.SetAnd();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TOr& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::GetOr(void) const
{
    CheckSelected(e_Or);
    return *static_cast<const TOr*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TOr& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::SetOr(void)
{
    Select(e_Or, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TOr& value = *static_cast<TOr*>(m_object);
    value.SetOr();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TXor& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::GetXor(void) const
{
    CheckSelected(e_Xor);
    return *static_cast<const TXor*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::TXor& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::SetXor(void)
{
    Select(e_Xor, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::C_Nary_logical_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_logical_mmlclass::~C_Nary_logical_mmlclass(void)
{
    Reset();
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::IsSetNot(void) const
{
    return m_Not ? m_Not->IsSetNot() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::ResetNot(void)
{
    if ( !m_Not ) {
        m_Not.Reset(new TNot());
        return;
    }
    (*m_Not).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::SetNot(CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::TNot& value)
{
    m_Not.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::TNot& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::SetNot(void)
{
    if ( !m_Not ) {
        ResetNot();
    }
    m_Not->SetNot();
    return (*m_Not);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::Reset(void)
{
    ResetNot();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::C_Unary_logical_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetNot();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_logical_mmlclass::~C_Unary_logical_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::sm_SelectionNames[] = {
    "not set",
    "implies",
    "equivalent"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::TImplies& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::GetImplies(void) const
{
    CheckSelected(e_Implies);
    return *static_cast<const TImplies*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::TImplies& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::SetImplies(void)
{
    Select(e_Implies, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::TImplies& value = *static_cast<TImplies*>(m_object);
    value.SetImplies();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::TEquivalent& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::GetEquivalent(void) const
{
    CheckSelected(e_Equivalent);
    return *static_cast<const TEquivalent*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::TEquivalent& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::SetEquivalent(void)
{
    Select(e_Equivalent, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::C_Binary_logical_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_logical_mmlclass::~C_Binary_logical_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::sm_SelectionNames[] = {
    "not set",
    "forall",
    "exists"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TForall& CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::GetForall(void) const
{
    CheckSelected(e_Forall);
    return *static_cast<const TForall*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TForall& CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::SetForall(void)
{
    Select(e_Forall, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TForall& value = *static_cast<TForall*>(m_object);
    value.SetForall();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TExists& CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::GetExists(void) const
{
    CheckSelected(e_Exists);
    return *static_cast<const TExists*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TExists& CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::SetExists(void)
{
    Select(e_Exists, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::TExists& value = *static_cast<TExists*>(m_object);
    value.SetExists();
    return value;
}
 
// helper methods
 
// type info
BEGIN_NAMED_CHOICE_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::C_Quantifier_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Quantifier_mmlclass::~C_Quantifier_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "eq",
    "gt",
    "lt",
    "geq",
    "leq"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TEq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::GetEq(void) const
{
    CheckSelected(e_Eq);
    return *static_cast<const TEq*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TEq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::SetEq(void)
{
    Select(e_Eq, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TEq& value = *static_cast<TEq*>(m_object);
    value.SetEq();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGt& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::GetGt(void) const
{
    CheckSelected(e_Gt);
    return *static_cast<const TGt*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGt& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::SetGt(void)
{
    Select(e_Gt, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGt& value = *static_cast<TGt*>(m_object);
    value.SetGt();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TLt& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::GetLt(void) const
{
    CheckSelected(e_Lt);
    return *static_cast<const TLt*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TLt& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::SetLt(void)
{
    Select(e_Lt, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TLt& value = *static_cast<TLt*>(m_object);
    value.SetLt();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGeq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::GetGeq(void) const
{
    CheckSelected(e_Geq);
    return *static_cast<const TGeq*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGeq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::SetGeq(void)
{
    Select(e_Geq, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TGeq& value = *static_cast<TGeq*>(m_object);
    value.SetGeq();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TLeq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::GetLeq(void) const
{
    CheckSelected(e_Leq);
    return *static_cast<const TLeq*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::TLeq& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::SetLeq(void)
{
    Select(e_Leq, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::C_Nary_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_reln_mmlclass::~C_Nary_reln_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "neq",
    "approx",
    "factorof",
    "tendsto"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TNeq& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::GetNeq(void) const
{
    CheckSelected(e_Neq);
    return *static_cast<const TNeq*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TNeq& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::SetNeq(void)
{
    Select(e_Neq, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TNeq& value = *static_cast<TNeq*>(m_object);
    value.SetNeq();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TApprox& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::GetApprox(void) const
{
    CheckSelected(e_Approx);
    return *static_cast<const TApprox*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TApprox& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::SetApprox(void)
{
    Select(e_Approx, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TApprox& value = *static_cast<TApprox*>(m_object);
    value.SetApprox();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TFactorof& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::GetFactorof(void) const
{
    CheckSelected(e_Factorof);
    return *static_cast<const TFactorof*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TFactorof& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::SetFactorof(void)
{
    Select(e_Factorof, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TFactorof& value = *static_cast<TFactorof*>(m_object);
    value.SetFactorof();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TTendsto& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::GetTendsto(void) const
{
    CheckSelected(e_Tendsto);
    return *static_cast<const TTendsto*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::TTendsto& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::SetTendsto(void)
{
    Select(e_Tendsto, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::C_Binary_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_reln_mmlclass::~C_Binary_reln_mmlclass(void)
{
    Reset();
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::IsSetInt(void) const
{
    return m_Int ? m_Int->IsSetInt() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::ResetInt(void)
{
    if ( !m_Int ) {
        m_Int.Reset(new TInt());
        return;
    }
    (*m_Int).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::SetInt(CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::TInt& value)
{
    m_Int.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::TInt& CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::SetInt(void)
{
    if ( !m_Int ) {
        ResetInt();
    }
    m_Int->SetInt();
    return (*m_Int);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::Reset(void)
{
    ResetInt();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::C_Int_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetInt();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Int_mmlclass::~C_Int_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::IsSetDiff(void) const
{
    return m_Diff ? m_Diff->IsSetDiff() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::ResetDiff(void)
{
    if ( !m_Diff ) {
        m_Diff.Reset(new TDiff());
        return;
    }
    (*m_Diff).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::SetDiff(CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::TDiff& value)
{
    m_Diff.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::TDiff& CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::SetDiff(void)
{
    if ( !m_Diff ) {
        ResetDiff();
    }
    m_Diff->SetDiff();
    return (*m_Diff);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::Reset(void)
{
    ResetDiff();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::C_Differential_Operator_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetDiff();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Differential_Operator_mmlclass::~C_Differential_Operator_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::IsSetPartialdiff(void) const
{
    return m_Partialdiff ? m_Partialdiff->IsSetPartialdiff() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::ResetPartialdiff(void)
{
    if ( !m_Partialdiff ) {
        m_Partialdiff.Reset(new TPartialdiff());
        return;
    }
    (*m_Partialdiff).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::SetPartialdiff(CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::TPartialdiff& value)
{
    m_Partialdiff.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::TPartialdiff& CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::SetPartialdiff(void)
{
    if ( !m_Partialdiff ) {
        ResetPartialdiff();
    }
    m_Partialdiff->SetPartialdiff();
    return (*m_Partialdiff);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::Reset(void)
{
    ResetPartialdiff();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::C_Partialdiff_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetPartialdiff();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Partialdiff_mmlclass::~C_Partialdiff_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::sm_SelectionNames[] = {
    "not set",
    "divergence",
    "grad",
    "curl",
    "laplacian"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::GetDivergence(void) const
{
    CheckSelected(e_Divergence);
    return *static_cast<const TDivergence*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::SetDivergence(void)
{
    Select(e_Divergence, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TDivergence& value = *static_cast<TDivergence*>(m_object);
    value.SetDivergence();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::GetGrad(void) const
{
    CheckSelected(e_Grad);
    return *static_cast<const TGrad*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::SetGrad(void)
{
    Select(e_Grad, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TGrad& value = *static_cast<TGrad*>(m_object);
    value.SetGrad();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::GetCurl(void) const
{
    CheckSelected(e_Curl);
    return *static_cast<const TCurl*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::SetCurl(void)
{
    Select(e_Curl, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TCurl& value = *static_cast<TCurl*>(m_object);
    value.SetCurl();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TLaplacian& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::GetLaplacian(void) const
{
    CheckSelected(e_Laplacian);
    return *static_cast<const TLaplacian*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::TLaplacian& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::SetLaplacian(void)
{
    Select(e_Laplacian, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::C_Unary_veccalc_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_veccalc_mmlclass::~C_Unary_veccalc_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::sm_SelectionNames[] = {
    "not set",
    "set",
    "list"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::TSet& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::GetSet(void) const
{
    CheckSelected(e_Set);
    return *static_cast<const TSet*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::TSet& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetSet(void)
{
    Select(e_Set, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TSet*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetSet(CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::TList& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::GetList(void) const
{
    CheckSelected(e_List);
    return *static_cast<const TList*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::TList& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetList(void)
{
    Select(e_List, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TList*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::SetList(CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::C_Nary_setlist_constructor_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_setlist_constructor_mmlclass::~C_Nary_setlist_constructor_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "union",
    "intersect",
    "cartesianproduct"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TUnion& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::GetUnion(void) const
{
    CheckSelected(e_Union);
    return *static_cast<const TUnion*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TUnion& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::SetUnion(void)
{
    Select(e_Union, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TUnion& value = *static_cast<TUnion*>(m_object);
    value.SetUnion();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TIntersect& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::GetIntersect(void) const
{
    CheckSelected(e_Intersect);
    return *static_cast<const TIntersect*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TIntersect& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::SetIntersect(void)
{
    Select(e_Intersect, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TIntersect& value = *static_cast<TIntersect*>(m_object);
    value.SetIntersect();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TCartesianproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::GetCartesianproduct(void) const
{
    CheckSelected(e_Cartesianproduct);
    return *static_cast<const TCartesianproduct*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::TCartesianproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::SetCartesianproduct(void)
{
    Select(e_Cartesianproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::C_Nary_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_mmlclass::~C_Nary_set_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "in",
    "notin",
    "notsubset",
    "notprsubset",
    "setdiff"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TIn& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::GetIn(void) const
{
    CheckSelected(e_In);
    return *static_cast<const TIn*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TIn& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::SetIn(void)
{
    Select(e_In, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TIn& value = *static_cast<TIn*>(m_object);
    value.SetIn();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotin& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::GetNotin(void) const
{
    CheckSelected(e_Notin);
    return *static_cast<const TNotin*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotin& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::SetNotin(void)
{
    Select(e_Notin, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotin& value = *static_cast<TNotin*>(m_object);
    value.SetNotin();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::GetNotsubset(void) const
{
    CheckSelected(e_Notsubset);
    return *static_cast<const TNotsubset*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::SetNotsubset(void)
{
    Select(e_Notsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotsubset& value = *static_cast<TNotsubset*>(m_object);
    value.SetNotsubset();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::GetNotprsubset(void) const
{
    CheckSelected(e_Notprsubset);
    return *static_cast<const TNotprsubset*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::SetNotprsubset(void)
{
    Select(e_Notprsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TNotprsubset& value = *static_cast<TNotprsubset*>(m_object);
    value.SetNotprsubset();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TSetdiff& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::GetSetdiff(void) const
{
    CheckSelected(e_Setdiff);
    return *static_cast<const TSetdiff*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::TSetdiff& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::SetSetdiff(void)
{
    Select(e_Setdiff, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::C_Binary_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_set_mmlclass::~C_Binary_set_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::sm_SelectionNames[] = {
    "not set",
    "subset",
    "prsubset"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::GetSubset(void) const
{
    CheckSelected(e_Subset);
    return *static_cast<const TSubset*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::SetSubset(void)
{
    Select(e_Subset, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::TSubset& value = *static_cast<TSubset*>(m_object);
    value.SetSubset();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::TPrsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::GetPrsubset(void) const
{
    CheckSelected(e_Prsubset);
    return *static_cast<const TPrsubset*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::TPrsubset& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::SetPrsubset(void)
{
    Select(e_Prsubset, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::C_Nary_set_reln_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_set_reln_mmlclass::~C_Nary_set_reln_mmlclass(void)
{
    Reset();
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::IsSetCard(void) const
{
    return m_Card ? m_Card->IsSetCard() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::ResetCard(void)
{
    if ( !m_Card ) {
        m_Card.Reset(new TCard());
        return;
    }
    (*m_Card).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::SetCard(CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::TCard& value)
{
    m_Card.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::TCard& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::SetCard(void)
{
    if ( !m_Card ) {
        ResetCard();
    }
    m_Card->SetCard();
    return (*m_Card);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::Reset(void)
{
    ResetCard();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::C_Unary_set_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetCard();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_set_mmlclass::~C_Unary_set_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::IsSetSum(void) const
{
    return m_Sum ? m_Sum->IsSetSum() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::ResetSum(void)
{
    if ( !m_Sum ) {
        m_Sum.Reset(new TSum());
        return;
    }
    (*m_Sum).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::SetSum(CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::TSum& value)
{
    m_Sum.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::TSum& CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::SetSum(void)
{
    if ( !m_Sum ) {
        ResetSum();
    }
    m_Sum->SetSum();
    return (*m_Sum);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::Reset(void)
{
    ResetSum();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::C_Sum_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetSum();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Sum_mmlclass::~C_Sum_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::IsSetProduct(void) const
{
    return m_Product ? m_Product->IsSetProduct() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::ResetProduct(void)
{
    if ( !m_Product ) {
        m_Product.Reset(new TProduct());
        return;
    }
    (*m_Product).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::SetProduct(CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::TProduct& value)
{
    m_Product.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::TProduct& CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::SetProduct(void)
{
    if ( !m_Product ) {
        ResetProduct();
    }
    m_Product->SetProduct();
    return (*m_Product);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::Reset(void)
{
    ResetProduct();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::C_Product_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetProduct();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Product_mmlclass::~C_Product_mmlclass(void)
{
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::IsSetLimit(void) const
{
    return m_Limit ? m_Limit->IsSetLimit() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::ResetLimit(void)
{
    if ( !m_Limit ) {
        m_Limit.Reset(new TLimit());
        return;
    }
    (*m_Limit).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::SetLimit(CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::TLimit& value)
{
    m_Limit.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::TLimit& CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::SetLimit(void)
{
    if ( !m_Limit ) {
        ResetLimit();
    }
    m_Limit->SetLimit();
    return (*m_Limit);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::Reset(void)
{
    ResetLimit();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::C_Limit_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetLimit();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Limit_mmlclass::~C_Limit_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSin& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetSin(void) const
{
    CheckSelected(e_Sin);
    return *static_cast<const TSin*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSin& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetSin(void)
{
    Select(e_Sin, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSin& value = *static_cast<TSin*>(m_object);
    value.SetSin();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCos& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCos(void) const
{
    CheckSelected(e_Cos);
    return *static_cast<const TCos*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCos& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCos(void)
{
    Select(e_Cos, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCos& value = *static_cast<TCos*>(m_object);
    value.SetCos();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTan& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetTan(void) const
{
    CheckSelected(e_Tan);
    return *static_cast<const TTan*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTan& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetTan(void)
{
    Select(e_Tan, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTan& value = *static_cast<TTan*>(m_object);
    value.SetTan();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSec& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetSec(void) const
{
    CheckSelected(e_Sec);
    return *static_cast<const TSec*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSec& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetSec(void)
{
    Select(e_Sec, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSec& value = *static_cast<TSec*>(m_object);
    value.SetSec();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsc& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCsc(void) const
{
    CheckSelected(e_Csc);
    return *static_cast<const TCsc*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsc& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCsc(void)
{
    Select(e_Csc, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsc& value = *static_cast<TCsc*>(m_object);
    value.SetCsc();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCot& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCot(void) const
{
    CheckSelected(e_Cot);
    return *static_cast<const TCot*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCot& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCot(void)
{
    Select(e_Cot, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCot& value = *static_cast<TCot*>(m_object);
    value.SetCot();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSinh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetSinh(void) const
{
    CheckSelected(e_Sinh);
    return *static_cast<const TSinh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSinh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetSinh(void)
{
    Select(e_Sinh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSinh& value = *static_cast<TSinh*>(m_object);
    value.SetSinh();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCosh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCosh(void) const
{
    CheckSelected(e_Cosh);
    return *static_cast<const TCosh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCosh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCosh(void)
{
    Select(e_Cosh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCosh& value = *static_cast<TCosh*>(m_object);
    value.SetCosh();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTanh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetTanh(void) const
{
    CheckSelected(e_Tanh);
    return *static_cast<const TTanh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTanh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetTanh(void)
{
    Select(e_Tanh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TTanh& value = *static_cast<TTanh*>(m_object);
    value.SetTanh();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSech& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetSech(void) const
{
    CheckSelected(e_Sech);
    return *static_cast<const TSech*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSech& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetSech(void)
{
    Select(e_Sech, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TSech& value = *static_cast<TSech*>(m_object);
    value.SetSech();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsch& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCsch(void) const
{
    CheckSelected(e_Csch);
    return *static_cast<const TCsch*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsch& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCsch(void)
{
    Select(e_Csch, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCsch& value = *static_cast<TCsch*>(m_object);
    value.SetCsch();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCoth& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetCoth(void) const
{
    CheckSelected(e_Coth);
    return *static_cast<const TCoth*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCoth& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetCoth(void)
{
    Select(e_Coth, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TCoth& value = *static_cast<TCoth*>(m_object);
    value.SetCoth();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArcsin(void) const
{
    CheckSelected(e_Arcsin);
    return *static_cast<const TArcsin*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArcsin(void)
{
    Select(e_Arcsin, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsin& value = *static_cast<TArcsin*>(m_object);
    value.SetArcsin();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccos& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccos(void) const
{
    CheckSelected(e_Arccos);
    return *static_cast<const TArccos*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccos& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccos(void)
{
    Select(e_Arccos, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccos& value = *static_cast<TArccos*>(m_object);
    value.SetArccos();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArctan& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArctan(void) const
{
    CheckSelected(e_Arctan);
    return *static_cast<const TArctan*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArctan& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArctan(void)
{
    Select(e_Arctan, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArctan& value = *static_cast<TArctan*>(m_object);
    value.SetArctan();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccosh(void) const
{
    CheckSelected(e_Arccosh);
    return *static_cast<const TArccosh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccosh(void)
{
    Select(e_Arccosh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccosh& value = *static_cast<TArccosh*>(m_object);
    value.SetArccosh();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccot& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccot(void) const
{
    CheckSelected(e_Arccot);
    return *static_cast<const TArccot*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccot& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccot(void)
{
    Select(e_Arccot, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccot& value = *static_cast<TArccot*>(m_object);
    value.SetArccot();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccoth(void) const
{
    CheckSelected(e_Arccoth);
    return *static_cast<const TArccoth*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccoth(void)
{
    Select(e_Arccoth, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccoth& value = *static_cast<TArccoth*>(m_object);
    value.SetArccoth();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccsc(void) const
{
    CheckSelected(e_Arccsc);
    return *static_cast<const TArccsc*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccsc(void)
{
    Select(e_Arccsc, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsc& value = *static_cast<TArccsc*>(m_object);
    value.SetArccsc();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArccsch(void) const
{
    CheckSelected(e_Arccsch);
    return *static_cast<const TArccsch*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArccsch(void)
{
    Select(e_Arccsch, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArccsch& value = *static_cast<TArccsch*>(m_object);
    value.SetArccsch();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArcsec(void) const
{
    CheckSelected(e_Arcsec);
    return *static_cast<const TArcsec*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArcsec(void)
{
    Select(e_Arcsec, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsec& value = *static_cast<TArcsec*>(m_object);
    value.SetArcsec();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArcsech(void) const
{
    CheckSelected(e_Arcsech);
    return *static_cast<const TArcsech*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArcsech(void)
{
    Select(e_Arcsech, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsech& value = *static_cast<TArcsech*>(m_object);
    value.SetArcsech();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArcsinh(void) const
{
    CheckSelected(e_Arcsinh);
    return *static_cast<const TArcsinh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArcsinh(void)
{
    Select(e_Arcsinh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArcsinh& value = *static_cast<TArcsinh*>(m_object);
    value.SetArcsinh();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArctanh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::GetArctanh(void) const
{
    CheckSelected(e_Arctanh);
    return *static_cast<const TArctanh*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::TArctanh& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::SetArctanh(void)
{
    Select(e_Arctanh, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::C_Unary_elementary_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_elementary_mmlclass::~C_Unary_elementary_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::sm_SelectionNames[] = {
    "not set",
    "mean",
    "sdev",
    "variance",
    "median",
    "mode"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMean& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::GetMean(void) const
{
    CheckSelected(e_Mean);
    return *static_cast<const TMean*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMean& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::SetMean(void)
{
    Select(e_Mean, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMean& value = *static_cast<TMean*>(m_object);
    value.SetMean();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TSdev& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::GetSdev(void) const
{
    CheckSelected(e_Sdev);
    return *static_cast<const TSdev*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TSdev& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::SetSdev(void)
{
    Select(e_Sdev, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TSdev& value = *static_cast<TSdev*>(m_object);
    value.SetSdev();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TVariance& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::GetVariance(void) const
{
    CheckSelected(e_Variance);
    return *static_cast<const TVariance*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TVariance& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::SetVariance(void)
{
    Select(e_Variance, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TVariance& value = *static_cast<TVariance*>(m_object);
    value.SetVariance();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMedian& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::GetMedian(void) const
{
    CheckSelected(e_Median);
    return *static_cast<const TMedian*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMedian& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::SetMedian(void)
{
    Select(e_Median, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMedian& value = *static_cast<TMedian*>(m_object);
    value.SetMedian();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMode& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::GetMode(void) const
{
    CheckSelected(e_Mode);
    return *static_cast<const TMode*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::TMode& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::SetMode(void)
{
    Select(e_Mode, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::C_Nary_stats_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_stats_mmlclass::~C_Nary_stats_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::sm_SelectionNames[] = {
    "not set",
    "vector",
    "matrix",
    "matrixrow"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TVector& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::GetVector(void) const
{
    CheckSelected(e_Vector);
    return *static_cast<const TVector*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TVector& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetVector(void)
{
    Select(e_Vector, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TVector*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetVector(CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TMatrix& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::GetMatrix(void) const
{
    CheckSelected(e_Matrix);
    return *static_cast<const TMatrix*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TMatrix& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetMatrix(void)
{
    Select(e_Matrix, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMatrix*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetMatrix(CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TMatrixrow& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::GetMatrixrow(void) const
{
    CheckSelected(e_Matrixrow);
    return *static_cast<const TMatrixrow*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::TMatrixrow& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetMatrixrow(void)
{
    Select(e_Matrixrow, NCBI_NS_NCBI::eDoNotResetVariant);
    return *static_cast<TMatrixrow*>(m_object);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::SetMatrixrow(CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::C_Nary_constructor_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_constructor_mmlclass::~C_Nary_constructor_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::sm_SelectionNames[] = {
    "not set",
    "determinant",
    "transpose"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::GetDeterminant(void) const
{
    CheckSelected(e_Determinant);
    return *static_cast<const TDeterminant*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::SetDeterminant(void)
{
    Select(e_Determinant, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::TDeterminant& value = *static_cast<TDeterminant*>(m_object);
    value.SetDeterminant();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::TTranspose& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::GetTranspose(void) const
{
    CheckSelected(e_Transpose);
    return *static_cast<const TTranspose*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::TTranspose& CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::SetTranspose(void)
{
    Select(e_Transpose, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::C_Unary_linalg_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Unary_linalg_mmlclass::~C_Unary_linalg_mmlclass(void)
{
    Reset();
}
 
 
bool CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::IsSetSelector(void) const
{
    return m_Selector ? m_Selector->IsSetSelector() : false;
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::ResetSelector(void)
{
    if ( !m_Selector ) {
        m_Selector.Reset(new TSelector());
        return;
    }
    (*m_Selector).Reset();
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::SetSelector(CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::TSelector& value)
{
    m_Selector.Reset(&value);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::TSelector& CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::SetSelector(void)
{
    if ( !m_Selector ) {
        ResetSelector();
    }
    m_Selector->SetSelector();
    return (*m_Selector);
}
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::Reset(void)
{
    ResetSelector();
}
 
BEGIN_NAMED_CLASS_INFO("", CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::C_Nary_linalg_mmlclass(void)
{
    memset(m_set_State,0,sizeof(m_set_State));
    if ( !IsAllocatedInPool() ) {
        ResetSelector();
    }
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Nary_linalg_mmlclass::~C_Nary_linalg_mmlclass(void)
{
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::sm_SelectionNames[] = {
    "not set",
    "vectorproduct",
    "scalarproduct",
    "outerproduct"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::GetVectorproduct(void) const
{
    CheckSelected(e_Vectorproduct);
    return *static_cast<const TVectorproduct*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::SetVectorproduct(void)
{
    Select(e_Vectorproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TVectorproduct& value = *static_cast<TVectorproduct*>(m_object);
    value.SetVectorproduct();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::GetScalarproduct(void) const
{
    CheckSelected(e_Scalarproduct);
    return *static_cast<const TScalarproduct*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::SetScalarproduct(void)
{
    Select(e_Scalarproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TScalarproduct& value = *static_cast<TScalarproduct*>(m_object);
    value.SetScalarproduct();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TOuterproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::GetOuterproduct(void) const
{
    CheckSelected(e_Outerproduct);
    return *static_cast<const TOuterproduct*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::TOuterproduct& CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::SetOuterproduct(void)
{
    Select(e_Outerproduct, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::C_Binary_linalg_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Binary_linalg_mmlclass::~C_Binary_linalg_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::sm_SelectionNames[] = {
    "not set",
    "integers",
    "reals",
    "rationals",
    "naturalnumbers",
    "complexes",
    "primes",
    "emptyset"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TIntegers& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetIntegers(void) const
{
    CheckSelected(e_Integers);
    return *static_cast<const TIntegers*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TIntegers& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetIntegers(void)
{
    Select(e_Integers, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TIntegers& value = *static_cast<TIntegers*>(m_object);
    value.SetIntegers();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TReals& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetReals(void) const
{
    CheckSelected(e_Reals);
    return *static_cast<const TReals*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TReals& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetReals(void)
{
    Select(e_Reals, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TReals& value = *static_cast<TReals*>(m_object);
    value.SetReals();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TRationals& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetRationals(void) const
{
    CheckSelected(e_Rationals);
    return *static_cast<const TRationals*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TRationals& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetRationals(void)
{
    Select(e_Rationals, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TRationals& value = *static_cast<TRationals*>(m_object);
    value.SetRationals();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetNaturalnumbers(void) const
{
    CheckSelected(e_Naturalnumbers);
    return *static_cast<const TNaturalnumbers*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetNaturalnumbers(void)
{
    Select(e_Naturalnumbers, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TNaturalnumbers& value = *static_cast<TNaturalnumbers*>(m_object);
    value.SetNaturalnumbers();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TComplexes& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetComplexes(void) const
{
    CheckSelected(e_Complexes);
    return *static_cast<const TComplexes*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TComplexes& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetComplexes(void)
{
    Select(e_Complexes, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TComplexes& value = *static_cast<TComplexes*>(m_object);
    value.SetComplexes();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TPrimes& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetPrimes(void) const
{
    CheckSelected(e_Primes);
    return *static_cast<const TPrimes*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TPrimes& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetPrimes(void)
{
    Select(e_Primes, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TPrimes& value = *static_cast<TPrimes*>(m_object);
    value.SetPrimes();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TEmptyset& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::GetEmptyset(void) const
{
    CheckSelected(e_Emptyset);
    return *static_cast<const TEmptyset*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::TEmptyset& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::SetEmptyset(void)
{
    Select(e_Emptyset, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::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("", CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass)
{
    SET_INTERNAL_NAME("ImpliedMrow.E.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
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::C_Constant_set_mmlclass(void)
    : m_choice(e_not_set)
{
}
 
// destructor
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_set_mmlclass::~C_Constant_set_mmlclass(void)
{
    Reset();
}
 
 
void CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::Reset(void)
{
    if ( m_choice != e_not_set )
        ResetSelection();
}
 
void CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::sm_SelectionNames[] = {
    "not set",
    "exponentiale",
    "imaginaryi",
    "notanumber",
    "true",
    "false",
    "pi",
    "eulergamma",
    "infinity"
};
 
NCBI_NS_STD::string CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::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 CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetExponentiale(void) const
{
    CheckSelected(e_Exponentiale);
    return *static_cast<const TExponentiale*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetExponentiale(void)
{
    Select(e_Exponentiale, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TExponentiale& value = *static_cast<TExponentiale*>(m_object);
    value.SetExponentiale();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetImaginaryi(void) const
{
    CheckSelected(e_Imaginaryi);
    return *static_cast<const TImaginaryi*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetImaginaryi(void)
{
    Select(e_Imaginaryi, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TImaginaryi& value = *static_cast<TImaginaryi*>(m_object);
    value.SetImaginaryi();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetNotanumber(void) const
{
    CheckSelected(e_Notanumber);
    return *static_cast<const TNotanumber*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetNotanumber(void)
{
    Select(e_Notanumber, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TNotanumber& value = *static_cast<TNotanumber*>(m_object);
    value.SetNotanumber();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TTrue& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetTrue(void) const
{
    CheckSelected(e_True);
    return *static_cast<const TTrue*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TTrue& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetTrue(void)
{
    Select(e_True, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TTrue& value = *static_cast<TTrue*>(m_object);
    value.SetTrue();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TFalse& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetFalse(void) const
{
    CheckSelected(e_False);
    return *static_cast<const TFalse*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TFalse& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetFalse(void)
{
    Select(e_False, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TFalse& value = *static_cast<TFalse*>(m_object);
    value.SetFalse();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TPi& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetPi(void) const
{
    CheckSelected(e_Pi);
    return *static_cast<const TPi*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TPi& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetPi(void)
{
    Select(e_Pi, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TPi& value = *static_cast<TPi*>(m_object);
    value.SetPi();
    return value;
}
 
const CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::GetEulergamma(void) const
{
    CheckSelected(e_Eulergamma);
    return *static_cast<const TEulergamma*>(m_object);
}
 
CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::SetEulergamma(void)
{
    Select(e_Eulergamma, NCBI_NS_NCBI::eDoNotResetVariant);
    CImpliedMrow_Base::C_E::C_ContExp::C_Constant_arith_mmlclass::TEulergamma& value = *static_cast<TEulergamma*>(m_object);
    value.SetEulergamma();
    return