Bind_content_.hpp

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 Bind_content_.hpp
/// Data storage class.
///
/// This file was generated by application DATATOOL
/// using the following specifications:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objtools/eutils/efetch/pubmed_mathml3.xsd">pubmed_mathml3.xsd</a>
/// and additional tune-up parameters:
/// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objtools/eutils/efetch/pubmed_mathml3.def">pubmed_mathml3.def</a>
///
/// ATTENTION:
///   Don't edit or commit this file into CVS as this file will
///   be overridden (by DATATOOL) without warning!
 
#ifndef OBJTOOLS_EUTILS_EFETCH_BIND_CONTENT_BASE_HPP
#define OBJTOOLS_EUTILS_EFETCH_BIND_CONTENT_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
 
// generated includes
#include <list>
 
BEGIN_NCBI_SCOPE
 
#ifndef BEGIN_objects_SCOPE
#  define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
#  define END_objects_SCOPE END_SCOPE(objects)
#endif
BEGIN_objects_SCOPE // namespace ncbi::objects::
 
 
// forward declarations
class CAbs;
class CAnd;
class CApply;
class CApprox;
class CArccos;
class CArccosh;
class CArccot;
class CArccoth;
class CArccsc;
class CArccsch;
class CArcsec;
class CArcsech;
class CArcsin;
class CArcsinh;
class CArctan;
class CArctanh;
class CArg;
class CBind;
class CBvar;
class CCard;
class CCartesianproduct;
class CCbytes;
class CCeiling;
class CCerror;
class CCi;
class CCn;
class CCodomain;
class CComplexes;
class CCompose;
class CCondition;
class CConjugate;
class CCos;
class CCosh;
class CCot;
class CCoth;
class CCs;
class CCsc;
class CCsch;
class CCsymbol;
class CCurl;
class CDeclare;
class CDegree;
class CDeterminant;
class CDiff;
class CDivergence;
class CDivide;
class CDomain;
class CDomainofapplication;
class CEmptyset;
class CEq;
class CEquivalent;
class CEulergamma;
class CExists;
class CExp;
class CExponentiale;
class CFactorial;
class CFactorof;
class CFalse;
class CFloor;
class CFn;
class CForall;
class CGcd;
class CGeq;
class CGrad;
class CGt;
class CIdent;
class CImage;
class CImaginary;
class CImaginaryi;
class CImplies;
class CIn;
class CInfinity;
class CInt;
class CIntegers;
class CIntersect;
class CInterval;
class CInverse;
class CLambda;
class CLaplacian;
class CLcm;
class CLeq;
class CLimit;
class CList;
class CLn;
class CLog;
class CLogbase;
class CLowlimit;
class CLt;
class CMatrix;
class CMatrixrow;
class CMax;
class CMean;
class CMedian;
class CMin;
class CMinus;
class CMode;
class CMoment;
class CMomentabout;
class CNaturalnumbers;
class CNeq;
class CNot;
class CNotanumber;
class CNotin;
class CNotprsubset;
class CNotsubset;
class COr;
class COuterproduct;
class CPartialdiff;
class CPi;
class CPiecewise;
class CPlus;
class CPower;
class CPrimes;
class CProduct;
class CPrsubset;
class CQuotient;
class CRationals;
class CReal;
class CReals;
class CReln;
class CRem;
class CRoot;
class CScalarproduct;
class CSdev;
class CSec;
class CSech;
class CSelector;
class CSemantics;
class CSet;
class CSetdiff;
class CShare;
class CSin;
class CSinh;
class CSubset;
class CSum;
class CTan;
class CTanh;
class CTendsto;
class CTimes;
class CTranspose;
class CTrue;
class CUnion;
class CUplimit;
class CVariance;
class CVector;
class CVectorproduct;
class CXor;
 
 
// generated classes
 
 
/** @addtogroup dataspec_pubmed_mathml3
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///
/// CBind_content_Base --
///
 
class CBind_content_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CBind_content_Base(void);
    // destructor
    virtual ~CBind_content_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_ContExp --
    ///
    
    class C_ContExp : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_ContExp(void);
        // destructor
        ~C_ContExp(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_E_ContExp --
        ///
        
        class C_E_ContExp : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_E_ContExp(void);
            // destructor
            ~C_E_ContExp(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_DeprecatedContExp --
            ///
            
            class C_DeprecatedContExp : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_DeprecatedContExp(void);
                // destructor
                ~C_DeprecatedContExp(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Reln,
                    e_Fn,
                    e_Declare
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_Declare+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CReln TReln;
                typedef CFn TFn;
                typedef CDeclare TDeclare;
            
                // getters
                // setters
            
            
                /// Check if variant Reln is selected.
                ///
                /// Reln type is defined as 'typedef CReln TReln'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsReln(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TReln& GetReln(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TReln& SetReln(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetReln(TReln& value);
            
            
                /// Check if variant Fn is selected.
                ///
                /// Fn type is defined as 'typedef CFn TFn'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsFn(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TFn& GetFn(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TFn& SetFn(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetFn(TFn& value);
            
            
                /// Check if variant Declare is selected.
                ///
                /// Declare type is defined as 'typedef CDeclare TDeclare'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDeclare(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDeclare& GetDeclare(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDeclare& SetDeclare(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetDeclare(TDeclare& value);
            
            
            private:
                // copy constructor and assignment operator
                C_DeprecatedContExp(const C_DeprecatedContExp& );
                C_DeprecatedContExp& operator=(const C_DeprecatedContExp& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Interval_mmlclass --
            ///
            
            class C_Interval_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Interval_mmlclass(void);
                // destructor
                ~C_Interval_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CInterval TInterval;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_interval
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Interval data member.
                ///
                /// Data member Interval is mandatory;
                /// its type is defined as 'typedef CInterval TInterval'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetInterval(void) const;
            
                /// Check if it is safe to call GetInterval method.
                ///
                /// @return
                ///   - true, if the data member is getatable.
                ///   - false, otherwise.
                bool CanGetInterval(void) const;
            
                /// Reset Interval data member.
                void ResetInterval(void);
            
                /// Get the Interval member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TInterval& GetInterval(void) const;
            
                /// Assign a value to Interval data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetInterval(TInterval& value);
            
                /// Assign a value to Interval data member.
                ///
                /// @return
                ///   Reference to the data value.
                TInterval& SetInterval(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Interval_mmlclass(const C_Interval_mmlclass&);
                C_Interval_mmlclass& operator=(const C_Interval_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TInterval > m_Interval;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_functional_mmlclass --
            ///
            
            class C_Unary_functional_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_functional_mmlclass(void);
                // destructor
                ~C_Unary_functional_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Inverse,
                    e_Ident,
                    e_Domain,
                    e_Codomain,
                    e_Image,
                    e_Ln,
                    e_Log,
                    e_Moment
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 9 ///< == e_Moment+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CInverse TInverse;
                typedef CIdent TIdent;
                typedef CDomain TDomain;
                typedef CCodomain TCodomain;
                typedef CImage TImage;
                typedef CLn TLn;
                typedef CLog TLog;
                typedef CMoment TMoment;
            
                // getters
                // setters
            
            
                /// Check if variant Inverse is selected.
                ///
                /// Inverse type is defined as 'typedef CInverse TInverse'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsInverse(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TInverse& GetInverse(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TInverse& SetInverse(void);
            
            
                /// Check if variant Ident is selected.
                ///
                /// Ident type is defined as 'typedef CIdent TIdent'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsIdent(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TIdent& GetIdent(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TIdent& SetIdent(void);
            
            
                /// Check if variant Domain is selected.
                ///
                /// Domain type is defined as 'typedef CDomain TDomain'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDomain(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDomain& GetDomain(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDomain& SetDomain(void);
            
            
                /// Check if variant Codomain is selected.
                ///
                /// Codomain type is defined as 'typedef CCodomain TCodomain'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCodomain(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCodomain& GetCodomain(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCodomain& SetCodomain(void);
            
            
                /// Check if variant Image is selected.
                ///
                /// Image type is defined as 'typedef CImage TImage'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsImage(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TImage& GetImage(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TImage& SetImage(void);
            
            
                /// Check if variant Ln is selected.
                ///
                /// Ln type is defined as 'typedef CLn TLn'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLn(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLn& GetLn(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLn& SetLn(void);
            
            
                /// Check if variant Log is selected.
                ///
                /// Log type is defined as 'typedef CLog TLog'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLog(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLog& GetLog(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLog& SetLog(void);
            
            
                /// Check if variant Moment is selected.
                ///
                /// Moment type is defined as 'typedef CMoment TMoment'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMoment(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMoment& GetMoment(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMoment& SetMoment(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Unary_functional_mmlclass(const C_Unary_functional_mmlclass& );
                C_Unary_functional_mmlclass& operator=(const C_Unary_functional_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Lambda_mmlclass --
            ///
            
            class C_Lambda_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Lambda_mmlclass(void);
                // destructor
                ~C_Lambda_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CLambda TLambda;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_lambda
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Lambda data member.
                ///
                /// Data member Lambda is mandatory;
                /// its type is defined as 'typedef CLambda TLambda'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetLambda(void) const;
            
                /// Check if it is safe to call GetLambda method.
                ///
                /// @return
                ///   - true, if the data member is getatable.
                ///   - false, otherwise.
                bool CanGetLambda(void) const;
            
                /// Reset Lambda data member.
                void ResetLambda(void);
            
                /// Get the Lambda member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TLambda& GetLambda(void) const;
            
                /// Assign a value to Lambda data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetLambda(TLambda& value);
            
                /// Assign a value to Lambda data member.
                ///
                /// @return
                ///   Reference to the data value.
                TLambda& SetLambda(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Lambda_mmlclass(const C_Lambda_mmlclass&);
                C_Lambda_mmlclass& operator=(const C_Lambda_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TLambda > m_Lambda;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_functional_mmlclass --
            ///
            
            class C_Nary_functional_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_functional_mmlclass(void);
                // destructor
                ~C_Nary_functional_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CCompose TCompose;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_compose
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Compose data member.
                ///
                /// Data member Compose is mandatory;
                /// its type is defined as 'typedef CCompose TCompose'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetCompose(void) const;
            
                /// Check if value of Compose member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetCompose(void) const;
            
                /// Reset Compose data member.
                void ResetCompose(void);
            
                /// Get the Compose member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TCompose& GetCompose(void) const;
            
                /// Assign a value to Compose data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetCompose(TCompose& value);
            
                /// Assign a value to Compose data member.
                ///
                /// @return
                ///   Reference to the data value.
                TCompose& SetCompose(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Nary_functional_mmlclass(const C_Nary_functional_mmlclass&);
                C_Nary_functional_mmlclass& operator=(const C_Nary_functional_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TCompose > m_Compose;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Binary_arith_mmlclass --
            ///
            
            class C_Binary_arith_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Binary_arith_mmlclass(void);
                // destructor
                ~C_Binary_arith_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Quotient,
                    e_Divide,
                    e_Minus,
                    e_Power,
                    e_Rem,
                    e_Root
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 7 ///< == e_Root+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CQuotient TQuotient;
                typedef CDivide TDivide;
                typedef CMinus TMinus;
                typedef CPower TPower;
                typedef CRem TRem;
                typedef CRoot TRoot;
            
                // getters
                // setters
            
            
                /// Check if variant Quotient is selected.
                ///
                /// Quotient type is defined as 'typedef CQuotient TQuotient'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsQuotient(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TQuotient& GetQuotient(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TQuotient& SetQuotient(void);
            
            
                /// Check if variant Divide is selected.
                ///
                /// Divide type is defined as 'typedef CDivide TDivide'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDivide(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDivide& GetDivide(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDivide& SetDivide(void);
            
            
                /// Check if variant Minus is selected.
                ///
                /// Minus type is defined as 'typedef CMinus TMinus'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMinus(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMinus& GetMinus(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMinus& SetMinus(void);
            
            
                /// Check if variant Power is selected.
                ///
                /// Power type is defined as 'typedef CPower TPower'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsPower(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TPower& GetPower(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TPower& SetPower(void);
            
            
                /// Check if variant Rem is selected.
                ///
                /// Rem type is defined as 'typedef CRem TRem'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsRem(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TRem& GetRem(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TRem& SetRem(void);
            
            
                /// Check if variant Root is selected.
                ///
                /// Root type is defined as 'typedef CRoot TRoot'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsRoot(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TRoot& GetRoot(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TRoot& SetRoot(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Binary_arith_mmlclass(const C_Binary_arith_mmlclass& );
                C_Binary_arith_mmlclass& operator=(const C_Binary_arith_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_arith_mmlclass --
            ///
            
            class C_Unary_arith_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_arith_mmlclass(void);
                // destructor
                ~C_Unary_arith_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Factorial,
                    e_Abs,
                    e_Conjugate,
                    e_Arg,
                    e_Real,
                    e_Imaginary,
                    e_Floor,
                    e_Ceiling,
                    e_Exp
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 10 ///< == e_Exp+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CFactorial TFactorial;
                typedef CAbs TAbs;
                typedef CConjugate TConjugate;
                typedef CArg TArg;
                typedef CReal TReal;
                typedef CImaginary TImaginary;
                typedef CFloor TFloor;
                typedef CCeiling TCeiling;
                typedef CExp TExp;
            
                // getters
                // setters
            
            
                /// Check if variant Factorial is selected.
                ///
                /// Factorial type is defined as 'typedef CFactorial TFactorial'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsFactorial(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TFactorial& GetFactorial(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TFactorial& SetFactorial(void);
            
            
                /// Check if variant Abs is selected.
                ///
                /// Abs type is defined as 'typedef CAbs TAbs'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsAbs(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TAbs& GetAbs(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TAbs& SetAbs(void);
            
            
                /// Check if variant Conjugate is selected.
                ///
                /// Conjugate type is defined as 'typedef CConjugate TConjugate'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsConjugate(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TConjugate& GetConjugate(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TConjugate& SetConjugate(void);
            
            
                /// Check if variant Arg is selected.
                ///
                /// Arg type is defined as 'typedef CArg TArg'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArg(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArg& GetArg(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArg& SetArg(void);
            
            
                /// Check if variant Real is selected.
                ///
                /// Real type is defined as 'typedef CReal TReal'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsReal(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TReal& GetReal(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TReal& SetReal(void);
            
            
                /// Check if variant Imaginary is selected.
                ///
                /// Imaginary type is defined as 'typedef CImaginary TImaginary'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsImaginary(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TImaginary& GetImaginary(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TImaginary& SetImaginary(void);
            
            
                /// Check if variant Floor is selected.
                ///
                /// Floor type is defined as 'typedef CFloor TFloor'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsFloor(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TFloor& GetFloor(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TFloor& SetFloor(void);
            
            
                /// Check if variant Ceiling is selected.
                ///
                /// Ceiling type is defined as 'typedef CCeiling TCeiling'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCeiling(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCeiling& GetCeiling(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCeiling& SetCeiling(void);
            
            
                /// Check if variant Exp is selected.
                ///
                /// Exp type is defined as 'typedef CExp TExp'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsExp(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TExp& GetExp(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TExp& SetExp(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Unary_arith_mmlclass(const C_Unary_arith_mmlclass& );
                C_Unary_arith_mmlclass& operator=(const C_Unary_arith_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_minmax_mmlclass --
            ///
            
            class C_Nary_minmax_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_minmax_mmlclass(void);
                // destructor
                ~C_Nary_minmax_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Max,
                    e_Min
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_Min+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CMax TMax;
                typedef CMin TMin;
            
                // getters
                // setters
            
            
                /// Check if variant Max is selected.
                ///
                /// Max type is defined as 'typedef CMax TMax'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMax(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMax& GetMax(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMax& SetMax(void);
            
            
                /// Check if variant Min is selected.
                ///
                /// Min type is defined as 'typedef CMin TMin'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMin(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMin& GetMin(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMin& SetMin(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_minmax_mmlclass(const C_Nary_minmax_mmlclass& );
                C_Nary_minmax_mmlclass& operator=(const C_Nary_minmax_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_arith_mmlclass --
            ///
            
            class C_Nary_arith_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_arith_mmlclass(void);
                // destructor
                ~C_Nary_arith_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Plus,
                    e_Times,
                    e_Gcd,
                    e_Lcm
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 5 ///< == e_Lcm+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CPlus TPlus;
                typedef CTimes TTimes;
                typedef CGcd TGcd;
                typedef CLcm TLcm;
            
                // getters
                // setters
            
            
                /// Check if variant Plus is selected.
                ///
                /// Plus type is defined as 'typedef CPlus TPlus'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsPlus(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TPlus& GetPlus(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TPlus& SetPlus(void);
            
            
                /// Check if variant Times is selected.
                ///
                /// Times type is defined as 'typedef CTimes TTimes'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTimes(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTimes& GetTimes(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTimes& SetTimes(void);
            
            
                /// Check if variant Gcd is selected.
                ///
                /// Gcd type is defined as 'typedef CGcd TGcd'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsGcd(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TGcd& GetGcd(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TGcd& SetGcd(void);
            
            
                /// Check if variant Lcm is selected.
                ///
                /// Lcm type is defined as 'typedef CLcm TLcm'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLcm(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLcm& GetLcm(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLcm& SetLcm(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_arith_mmlclass(const C_Nary_arith_mmlclass& );
                C_Nary_arith_mmlclass& operator=(const C_Nary_arith_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_logical_mmlclass --
            ///
            
            class C_Nary_logical_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_logical_mmlclass(void);
                // destructor
                ~C_Nary_logical_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_And,
                    e_Or,
                    e_Xor
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_Xor+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CAnd TAnd;
                typedef COr TOr;
                typedef CXor TXor;
            
                // getters
                // setters
            
            
                /// Check if variant And is selected.
                ///
                /// And type is defined as 'typedef CAnd TAnd'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsAnd(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TAnd& GetAnd(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TAnd& SetAnd(void);
            
            
                /// Check if variant Or is selected.
                ///
                /// Or type is defined as 'typedef COr TOr'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsOr(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TOr& GetOr(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TOr& SetOr(void);
            
            
                /// Check if variant Xor is selected.
                ///
                /// Xor type is defined as 'typedef CXor TXor'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsXor(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TXor& GetXor(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TXor& SetXor(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_logical_mmlclass(const C_Nary_logical_mmlclass& );
                C_Nary_logical_mmlclass& operator=(const C_Nary_logical_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_logical_mmlclass --
            ///
            
            class C_Unary_logical_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_logical_mmlclass(void);
                // destructor
                ~C_Unary_logical_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CNot TNot;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_not
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Not data member.
                ///
                /// Data member Not is mandatory;
                /// its type is defined as 'typedef CNot TNot'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetNot(void) const;
            
                /// Check if value of Not member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetNot(void) const;
            
                /// Reset Not data member.
                void ResetNot(void);
            
                /// Get the Not member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TNot& GetNot(void) const;
            
                /// Assign a value to Not data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetNot(TNot& value);
            
                /// Assign a value to Not data member.
                ///
                /// @return
                ///   Reference to the data value.
                TNot& SetNot(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Unary_logical_mmlclass(const C_Unary_logical_mmlclass&);
                C_Unary_logical_mmlclass& operator=(const C_Unary_logical_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TNot > m_Not;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Binary_logical_mmlclass --
            ///
            
            class C_Binary_logical_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Binary_logical_mmlclass(void);
                // destructor
                ~C_Binary_logical_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Implies,
                    e_Equivalent
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_Equivalent+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CImplies TImplies;
                typedef CEquivalent TEquivalent;
            
                // getters
                // setters
            
            
                /// Check if variant Implies is selected.
                ///
                /// Implies type is defined as 'typedef CImplies TImplies'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsImplies(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TImplies& GetImplies(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TImplies& SetImplies(void);
            
            
                /// Check if variant Equivalent is selected.
                ///
                /// Equivalent type is defined as 'typedef CEquivalent TEquivalent'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsEquivalent(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TEquivalent& GetEquivalent(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TEquivalent& SetEquivalent(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Binary_logical_mmlclass(const C_Binary_logical_mmlclass& );
                C_Binary_logical_mmlclass& operator=(const C_Binary_logical_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Quantifier_mmlclass --
            ///
            
            class C_Quantifier_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Quantifier_mmlclass(void);
                // destructor
                ~C_Quantifier_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Forall,
                    e_Exists
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_Exists+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CForall TForall;
                typedef CExists TExists;
            
                // getters
                // setters
            
            
                /// Check if variant Forall is selected.
                ///
                /// Forall type is defined as 'typedef CForall TForall'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsForall(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TForall& GetForall(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TForall& SetForall(void);
            
            
                /// Check if variant Exists is selected.
                ///
                /// Exists type is defined as 'typedef CExists TExists'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsExists(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TExists& GetExists(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TExists& SetExists(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Quantifier_mmlclass(const C_Quantifier_mmlclass& );
                C_Quantifier_mmlclass& operator=(const C_Quantifier_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_reln_mmlclass --
            ///
            
            class C_Nary_reln_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_reln_mmlclass(void);
                // destructor
                ~C_Nary_reln_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Eq,
                    e_Gt,
                    e_Lt,
                    e_Geq,
                    e_Leq
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 6 ///< == e_Leq+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CEq TEq;
                typedef CGt TGt;
                typedef CLt TLt;
                typedef CGeq TGeq;
                typedef CLeq TLeq;
            
                // getters
                // setters
            
            
                /// Check if variant Eq is selected.
                ///
                /// Eq type is defined as 'typedef CEq TEq'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsEq(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TEq& GetEq(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TEq& SetEq(void);
            
            
                /// Check if variant Gt is selected.
                ///
                /// Gt type is defined as 'typedef CGt TGt'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsGt(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TGt& GetGt(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TGt& SetGt(void);
            
            
                /// Check if variant Lt is selected.
                ///
                /// Lt type is defined as 'typedef CLt TLt'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLt(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLt& GetLt(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLt& SetLt(void);
            
            
                /// Check if variant Geq is selected.
                ///
                /// Geq type is defined as 'typedef CGeq TGeq'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsGeq(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TGeq& GetGeq(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TGeq& SetGeq(void);
            
            
                /// Check if variant Leq is selected.
                ///
                /// Leq type is defined as 'typedef CLeq TLeq'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLeq(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLeq& GetLeq(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLeq& SetLeq(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_reln_mmlclass(const C_Nary_reln_mmlclass& );
                C_Nary_reln_mmlclass& operator=(const C_Nary_reln_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Binary_reln_mmlclass --
            ///
            
            class C_Binary_reln_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Binary_reln_mmlclass(void);
                // destructor
                ~C_Binary_reln_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Neq,
                    e_Approx,
                    e_Factorof,
                    e_Tendsto
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 5 ///< == e_Tendsto+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CNeq TNeq;
                typedef CApprox TApprox;
                typedef CFactorof TFactorof;
                typedef CTendsto TTendsto;
            
                // getters
                // setters
            
            
                /// Check if variant Neq is selected.
                ///
                /// Neq type is defined as 'typedef CNeq TNeq'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNeq(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNeq& GetNeq(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNeq& SetNeq(void);
            
            
                /// Check if variant Approx is selected.
                ///
                /// Approx type is defined as 'typedef CApprox TApprox'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsApprox(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TApprox& GetApprox(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TApprox& SetApprox(void);
            
            
                /// Check if variant Factorof is selected.
                ///
                /// Factorof type is defined as 'typedef CFactorof TFactorof'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsFactorof(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TFactorof& GetFactorof(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TFactorof& SetFactorof(void);
            
            
                /// Check if variant Tendsto is selected.
                ///
                /// Tendsto type is defined as 'typedef CTendsto TTendsto'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTendsto(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTendsto& GetTendsto(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTendsto& SetTendsto(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Binary_reln_mmlclass(const C_Binary_reln_mmlclass& );
                C_Binary_reln_mmlclass& operator=(const C_Binary_reln_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Int_mmlclass --
            ///
            
            class C_Int_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Int_mmlclass(void);
                // destructor
                ~C_Int_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CInt TInt;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_int
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Int data member.
                ///
                /// Data member Int is mandatory;
                /// its type is defined as 'typedef CInt TInt'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetInt(void) const;
            
                /// Check if value of Int member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetInt(void) const;
            
                /// Reset Int data member.
                void ResetInt(void);
            
                /// Get the Int member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TInt& GetInt(void) const;
            
                /// Assign a value to Int data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetInt(TInt& value);
            
                /// Assign a value to Int data member.
                ///
                /// @return
                ///   Reference to the data value.
                TInt& SetInt(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Int_mmlclass(const C_Int_mmlclass&);
                C_Int_mmlclass& operator=(const C_Int_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TInt > m_Int;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Differential_Operator_mmlclass --
            ///
            
            class C_Differential_Operator_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Differential_Operator_mmlclass(void);
                // destructor
                ~C_Differential_Operator_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CDiff TDiff;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_diff
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Diff data member.
                ///
                /// Data member Diff is mandatory;
                /// its type is defined as 'typedef CDiff TDiff'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetDiff(void) const;
            
                /// Check if value of Diff member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetDiff(void) const;
            
                /// Reset Diff data member.
                void ResetDiff(void);
            
                /// Get the Diff member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TDiff& GetDiff(void) const;
            
                /// Assign a value to Diff data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetDiff(TDiff& value);
            
                /// Assign a value to Diff data member.
                ///
                /// @return
                ///   Reference to the data value.
                TDiff& SetDiff(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Differential_Operator_mmlclass(const C_Differential_Operator_mmlclass&);
                C_Differential_Operator_mmlclass& operator=(const C_Differential_Operator_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TDiff > m_Diff;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Partialdiff_mmlclass --
            ///
            
            class C_Partialdiff_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Partialdiff_mmlclass(void);
                // destructor
                ~C_Partialdiff_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CPartialdiff TPartialdiff;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_partialdiff
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Partialdiff data member.
                ///
                /// Data member Partialdiff is mandatory;
                /// its type is defined as 'typedef CPartialdiff TPartialdiff'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetPartialdiff(void) const;
            
                /// Check if value of Partialdiff member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetPartialdiff(void) const;
            
                /// Reset Partialdiff data member.
                void ResetPartialdiff(void);
            
                /// Get the Partialdiff member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TPartialdiff& GetPartialdiff(void) const;
            
                /// Assign a value to Partialdiff data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetPartialdiff(TPartialdiff& value);
            
                /// Assign a value to Partialdiff data member.
                ///
                /// @return
                ///   Reference to the data value.
                TPartialdiff& SetPartialdiff(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Partialdiff_mmlclass(const C_Partialdiff_mmlclass&);
                C_Partialdiff_mmlclass& operator=(const C_Partialdiff_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TPartialdiff > m_Partialdiff;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_veccalc_mmlclass --
            ///
            
            class C_Unary_veccalc_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_veccalc_mmlclass(void);
                // destructor
                ~C_Unary_veccalc_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Divergence,
                    e_Grad,
                    e_Curl,
                    e_Laplacian
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 5 ///< == e_Laplacian+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CDivergence TDivergence;
                typedef CGrad TGrad;
                typedef CCurl TCurl;
                typedef CLaplacian TLaplacian;
            
                // getters
                // setters
            
            
                /// Check if variant Divergence is selected.
                ///
                /// Divergence type is defined as 'typedef CDivergence TDivergence'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDivergence(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDivergence& GetDivergence(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDivergence& SetDivergence(void);
            
            
                /// Check if variant Grad is selected.
                ///
                /// Grad type is defined as 'typedef CGrad TGrad'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsGrad(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TGrad& GetGrad(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TGrad& SetGrad(void);
            
            
                /// Check if variant Curl is selected.
                ///
                /// Curl type is defined as 'typedef CCurl TCurl'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCurl(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCurl& GetCurl(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCurl& SetCurl(void);
            
            
                /// Check if variant Laplacian is selected.
                ///
                /// Laplacian type is defined as 'typedef CLaplacian TLaplacian'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLaplacian(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLaplacian& GetLaplacian(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLaplacian& SetLaplacian(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Unary_veccalc_mmlclass(const C_Unary_veccalc_mmlclass& );
                C_Unary_veccalc_mmlclass& operator=(const C_Unary_veccalc_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_setlist_constructor_mmlclass --
            ///
            
            class C_Nary_setlist_constructor_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_setlist_constructor_mmlclass(void);
                // destructor
                ~C_Nary_setlist_constructor_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Set,
                    e_List
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_List+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CSet TSet;
                typedef CList TList;
            
                // getters
                // setters
            
            
                /// Check if variant Set is selected.
                ///
                /// Set type is defined as 'typedef CSet TSet'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSet(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSet& GetSet(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSet& SetSet(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetSet(TSet& value);
            
            
                /// Check if variant List is selected.
                ///
                /// List type is defined as 'typedef CList TList'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsList(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TList& GetList(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TList& SetList(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetList(TList& value);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_setlist_constructor_mmlclass(const C_Nary_setlist_constructor_mmlclass& );
                C_Nary_setlist_constructor_mmlclass& operator=(const C_Nary_setlist_constructor_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_set_mmlclass --
            ///
            
            class C_Nary_set_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_set_mmlclass(void);
                // destructor
                ~C_Nary_set_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,       ///< No variant selected
                    e_Union,
                    e_Intersect,
                    e_Cartesianproduct
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_Cartesianproduct+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CUnion TUnion;
                typedef CIntersect TIntersect;
                typedef CCartesianproduct TCartesianproduct;
            
                // getters
                // setters
            
            
                /// Check if variant Union is selected.
                ///
                /// Union type is defined as 'typedef CUnion TUnion'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsUnion(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TUnion& GetUnion(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TUnion& SetUnion(void);
            
            
                /// Check if variant Intersect is selected.
                ///
                /// Intersect type is defined as 'typedef CIntersect TIntersect'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsIntersect(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TIntersect& GetIntersect(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TIntersect& SetIntersect(void);
            
            
                /// Check if variant Cartesianproduct is selected.
                ///
                /// Cartesianproduct type is defined as 'typedef CCartesianproduct TCartesianproduct'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCartesianproduct(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCartesianproduct& GetCartesianproduct(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCartesianproduct& SetCartesianproduct(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_set_mmlclass(const C_Nary_set_mmlclass& );
                C_Nary_set_mmlclass& operator=(const C_Nary_set_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Binary_set_mmlclass --
            ///
            
            class C_Binary_set_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Binary_set_mmlclass(void);
                // destructor
                ~C_Binary_set_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_In,
                    e_Notin,
                    e_Notsubset,
                    e_Notprsubset,
                    e_Setdiff
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 6 ///< == e_Setdiff+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CIn TIn;
                typedef CNotin TNotin;
                typedef CNotsubset TNotsubset;
                typedef CNotprsubset TNotprsubset;
                typedef CSetdiff TSetdiff;
            
                // getters
                // setters
            
            
                /// Check if variant In is selected.
                ///
                /// In type is defined as 'typedef CIn TIn'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsIn(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TIn& GetIn(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TIn& SetIn(void);
            
            
                /// Check if variant Notin is selected.
                ///
                /// Notin type is defined as 'typedef CNotin TNotin'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNotin(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNotin& GetNotin(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNotin& SetNotin(void);
            
            
                /// Check if variant Notsubset is selected.
                ///
                /// Notsubset type is defined as 'typedef CNotsubset TNotsubset'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNotsubset(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNotsubset& GetNotsubset(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNotsubset& SetNotsubset(void);
            
            
                /// Check if variant Notprsubset is selected.
                ///
                /// Notprsubset type is defined as 'typedef CNotprsubset TNotprsubset'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNotprsubset(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNotprsubset& GetNotprsubset(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNotprsubset& SetNotprsubset(void);
            
            
                /// Check if variant Setdiff is selected.
                ///
                /// Setdiff type is defined as 'typedef CSetdiff TSetdiff'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSetdiff(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSetdiff& GetSetdiff(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSetdiff& SetSetdiff(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Binary_set_mmlclass(const C_Binary_set_mmlclass& );
                C_Binary_set_mmlclass& operator=(const C_Binary_set_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_set_reln_mmlclass --
            ///
            
            class C_Nary_set_reln_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_set_reln_mmlclass(void);
                // destructor
                ~C_Nary_set_reln_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Subset,
                    e_Prsubset
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_Prsubset+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CSubset TSubset;
                typedef CPrsubset TPrsubset;
            
                // getters
                // setters
            
            
                /// Check if variant Subset is selected.
                ///
                /// Subset type is defined as 'typedef CSubset TSubset'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSubset(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSubset& GetSubset(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSubset& SetSubset(void);
            
            
                /// Check if variant Prsubset is selected.
                ///
                /// Prsubset type is defined as 'typedef CPrsubset TPrsubset'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsPrsubset(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TPrsubset& GetPrsubset(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TPrsubset& SetPrsubset(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_set_reln_mmlclass(const C_Nary_set_reln_mmlclass& );
                C_Nary_set_reln_mmlclass& operator=(const C_Nary_set_reln_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_set_mmlclass --
            ///
            
            class C_Unary_set_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_set_mmlclass(void);
                // destructor
                ~C_Unary_set_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CCard TCard;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_card
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Card data member.
                ///
                /// Data member Card is mandatory;
                /// its type is defined as 'typedef CCard TCard'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetCard(void) const;
            
                /// Check if value of Card member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetCard(void) const;
            
                /// Reset Card data member.
                void ResetCard(void);
            
                /// Get the Card member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TCard& GetCard(void) const;
            
                /// Assign a value to Card data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetCard(TCard& value);
            
                /// Assign a value to Card data member.
                ///
                /// @return
                ///   Reference to the data value.
                TCard& SetCard(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Unary_set_mmlclass(const C_Unary_set_mmlclass&);
                C_Unary_set_mmlclass& operator=(const C_Unary_set_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TCard > m_Card;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Sum_mmlclass --
            ///
            
            class C_Sum_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Sum_mmlclass(void);
                // destructor
                ~C_Sum_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CSum TSum;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_sum
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Sum data member.
                ///
                /// Data member Sum is mandatory;
                /// its type is defined as 'typedef CSum TSum'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetSum(void) const;
            
                /// Check if value of Sum member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetSum(void) const;
            
                /// Reset Sum data member.
                void ResetSum(void);
            
                /// Get the Sum member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TSum& GetSum(void) const;
            
                /// Assign a value to Sum data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetSum(TSum& value);
            
                /// Assign a value to Sum data member.
                ///
                /// @return
                ///   Reference to the data value.
                TSum& SetSum(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Sum_mmlclass(const C_Sum_mmlclass&);
                C_Sum_mmlclass& operator=(const C_Sum_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TSum > m_Sum;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Product_mmlclass --
            ///
            
            class C_Product_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Product_mmlclass(void);
                // destructor
                ~C_Product_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CProduct TProduct;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_product
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Product data member.
                ///
                /// Data member Product is mandatory;
                /// its type is defined as 'typedef CProduct TProduct'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetProduct(void) const;
            
                /// Check if value of Product member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetProduct(void) const;
            
                /// Reset Product data member.
                void ResetProduct(void);
            
                /// Get the Product member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TProduct& GetProduct(void) const;
            
                /// Assign a value to Product data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetProduct(TProduct& value);
            
                /// Assign a value to Product data member.
                ///
                /// @return
                ///   Reference to the data value.
                TProduct& SetProduct(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Product_mmlclass(const C_Product_mmlclass&);
                C_Product_mmlclass& operator=(const C_Product_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TProduct > m_Product;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Limit_mmlclass --
            ///
            
            class C_Limit_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Limit_mmlclass(void);
                // destructor
                ~C_Limit_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CLimit TLimit;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_limit
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Limit data member.
                ///
                /// Data member Limit is mandatory;
                /// its type is defined as 'typedef CLimit TLimit'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetLimit(void) const;
            
                /// Check if value of Limit member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetLimit(void) const;
            
                /// Reset Limit data member.
                void ResetLimit(void);
            
                /// Get the Limit member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TLimit& GetLimit(void) const;
            
                /// Assign a value to Limit data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetLimit(TLimit& value);
            
                /// Assign a value to Limit data member.
                ///
                /// @return
                ///   Reference to the data value.
                TLimit& SetLimit(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Limit_mmlclass(const C_Limit_mmlclass&);
                C_Limit_mmlclass& operator=(const C_Limit_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TLimit > m_Limit;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_elementary_mmlclass --
            ///
            
            class C_Unary_elementary_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_elementary_mmlclass(void);
                // destructor
                ~C_Unary_elementary_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Sin,
                    e_Cos,
                    e_Tan,
                    e_Sec,
                    e_Csc,
                    e_Cot,
                    e_Sinh,
                    e_Cosh,
                    e_Tanh,
                    e_Sech,
                    e_Csch,
                    e_Coth,
                    e_Arcsin,
                    e_Arccos,
                    e_Arctan,
                    e_Arccosh,
                    e_Arccot,
                    e_Arccoth,
                    e_Arccsc,
                    e_Arccsch,
                    e_Arcsec,
                    e_Arcsech,
                    e_Arcsinh,
                    e_Arctanh
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 25 ///< == e_Arctanh+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CSin TSin;
                typedef CCos TCos;
                typedef CTan TTan;
                typedef CSec TSec;
                typedef CCsc TCsc;
                typedef CCot TCot;
                typedef CSinh TSinh;
                typedef CCosh TCosh;
                typedef CTanh TTanh;
                typedef CSech TSech;
                typedef CCsch TCsch;
                typedef CCoth TCoth;
                typedef CArcsin TArcsin;
                typedef CArccos TArccos;
                typedef CArctan TArctan;
                typedef CArccosh TArccosh;
                typedef CArccot TArccot;
                typedef CArccoth TArccoth;
                typedef CArccsc TArccsc;
                typedef CArccsch TArccsch;
                typedef CArcsec TArcsec;
                typedef CArcsech TArcsech;
                typedef CArcsinh TArcsinh;
                typedef CArctanh TArctanh;
            
                // getters
                // setters
            
            
                /// Check if variant Sin is selected.
                ///
                /// Sin type is defined as 'typedef CSin TSin'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSin(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSin& GetSin(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSin& SetSin(void);
            
            
                /// Check if variant Cos is selected.
                ///
                /// Cos type is defined as 'typedef CCos TCos'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCos(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCos& GetCos(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCos& SetCos(void);
            
            
                /// Check if variant Tan is selected.
                ///
                /// Tan type is defined as 'typedef CTan TTan'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTan(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTan& GetTan(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTan& SetTan(void);
            
            
                /// Check if variant Sec is selected.
                ///
                /// Sec type is defined as 'typedef CSec TSec'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSec(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSec& GetSec(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSec& SetSec(void);
            
            
                /// Check if variant Csc is selected.
                ///
                /// Csc type is defined as 'typedef CCsc TCsc'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCsc(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCsc& GetCsc(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCsc& SetCsc(void);
            
            
                /// Check if variant Cot is selected.
                ///
                /// Cot type is defined as 'typedef CCot TCot'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCot(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCot& GetCot(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCot& SetCot(void);
            
            
                /// Check if variant Sinh is selected.
                ///
                /// Sinh type is defined as 'typedef CSinh TSinh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSinh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSinh& GetSinh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSinh& SetSinh(void);
            
            
                /// Check if variant Cosh is selected.
                ///
                /// Cosh type is defined as 'typedef CCosh TCosh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCosh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCosh& GetCosh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCosh& SetCosh(void);
            
            
                /// Check if variant Tanh is selected.
                ///
                /// Tanh type is defined as 'typedef CTanh TTanh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTanh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTanh& GetTanh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTanh& SetTanh(void);
            
            
                /// Check if variant Sech is selected.
                ///
                /// Sech type is defined as 'typedef CSech TSech'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSech(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSech& GetSech(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSech& SetSech(void);
            
            
                /// Check if variant Csch is selected.
                ///
                /// Csch type is defined as 'typedef CCsch TCsch'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCsch(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCsch& GetCsch(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCsch& SetCsch(void);
            
            
                /// Check if variant Coth is selected.
                ///
                /// Coth type is defined as 'typedef CCoth TCoth'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCoth(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCoth& GetCoth(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCoth& SetCoth(void);
            
            
                /// Check if variant Arcsin is selected.
                ///
                /// Arcsin type is defined as 'typedef CArcsin TArcsin'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArcsin(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArcsin& GetArcsin(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArcsin& SetArcsin(void);
            
            
                /// Check if variant Arccos is selected.
                ///
                /// Arccos type is defined as 'typedef CArccos TArccos'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccos(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccos& GetArccos(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccos& SetArccos(void);
            
            
                /// Check if variant Arctan is selected.
                ///
                /// Arctan type is defined as 'typedef CArctan TArctan'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArctan(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArctan& GetArctan(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArctan& SetArctan(void);
            
            
                /// Check if variant Arccosh is selected.
                ///
                /// Arccosh type is defined as 'typedef CArccosh TArccosh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccosh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccosh& GetArccosh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccosh& SetArccosh(void);
            
            
                /// Check if variant Arccot is selected.
                ///
                /// Arccot type is defined as 'typedef CArccot TArccot'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccot(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccot& GetArccot(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccot& SetArccot(void);
            
            
                /// Check if variant Arccoth is selected.
                ///
                /// Arccoth type is defined as 'typedef CArccoth TArccoth'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccoth(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccoth& GetArccoth(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccoth& SetArccoth(void);
            
            
                /// Check if variant Arccsc is selected.
                ///
                /// Arccsc type is defined as 'typedef CArccsc TArccsc'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccsc(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccsc& GetArccsc(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccsc& SetArccsc(void);
            
            
                /// Check if variant Arccsch is selected.
                ///
                /// Arccsch type is defined as 'typedef CArccsch TArccsch'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArccsch(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArccsch& GetArccsch(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArccsch& SetArccsch(void);
            
            
                /// Check if variant Arcsec is selected.
                ///
                /// Arcsec type is defined as 'typedef CArcsec TArcsec'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArcsec(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArcsec& GetArcsec(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArcsec& SetArcsec(void);
            
            
                /// Check if variant Arcsech is selected.
                ///
                /// Arcsech type is defined as 'typedef CArcsech TArcsech'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArcsech(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArcsech& GetArcsech(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArcsech& SetArcsech(void);
            
            
                /// Check if variant Arcsinh is selected.
                ///
                /// Arcsinh type is defined as 'typedef CArcsinh TArcsinh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArcsinh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArcsinh& GetArcsinh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArcsinh& SetArcsinh(void);
            
            
                /// Check if variant Arctanh is selected.
                ///
                /// Arctanh type is defined as 'typedef CArctanh TArctanh'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsArctanh(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TArctanh& GetArctanh(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TArctanh& SetArctanh(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Unary_elementary_mmlclass(const C_Unary_elementary_mmlclass& );
                C_Unary_elementary_mmlclass& operator=(const C_Unary_elementary_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_stats_mmlclass --
            ///
            
            class C_Nary_stats_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_stats_mmlclass(void);
                // destructor
                ~C_Nary_stats_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Mean,
                    e_Sdev,
                    e_Variance,
                    e_Median,
                    e_Mode
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 6 ///< == e_Mode+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CMean TMean;
                typedef CSdev TSdev;
                typedef CVariance TVariance;
                typedef CMedian TMedian;
                typedef CMode TMode;
            
                // getters
                // setters
            
            
                /// Check if variant Mean is selected.
                ///
                /// Mean type is defined as 'typedef CMean TMean'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMean(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMean& GetMean(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMean& SetMean(void);
            
            
                /// Check if variant Sdev is selected.
                ///
                /// Sdev type is defined as 'typedef CSdev TSdev'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsSdev(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TSdev& GetSdev(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TSdev& SetSdev(void);
            
            
                /// Check if variant Variance is selected.
                ///
                /// Variance type is defined as 'typedef CVariance TVariance'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsVariance(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TVariance& GetVariance(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TVariance& SetVariance(void);
            
            
                /// Check if variant Median is selected.
                ///
                /// Median type is defined as 'typedef CMedian TMedian'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMedian(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMedian& GetMedian(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMedian& SetMedian(void);
            
            
                /// Check if variant Mode is selected.
                ///
                /// Mode type is defined as 'typedef CMode TMode'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMode(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMode& GetMode(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMode& SetMode(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_stats_mmlclass(const C_Nary_stats_mmlclass& );
                C_Nary_stats_mmlclass& operator=(const C_Nary_stats_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_constructor_mmlclass --
            ///
            
            class C_Nary_constructor_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_constructor_mmlclass(void);
                // destructor
                ~C_Nary_constructor_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Vector,
                    e_Matrix,
                    e_Matrixrow
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_Matrixrow+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CVector TVector;
                typedef CMatrix TMatrix;
                typedef CMatrixrow TMatrixrow;
            
                // getters
                // setters
            
            
                /// Check if variant Vector is selected.
                ///
                /// Vector type is defined as 'typedef CVector TVector'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsVector(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TVector& GetVector(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TVector& SetVector(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetVector(TVector& value);
            
            
                /// Check if variant Matrix is selected.
                ///
                /// Matrix type is defined as 'typedef CMatrix TMatrix'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMatrix(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMatrix& GetMatrix(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMatrix& SetMatrix(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetMatrix(TMatrix& value);
            
            
                /// Check if variant Matrixrow is selected.
                ///
                /// Matrixrow type is defined as 'typedef CMatrixrow TMatrixrow'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsMatrixrow(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TMatrixrow& GetMatrixrow(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TMatrixrow& SetMatrixrow(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetMatrixrow(TMatrixrow& value);
            
            
            private:
                // copy constructor and assignment operator
                C_Nary_constructor_mmlclass(const C_Nary_constructor_mmlclass& );
                C_Nary_constructor_mmlclass& operator=(const C_Nary_constructor_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Unary_linalg_mmlclass --
            ///
            
            class C_Unary_linalg_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Unary_linalg_mmlclass(void);
                // destructor
                ~C_Unary_linalg_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,  ///< No variant selected
                    e_Determinant,
                    e_Transpose
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 3 ///< == e_Transpose+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CDeterminant TDeterminant;
                typedef CTranspose TTranspose;
            
                // getters
                // setters
            
            
                /// Check if variant Determinant is selected.
                ///
                /// Determinant type is defined as 'typedef CDeterminant TDeterminant'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDeterminant(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDeterminant& GetDeterminant(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDeterminant& SetDeterminant(void);
            
            
                /// Check if variant Transpose is selected.
                ///
                /// Transpose type is defined as 'typedef CTranspose TTranspose'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTranspose(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTranspose& GetTranspose(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTranspose& SetTranspose(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Unary_linalg_mmlclass(const C_Unary_linalg_mmlclass& );
                C_Unary_linalg_mmlclass& operator=(const C_Unary_linalg_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Nary_linalg_mmlclass --
            ///
            
            class C_Nary_linalg_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Nary_linalg_mmlclass(void);
                // destructor
                ~C_Nary_linalg_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                // types
                typedef CSelector TSelector;
            
                // member index
                enum class E_memberIndex {
                    e__allMandatory = 0,
                    e_selector
                };
                typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
            
                // getters
                // setters
            
                /// Check if a value has been assigned to Selector data member.
                ///
                /// Data member Selector is mandatory;
                /// its type is defined as 'typedef CSelector TSelector'
                /// @return
                ///   - true, if a value has been assigned.
                ///   - false, otherwise.
                bool IsSetSelector(void) const;
            
                /// Check if value of Selector member is getatable.
                ///
                /// @return
                ///   - false; the data member of type 'NULL' has no value.
                bool CanGetSelector(void) const;
            
                /// Reset Selector data member.
                void ResetSelector(void);
            
                /// Get the Selector member data.
                ///
                /// @return
                ///   Reference to the member data.
                const TSelector& GetSelector(void) const;
            
                /// Assign a value to Selector data member.
                ///
                /// @param value
                ///   Reference to value.
                void SetSelector(TSelector& value);
            
                /// Assign a value to Selector data member.
                ///
                /// @return
                ///   Reference to the data value.
                TSelector& SetSelector(void);
            
                /// Reset the whole object
                void Reset(void);
            
            
            private:
                // Prohibit copy constructor and assignment operator
                C_Nary_linalg_mmlclass(const C_Nary_linalg_mmlclass&);
                C_Nary_linalg_mmlclass& operator=(const C_Nary_linalg_mmlclass&);
            
                // data
                Uint4 m_set_State[1];
                CRef< TSelector > m_Selector;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Binary_linalg_mmlclass --
            ///
            
            class C_Binary_linalg_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Binary_linalg_mmlclass(void);
                // destructor
                ~C_Binary_linalg_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,    ///< No variant selected
                    e_Vectorproduct,
                    e_Scalarproduct,
                    e_Outerproduct
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_Outerproduct+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CVectorproduct TVectorproduct;
                typedef CScalarproduct TScalarproduct;
                typedef COuterproduct TOuterproduct;
            
                // getters
                // setters
            
            
                /// Check if variant Vectorproduct is selected.
                ///
                /// Vectorproduct type is defined as 'typedef CVectorproduct TVectorproduct'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsVectorproduct(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TVectorproduct& GetVectorproduct(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TVectorproduct& SetVectorproduct(void);
            
            
                /// Check if variant Scalarproduct is selected.
                ///
                /// Scalarproduct type is defined as 'typedef CScalarproduct TScalarproduct'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsScalarproduct(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TScalarproduct& GetScalarproduct(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TScalarproduct& SetScalarproduct(void);
            
            
                /// Check if variant Outerproduct is selected.
                ///
                /// Outerproduct type is defined as 'typedef COuterproduct TOuterproduct'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsOuterproduct(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TOuterproduct& GetOuterproduct(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TOuterproduct& SetOuterproduct(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Binary_linalg_mmlclass(const C_Binary_linalg_mmlclass& );
                C_Binary_linalg_mmlclass& operator=(const C_Binary_linalg_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Constant_set_mmlclass --
            ///
            
            class C_Constant_set_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Constant_set_mmlclass(void);
                // destructor
                ~C_Constant_set_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,     ///< No variant selected
                    e_Integers,
                    e_Reals,
                    e_Rationals,
                    e_Naturalnumbers,
                    e_Complexes,
                    e_Primes,
                    e_Emptyset
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 8 ///< == e_Emptyset+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CIntegers TIntegers;
                typedef CReals TReals;
                typedef CRationals TRationals;
                typedef CNaturalnumbers TNaturalnumbers;
                typedef CComplexes TComplexes;
                typedef CPrimes TPrimes;
                typedef CEmptyset TEmptyset;
            
                // getters
                // setters
            
            
                /// Check if variant Integers is selected.
                ///
                /// Integers type is defined as 'typedef CIntegers TIntegers'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsIntegers(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TIntegers& GetIntegers(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TIntegers& SetIntegers(void);
            
            
                /// Check if variant Reals is selected.
                ///
                /// Reals type is defined as 'typedef CReals TReals'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsReals(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TReals& GetReals(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TReals& SetReals(void);
            
            
                /// Check if variant Rationals is selected.
                ///
                /// Rationals type is defined as 'typedef CRationals TRationals'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsRationals(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TRationals& GetRationals(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TRationals& SetRationals(void);
            
            
                /// Check if variant Naturalnumbers is selected.
                ///
                /// Naturalnumbers type is defined as 'typedef CNaturalnumbers TNaturalnumbers'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNaturalnumbers(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNaturalnumbers& GetNaturalnumbers(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNaturalnumbers& SetNaturalnumbers(void);
            
            
                /// Check if variant Complexes is selected.
                ///
                /// Complexes type is defined as 'typedef CComplexes TComplexes'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsComplexes(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TComplexes& GetComplexes(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TComplexes& SetComplexes(void);
            
            
                /// Check if variant Primes is selected.
                ///
                /// Primes type is defined as 'typedef CPrimes TPrimes'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsPrimes(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TPrimes& GetPrimes(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TPrimes& SetPrimes(void);
            
            
                /// Check if variant Emptyset is selected.
                ///
                /// Emptyset type is defined as 'typedef CEmptyset TEmptyset'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsEmptyset(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TEmptyset& GetEmptyset(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TEmptyset& SetEmptyset(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Constant_set_mmlclass(const C_Constant_set_mmlclass& );
                C_Constant_set_mmlclass& operator=(const C_Constant_set_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_Constant_arith_mmlclass --
            ///
            
            class C_Constant_arith_mmlclass : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_Constant_arith_mmlclass(void);
                // destructor
                ~C_Constant_arith_mmlclass(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,   ///< No variant selected
                    e_Exponentiale,
                    e_Imaginaryi,
                    e_Notanumber,
                    e_True,
                    e_False,
                    e_Pi,
                    e_Eulergamma,
                    e_Infinity
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 9 ///< == e_Infinity+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CExponentiale TExponentiale;
                typedef CImaginaryi TImaginaryi;
                typedef CNotanumber TNotanumber;
                typedef CTrue TTrue;
                typedef CFalse TFalse;
                typedef CPi TPi;
                typedef CEulergamma TEulergamma;
                typedef CInfinity TInfinity;
            
                // getters
                // setters
            
            
                /// Check if variant Exponentiale is selected.
                ///
                /// Exponentiale type is defined as 'typedef CExponentiale TExponentiale'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsExponentiale(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TExponentiale& GetExponentiale(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TExponentiale& SetExponentiale(void);
            
            
                /// Check if variant Imaginaryi is selected.
                ///
                /// Imaginaryi type is defined as 'typedef CImaginaryi TImaginaryi'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsImaginaryi(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TImaginaryi& GetImaginaryi(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TImaginaryi& SetImaginaryi(void);
            
            
                /// Check if variant Notanumber is selected.
                ///
                /// Notanumber type is defined as 'typedef CNotanumber TNotanumber'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsNotanumber(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TNotanumber& GetNotanumber(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TNotanumber& SetNotanumber(void);
            
            
                /// Check if variant True is selected.
                ///
                /// True type is defined as 'typedef CTrue TTrue'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsTrue(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TTrue& GetTrue(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TTrue& SetTrue(void);
            
            
                /// Check if variant False is selected.
                ///
                /// False type is defined as 'typedef CFalse TFalse'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsFalse(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TFalse& GetFalse(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TFalse& SetFalse(void);
            
            
                /// Check if variant Pi is selected.
                ///
                /// Pi type is defined as 'typedef CPi TPi'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsPi(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TPi& GetPi(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TPi& SetPi(void);
            
            
                /// Check if variant Eulergamma is selected.
                ///
                /// Eulergamma type is defined as 'typedef CEulergamma TEulergamma'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsEulergamma(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TEulergamma& GetEulergamma(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TEulergamma& SetEulergamma(void);
            
            
                /// Check if variant Infinity is selected.
                ///
                /// Infinity type is defined as 'typedef CInfinity TInfinity'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsInfinity(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TInfinity& GetInfinity(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TInfinity& SetInfinity(void);
            
            
            private:
                // copy constructor and assignment operator
                C_Constant_arith_mmlclass(const C_Constant_arith_mmlclass& );
                C_Constant_arith_mmlclass& operator=(const C_Constant_arith_mmlclass& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,                        ///< No variant selected
                e_Piecewise,
                e_DeprecatedContExp,
                e_Interval_mmlclass,
                e_Unary_functional_mmlclass,
                e_Lambda_mmlclass,
                e_Nary_functional_mmlclass,
                e_Binary_arith_mmlclass,
                e_Unary_arith_mmlclass,
                e_Nary_minmax_mmlclass,
                e_Nary_arith_mmlclass,
                e_Nary_logical_mmlclass,
                e_Unary_logical_mmlclass,
                e_Binary_logical_mmlclass,
                e_Quantifier_mmlclass,
                e_Nary_reln_mmlclass,
                e_Binary_reln_mmlclass,
                e_Int_mmlclass,
                e_Differential_Operator_mmlclass,
                e_Partialdiff_mmlclass,
                e_Unary_veccalc_mmlclass,
                e_Nary_setlist_constructor_mmlclass,
                e_Nary_set_mmlclass,
                e_Binary_set_mmlclass,
                e_Nary_set_reln_mmlclass,
                e_Unary_set_mmlclass,
                e_Sum_mmlclass,
                e_Product_mmlclass,
                e_Limit_mmlclass,
                e_Unary_elementary_mmlclass,
                e_Nary_stats_mmlclass,
                e_Nary_constructor_mmlclass,
                e_Unary_linalg_mmlclass,
                e_Nary_linalg_mmlclass,
                e_Binary_linalg_mmlclass,
                e_Constant_set_mmlclass,
                e_Constant_arith_mmlclass,
                e_Semantics,
                e_Cn,
                e_Ci,
                e_Csymbol,
                e_Apply,
                e_Bind,
                e_Share,
                e_Cerror,
                e_Cbytes,
                e_Cs
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 47 ///< == e_Cs+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CPiecewise TPiecewise;
            typedef C_DeprecatedContExp TDeprecatedContExp;
            typedef C_Interval_mmlclass TInterval_mmlclass;
            typedef C_Unary_functional_mmlclass TUnary_functional_mmlclass;
            typedef C_Lambda_mmlclass TLambda_mmlclass;
            typedef C_Nary_functional_mmlclass TNary_functional_mmlclass;
            typedef C_Binary_arith_mmlclass TBinary_arith_mmlclass;
            typedef C_Unary_arith_mmlclass TUnary_arith_mmlclass;
            typedef C_Nary_minmax_mmlclass TNary_minmax_mmlclass;
            typedef C_Nary_arith_mmlclass TNary_arith_mmlclass;
            typedef C_Nary_logical_mmlclass TNary_logical_mmlclass;
            typedef C_Unary_logical_mmlclass TUnary_logical_mmlclass;
            typedef C_Binary_logical_mmlclass TBinary_logical_mmlclass;
            typedef C_Quantifier_mmlclass TQuantifier_mmlclass;
            typedef C_Nary_reln_mmlclass TNary_reln_mmlclass;
            typedef C_Binary_reln_mmlclass TBinary_reln_mmlclass;
            typedef C_Int_mmlclass TInt_mmlclass;
            typedef C_Differential_Operator_mmlclass TDifferential_Operator_mmlclass;
            typedef C_Partialdiff_mmlclass TPartialdiff_mmlclass;
            typedef C_Unary_veccalc_mmlclass TUnary_veccalc_mmlclass;
            typedef C_Nary_setlist_constructor_mmlclass TNary_setlist_constructor_mmlclass;
            typedef C_Nary_set_mmlclass TNary_set_mmlclass;
            typedef C_Binary_set_mmlclass TBinary_set_mmlclass;
            typedef C_Nary_set_reln_mmlclass TNary_set_reln_mmlclass;
            typedef C_Unary_set_mmlclass TUnary_set_mmlclass;
            typedef C_Sum_mmlclass TSum_mmlclass;
            typedef C_Product_mmlclass TProduct_mmlclass;
            typedef C_Limit_mmlclass TLimit_mmlclass;
            typedef C_Unary_elementary_mmlclass TUnary_elementary_mmlclass;
            typedef C_Nary_stats_mmlclass TNary_stats_mmlclass;
            typedef C_Nary_constructor_mmlclass TNary_constructor_mmlclass;
            typedef C_Unary_linalg_mmlclass TUnary_linalg_mmlclass;
            typedef C_Nary_linalg_mmlclass TNary_linalg_mmlclass;
            typedef C_Binary_linalg_mmlclass TBinary_linalg_mmlclass;
            typedef C_Constant_set_mmlclass TConstant_set_mmlclass;
            typedef C_Constant_arith_mmlclass TConstant_arith_mmlclass;
            typedef CSemantics TSemantics;
            typedef CCn TCn;
            typedef CCi TCi;
            typedef CCsymbol TCsymbol;
            typedef CApply TApply;
            typedef CBind TBind;
            typedef CShare TShare;
            typedef CCerror TCerror;
            typedef CCbytes TCbytes;
            typedef CCs TCs;
        
            // getters
            // setters
        
        
            /// Check if variant Piecewise is selected.
            ///
            /// Piecewise type is defined as 'typedef CPiecewise TPiecewise'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsPiecewise(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TPiecewise& GetPiecewise(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TPiecewise& SetPiecewise(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetPiecewise(TPiecewise& value);
        
        
            /// Check if variant DeprecatedContExp is selected.
            ///
            /// DeprecatedContExp type is defined as 'typedef C_DeprecatedContExp TDeprecatedContExp'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDeprecatedContExp(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDeprecatedContExp& GetDeprecatedContExp(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDeprecatedContExp& SetDeprecatedContExp(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetDeprecatedContExp(TDeprecatedContExp& value);
        
        
            /// Check if variant Interval_mmlclass is selected.
            ///
            /// Interval_mmlclass type is defined as 'typedef C_Interval_mmlclass TInterval_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsInterval_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TInterval_mmlclass& GetInterval_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TInterval_mmlclass& SetInterval_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetInterval_mmlclass(TInterval_mmlclass& value);
        
        
            /// Check if variant Unary_functional_mmlclass is selected.
            ///
            /// Unary_functional_mmlclass type is defined as 'typedef C_Unary_functional_mmlclass TUnary_functional_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_functional_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_functional_mmlclass& GetUnary_functional_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_functional_mmlclass& SetUnary_functional_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_functional_mmlclass(TUnary_functional_mmlclass& value);
        
        
            /// Check if variant Lambda_mmlclass is selected.
            ///
            /// Lambda_mmlclass type is defined as 'typedef C_Lambda_mmlclass TLambda_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLambda_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLambda_mmlclass& GetLambda_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLambda_mmlclass& SetLambda_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetLambda_mmlclass(TLambda_mmlclass& value);
        
        
            /// Check if variant Nary_functional_mmlclass is selected.
            ///
            /// Nary_functional_mmlclass type is defined as 'typedef C_Nary_functional_mmlclass TNary_functional_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_functional_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_functional_mmlclass& GetNary_functional_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_functional_mmlclass& SetNary_functional_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_functional_mmlclass(TNary_functional_mmlclass& value);
        
        
            /// Check if variant Binary_arith_mmlclass is selected.
            ///
            /// Binary_arith_mmlclass type is defined as 'typedef C_Binary_arith_mmlclass TBinary_arith_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBinary_arith_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBinary_arith_mmlclass& GetBinary_arith_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBinary_arith_mmlclass& SetBinary_arith_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBinary_arith_mmlclass(TBinary_arith_mmlclass& value);
        
        
            /// Check if variant Unary_arith_mmlclass is selected.
            ///
            /// Unary_arith_mmlclass type is defined as 'typedef C_Unary_arith_mmlclass TUnary_arith_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_arith_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_arith_mmlclass& GetUnary_arith_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_arith_mmlclass& SetUnary_arith_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_arith_mmlclass(TUnary_arith_mmlclass& value);
        
        
            /// Check if variant Nary_minmax_mmlclass is selected.
            ///
            /// Nary_minmax_mmlclass type is defined as 'typedef C_Nary_minmax_mmlclass TNary_minmax_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_minmax_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_minmax_mmlclass& GetNary_minmax_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_minmax_mmlclass& SetNary_minmax_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_minmax_mmlclass(TNary_minmax_mmlclass& value);
        
        
            /// Check if variant Nary_arith_mmlclass is selected.
            ///
            /// Nary_arith_mmlclass type is defined as 'typedef C_Nary_arith_mmlclass TNary_arith_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_arith_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_arith_mmlclass& GetNary_arith_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_arith_mmlclass& SetNary_arith_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_arith_mmlclass(TNary_arith_mmlclass& value);
        
        
            /// Check if variant Nary_logical_mmlclass is selected.
            ///
            /// Nary_logical_mmlclass type is defined as 'typedef C_Nary_logical_mmlclass TNary_logical_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_logical_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_logical_mmlclass& GetNary_logical_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_logical_mmlclass& SetNary_logical_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_logical_mmlclass(TNary_logical_mmlclass& value);
        
        
            /// Check if variant Unary_logical_mmlclass is selected.
            ///
            /// Unary_logical_mmlclass type is defined as 'typedef C_Unary_logical_mmlclass TUnary_logical_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_logical_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_logical_mmlclass& GetUnary_logical_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_logical_mmlclass& SetUnary_logical_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_logical_mmlclass(TUnary_logical_mmlclass& value);
        
        
            /// Check if variant Binary_logical_mmlclass is selected.
            ///
            /// Binary_logical_mmlclass type is defined as 'typedef C_Binary_logical_mmlclass TBinary_logical_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBinary_logical_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBinary_logical_mmlclass& GetBinary_logical_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBinary_logical_mmlclass& SetBinary_logical_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBinary_logical_mmlclass(TBinary_logical_mmlclass& value);
        
        
            /// Check if variant Quantifier_mmlclass is selected.
            ///
            /// Quantifier_mmlclass type is defined as 'typedef C_Quantifier_mmlclass TQuantifier_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsQuantifier_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TQuantifier_mmlclass& GetQuantifier_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TQuantifier_mmlclass& SetQuantifier_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetQuantifier_mmlclass(TQuantifier_mmlclass& value);
        
        
            /// Check if variant Nary_reln_mmlclass is selected.
            ///
            /// Nary_reln_mmlclass type is defined as 'typedef C_Nary_reln_mmlclass TNary_reln_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_reln_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_reln_mmlclass& GetNary_reln_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_reln_mmlclass& SetNary_reln_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_reln_mmlclass(TNary_reln_mmlclass& value);
        
        
            /// Check if variant Binary_reln_mmlclass is selected.
            ///
            /// Binary_reln_mmlclass type is defined as 'typedef C_Binary_reln_mmlclass TBinary_reln_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBinary_reln_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBinary_reln_mmlclass& GetBinary_reln_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBinary_reln_mmlclass& SetBinary_reln_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBinary_reln_mmlclass(TBinary_reln_mmlclass& value);
        
        
            /// Check if variant Int_mmlclass is selected.
            ///
            /// Int_mmlclass type is defined as 'typedef C_Int_mmlclass TInt_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsInt_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TInt_mmlclass& GetInt_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TInt_mmlclass& SetInt_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetInt_mmlclass(TInt_mmlclass& value);
        
        
            /// Check if variant Differential_Operator_mmlclass is selected.
            ///
            /// Differential_Operator_mmlclass type is defined as 'typedef C_Differential_Operator_mmlclass TDifferential_Operator_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDifferential_Operator_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDifferential_Operator_mmlclass& GetDifferential_Operator_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDifferential_Operator_mmlclass& SetDifferential_Operator_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetDifferential_Operator_mmlclass(TDifferential_Operator_mmlclass& value);
        
        
            /// Check if variant Partialdiff_mmlclass is selected.
            ///
            /// Partialdiff_mmlclass type is defined as 'typedef C_Partialdiff_mmlclass TPartialdiff_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsPartialdiff_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TPartialdiff_mmlclass& GetPartialdiff_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TPartialdiff_mmlclass& SetPartialdiff_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetPartialdiff_mmlclass(TPartialdiff_mmlclass& value);
        
        
            /// Check if variant Unary_veccalc_mmlclass is selected.
            ///
            /// Unary_veccalc_mmlclass type is defined as 'typedef C_Unary_veccalc_mmlclass TUnary_veccalc_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_veccalc_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_veccalc_mmlclass& GetUnary_veccalc_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_veccalc_mmlclass& SetUnary_veccalc_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_veccalc_mmlclass(TUnary_veccalc_mmlclass& value);
        
        
            /// Check if variant Nary_setlist_constructor_mmlclass is selected.
            ///
            /// Nary_setlist_constructor_mmlclass type is defined as 'typedef C_Nary_setlist_constructor_mmlclass TNary_setlist_constructor_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_setlist_constructor_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_setlist_constructor_mmlclass& GetNary_setlist_constructor_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_setlist_constructor_mmlclass& SetNary_setlist_constructor_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_setlist_constructor_mmlclass(TNary_setlist_constructor_mmlclass& value);
        
        
            /// Check if variant Nary_set_mmlclass is selected.
            ///
            /// Nary_set_mmlclass type is defined as 'typedef C_Nary_set_mmlclass TNary_set_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_set_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_set_mmlclass& GetNary_set_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_set_mmlclass& SetNary_set_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_set_mmlclass(TNary_set_mmlclass& value);
        
        
            /// Check if variant Binary_set_mmlclass is selected.
            ///
            /// Binary_set_mmlclass type is defined as 'typedef C_Binary_set_mmlclass TBinary_set_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBinary_set_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBinary_set_mmlclass& GetBinary_set_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBinary_set_mmlclass& SetBinary_set_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBinary_set_mmlclass(TBinary_set_mmlclass& value);
        
        
            /// Check if variant Nary_set_reln_mmlclass is selected.
            ///
            /// Nary_set_reln_mmlclass type is defined as 'typedef C_Nary_set_reln_mmlclass TNary_set_reln_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_set_reln_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_set_reln_mmlclass& GetNary_set_reln_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_set_reln_mmlclass& SetNary_set_reln_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_set_reln_mmlclass(TNary_set_reln_mmlclass& value);
        
        
            /// Check if variant Unary_set_mmlclass is selected.
            ///
            /// Unary_set_mmlclass type is defined as 'typedef C_Unary_set_mmlclass TUnary_set_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_set_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_set_mmlclass& GetUnary_set_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_set_mmlclass& SetUnary_set_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_set_mmlclass(TUnary_set_mmlclass& value);
        
        
            /// Check if variant Sum_mmlclass is selected.
            ///
            /// Sum_mmlclass type is defined as 'typedef C_Sum_mmlclass TSum_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSum_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSum_mmlclass& GetSum_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSum_mmlclass& SetSum_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetSum_mmlclass(TSum_mmlclass& value);
        
        
            /// Check if variant Product_mmlclass is selected.
            ///
            /// Product_mmlclass type is defined as 'typedef C_Product_mmlclass TProduct_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsProduct_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TProduct_mmlclass& GetProduct_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TProduct_mmlclass& SetProduct_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetProduct_mmlclass(TProduct_mmlclass& value);
        
        
            /// Check if variant Limit_mmlclass is selected.
            ///
            /// Limit_mmlclass type is defined as 'typedef C_Limit_mmlclass TLimit_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLimit_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLimit_mmlclass& GetLimit_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLimit_mmlclass& SetLimit_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetLimit_mmlclass(TLimit_mmlclass& value);
        
        
            /// Check if variant Unary_elementary_mmlclass is selected.
            ///
            /// Unary_elementary_mmlclass type is defined as 'typedef C_Unary_elementary_mmlclass TUnary_elementary_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_elementary_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_elementary_mmlclass& GetUnary_elementary_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_elementary_mmlclass& SetUnary_elementary_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_elementary_mmlclass(TUnary_elementary_mmlclass& value);
        
        
            /// Check if variant Nary_stats_mmlclass is selected.
            ///
            /// Nary_stats_mmlclass type is defined as 'typedef C_Nary_stats_mmlclass TNary_stats_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_stats_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_stats_mmlclass& GetNary_stats_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_stats_mmlclass& SetNary_stats_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_stats_mmlclass(TNary_stats_mmlclass& value);
        
        
            /// Check if variant Nary_constructor_mmlclass is selected.
            ///
            /// Nary_constructor_mmlclass type is defined as 'typedef C_Nary_constructor_mmlclass TNary_constructor_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_constructor_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_constructor_mmlclass& GetNary_constructor_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_constructor_mmlclass& SetNary_constructor_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_constructor_mmlclass(TNary_constructor_mmlclass& value);
        
        
            /// Check if variant Unary_linalg_mmlclass is selected.
            ///
            /// Unary_linalg_mmlclass type is defined as 'typedef C_Unary_linalg_mmlclass TUnary_linalg_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnary_linalg_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnary_linalg_mmlclass& GetUnary_linalg_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnary_linalg_mmlclass& SetUnary_linalg_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetUnary_linalg_mmlclass(TUnary_linalg_mmlclass& value);
        
        
            /// Check if variant Nary_linalg_mmlclass is selected.
            ///
            /// Nary_linalg_mmlclass type is defined as 'typedef C_Nary_linalg_mmlclass TNary_linalg_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNary_linalg_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNary_linalg_mmlclass& GetNary_linalg_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNary_linalg_mmlclass& SetNary_linalg_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetNary_linalg_mmlclass(TNary_linalg_mmlclass& value);
        
        
            /// Check if variant Binary_linalg_mmlclass is selected.
            ///
            /// Binary_linalg_mmlclass type is defined as 'typedef C_Binary_linalg_mmlclass TBinary_linalg_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBinary_linalg_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBinary_linalg_mmlclass& GetBinary_linalg_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBinary_linalg_mmlclass& SetBinary_linalg_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBinary_linalg_mmlclass(TBinary_linalg_mmlclass& value);
        
        
            /// Check if variant Constant_set_mmlclass is selected.
            ///
            /// Constant_set_mmlclass type is defined as 'typedef C_Constant_set_mmlclass TConstant_set_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsConstant_set_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TConstant_set_mmlclass& GetConstant_set_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TConstant_set_mmlclass& SetConstant_set_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetConstant_set_mmlclass(TConstant_set_mmlclass& value);
        
        
            /// Check if variant Constant_arith_mmlclass is selected.
            ///
            /// Constant_arith_mmlclass type is defined as 'typedef C_Constant_arith_mmlclass TConstant_arith_mmlclass'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsConstant_arith_mmlclass(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TConstant_arith_mmlclass& GetConstant_arith_mmlclass(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TConstant_arith_mmlclass& SetConstant_arith_mmlclass(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetConstant_arith_mmlclass(TConstant_arith_mmlclass& value);
        
        
            /// Check if variant Semantics is selected.
            ///
            /// Semantics type is defined as 'typedef CSemantics TSemantics'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSemantics(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSemantics& GetSemantics(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSemantics& SetSemantics(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetSemantics(TSemantics& value);
        
        
            /// Check if variant Cn is selected.
            ///
            /// Cn type is defined as 'typedef CCn TCn'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCn(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCn& GetCn(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCn& SetCn(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCn(TCn& value);
        
        
            /// Check if variant Ci is selected.
            ///
            /// Ci type is defined as 'typedef CCi TCi'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCi(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCi& GetCi(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCi& SetCi(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCi(TCi& value);
        
        
            /// Check if variant Csymbol is selected.
            ///
            /// Csymbol type is defined as 'typedef CCsymbol TCsymbol'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCsymbol(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCsymbol& GetCsymbol(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCsymbol& SetCsymbol(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCsymbol(TCsymbol& value);
        
        
            /// Check if variant Apply is selected.
            ///
            /// Apply type is defined as 'typedef CApply TApply'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsApply(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TApply& GetApply(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TApply& SetApply(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetApply(TApply& value);
        
        
            /// Check if variant Bind is selected.
            ///
            /// Bind type is defined as 'typedef CBind TBind'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsBind(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TBind& GetBind(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TBind& SetBind(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetBind(TBind& value);
        
        
            /// Check if variant Share is selected.
            ///
            /// Share type is defined as 'typedef CShare TShare'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsShare(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TShare& GetShare(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TShare& SetShare(void);
        
        
            /// Check if variant Cerror is selected.
            ///
            /// Cerror type is defined as 'typedef CCerror TCerror'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCerror(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCerror& GetCerror(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCerror& SetCerror(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCerror(TCerror& value);
        
        
            /// Check if variant Cbytes is selected.
            ///
            /// Cbytes type is defined as 'typedef CCbytes TCbytes'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCbytes(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCbytes& GetCbytes(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCbytes& SetCbytes(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCbytes(TCbytes& value);
        
        
            /// Check if variant Cs is selected.
            ///
            /// Cs type is defined as 'typedef CCs TCs'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCs(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCs& GetCs(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCs& SetCs(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetCs(TCs& value);
        
        
        private:
            // copy constructor and assignment operator
            C_E_ContExp(const C_E_ContExp& );
            C_E_ContExp& operator=(const C_E_ContExp& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        // types
        typedef C_E_ContExp C_E;
        typedef list< CRef< C_E_ContExp > > TContExp;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_ContExp
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to ContExp data member.
        ///
        /// Data member ContExp is optional;
        /// its type is defined as 'typedef list< CRef< C_E_ContExp > > TContExp'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetContExp(void) const;
    
        /// Check if it is safe to call GetContExp method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetContExp(void) const;
    
        /// Reset ContExp data member.
        void ResetContExp(void);
    
        /// Get the ContExp member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TContExp& GetContExp(void) const;
    
        /// Assign a value to ContExp data member.
        ///
        /// @return
        ///   Reference to the data value.
        TContExp& SetContExp(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_ContExp(const C_ContExp&);
        C_ContExp& operator=(const C_ContExp&);
    
        // data
        Uint4 m_set_State[1];
        list< CRef< C_E_ContExp > > m_ContExp;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_BvarQ --
    ///
    
    class C_BvarQ : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_BvarQ(void);
        // destructor
        ~C_BvarQ(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        // types
        typedef CBvar C_E;
        typedef list< CRef< CBvar > > TBvar;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_bvar
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Bvar data member.
        ///
        /// Data member Bvar is optional;
        /// its type is defined as 'typedef list< CRef< CBvar > > TBvar'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetBvar(void) const;
    
        /// Check if it is safe to call GetBvar method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetBvar(void) const;
    
        /// Reset Bvar data member.
        void ResetBvar(void);
    
        /// Get the Bvar member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TBvar& GetBvar(void) const;
    
        /// Assign a value to Bvar data member.
        ///
        /// @return
        ///   Reference to the data value.
        TBvar& SetBvar(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_BvarQ(const C_BvarQ&);
        C_BvarQ& operator=(const C_BvarQ&);
    
        // data
        Uint4 m_set_State[1];
        list< CRef< CBvar > > m_Bvar;
    };
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_Qualifier --
    ///
    
    class C_Qualifier : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_Qualifier(void);
        // destructor
        ~C_Qualifier(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_E_Qualifier --
        ///
        
        class C_E_Qualifier : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_E_Qualifier(void);
            // destructor
            ~C_E_Qualifier(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            /////////////////////////////////////////////////////////////////////////////
            ///
            /// C_DCL --
            ///
            
            class C_DCL : public CSerialObject
            {
                typedef CSerialObject Tparent;
            public:
                // constructor
                C_DCL(void);
                // destructor
                ~C_DCL(void);
            
                // type info
                DECLARE_INTERNAL_TYPE_INFO();
            
                /////////////////////////////////////////////////////////////////////////////
                ///
                /// C_LU --
                ///
                
                class C_LU : public CSerialObject
                {
                    typedef CSerialObject Tparent;
                public:
                    // constructor
                    C_LU(void);
                    // destructor
                    ~C_LU(void);
                
                    // type info
                    DECLARE_INTERNAL_TYPE_INFO();
                
                    // types
                    typedef CLowlimit TLowlimit;
                    typedef CUplimit TUplimit;
                
                    // member index
                    enum class E_memberIndex {
                        e__allMandatory = 0,
                        e_lowlimit,
                        e_uplimit
                    };
                    typedef Tparent::CMemberIndex<E_memberIndex, 3> TmemberIndex;
                
                    // getters
                    // setters
                
                    /// Check if a value has been assigned to Lowlimit data member.
                    ///
                    /// Data member Lowlimit is mandatory;
                    /// its type is defined as 'typedef CLowlimit TLowlimit'
                    /// @return
                    ///   - true, if a value has been assigned.
                    ///   - false, otherwise.
                    bool IsSetLowlimit(void) const;
                
                    /// Check if it is safe to call GetLowlimit method.
                    ///
                    /// @return
                    ///   - true, if the data member is getatable.
                    ///   - false, otherwise.
                    bool CanGetLowlimit(void) const;
                
                    /// Reset Lowlimit data member.
                    void ResetLowlimit(void);
                
                    /// Get the Lowlimit member data.
                    ///
                    /// @return
                    ///   Reference to the member data.
                    const TLowlimit& GetLowlimit(void) const;
                
                    /// Assign a value to Lowlimit data member.
                    ///
                    /// @param value
                    ///   Reference to value.
                    void SetLowlimit(TLowlimit& value);
                
                    /// Assign a value to Lowlimit data member.
                    ///
                    /// @return
                    ///   Reference to the data value.
                    TLowlimit& SetLowlimit(void);
                
                    /// Check if a value has been assigned to Uplimit data member.
                    ///
                    /// Data member Uplimit is optional;
                    /// its type is defined as 'typedef CUplimit TUplimit'
                    /// @return
                    ///   - true, if a value has been assigned.
                    ///   - false, otherwise.
                    bool IsSetUplimit(void) const;
                
                    /// Check if it is safe to call GetUplimit method.
                    ///
                    /// @return
                    ///   - true, if the data member is getatable.
                    ///   - false, otherwise.
                    bool CanGetUplimit(void) const;
                
                    /// Reset Uplimit data member.
                    void ResetUplimit(void);
                
                    /// Get the Uplimit member data.
                    ///
                    /// @return
                    ///   Reference to the member data.
                    const TUplimit& GetUplimit(void) const;
                
                    /// Assign a value to Uplimit data member.
                    ///
                    /// @param value
                    ///   Reference to value.
                    void SetUplimit(TUplimit& value);
                
                    /// Assign a value to Uplimit data member.
                    ///
                    /// @return
                    ///   Reference to the data value.
                    TUplimit& SetUplimit(void);
                
                    /// Reset the whole object
                    void Reset(void);
                
                
                private:
                    // Prohibit copy constructor and assignment operator
                    C_LU(const C_LU&);
                    C_LU& operator=(const C_LU&);
                
                    // data
                    Uint4 m_set_State[1];
                    CRef< TLowlimit > m_Lowlimit;
                    CRef< TUplimit > m_Uplimit;
                };
            
                /// Choice variants.
                enum E_Choice {
                    e_not_set = 0,          ///< No variant selected
                    e_Domainofapplication,
                    e_Condition,
                    e_LU
                };
                /// Maximum+1 value of the choice variant enumerator.
                enum E_ChoiceStopper {
                    e_MaxChoice = 4 ///< == e_LU+1
                };
            
                /// Reset the whole object
                void Reset(void);
            
                /// Reset the selection (set it to e_not_set).
                void ResetSelection(void);
            
                /// Which variant is currently selected.
                ///
                /// @return
                ///   Choice state enumerator.
                E_Choice Which(void) const;
            
                /// Verify selection, throw exception if it differs from the expected.
                ///
                /// @param index
                ///   Expected selection.
                void CheckSelected(E_Choice index) const;
            
                /// Throw 'InvalidSelection' exception.
                ///
                /// @param index
                ///   Expected selection.
                NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
            
                /// Retrieve selection name (for diagnostic purposes).
                ///
                /// @param index
                ///   One of possible selection states.
                /// @return
                ///   Name string.
                static string SelectionName(E_Choice index);
            
                /// Select the requested variant if needed.
                ///
                /// @param index
                ///   New selection state.
                /// @param reset
                ///   Flag that defines the resetting of the variant data. The data will
                ///   be reset if either the current selection differs from the new one,
                ///   or the flag is set to eDoResetVariant.
                void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
                /// Select the requested variant if needed,
                /// allocating CObject variants from memory pool.
                void Select(E_Choice index,
                            EResetVariant reset,
                            CObjectMemoryPool* pool);
            
                // types
                typedef CDomainofapplication TDomainofapplication;
                typedef CCondition TCondition;
                typedef C_LU TLU;
            
                // getters
                // setters
            
            
                /// Check if variant Domainofapplication is selected.
                ///
                /// Domainofapplication type is defined as 'typedef CDomainofapplication TDomainofapplication'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsDomainofapplication(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TDomainofapplication& GetDomainofapplication(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TDomainofapplication& SetDomainofapplication(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetDomainofapplication(TDomainofapplication& value);
            
            
                /// Check if variant Condition is selected.
                ///
                /// Condition type is defined as 'typedef CCondition TCondition'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsCondition(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TCondition& GetCondition(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TCondition& SetCondition(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetCondition(TCondition& value);
            
            
                /// Check if variant LU is selected.
                ///
                /// LU type is defined as 'typedef C_LU TLU'.
                /// @return
                ///   - true, if the variant is selected.
                ///   - false, otherwise.
                bool IsLU(void) const;
            
                /// Get the variant data.
                ///
                /// @return
                ///   Reference to the data.
                const TLU& GetLU(void) const;
            
                /// Select the variant.
                ///
                /// @return
                ///   Reference to the variant data.
                TLU& SetLU(void);
                /// Select the variant and set its data.
                ///
                /// @param value
                ///   Reference to the data.
                void SetLU(TLU& value);
            
            
            private:
                // copy constructor and assignment operator
                C_DCL(const C_DCL& );
                C_DCL& operator=(const C_DCL& );
                // choice state
                E_Choice m_choice;
                // helper methods
                void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
            
                static const char* const sm_SelectionNames[];
                // data
                NCBI_NS_NCBI::CSerialObject *m_object;
            };
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_DCL,
                e_Degree,
                e_Momentabout,
                e_Logbase
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 5 ///< == e_Logbase+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef C_DCL TDCL;
            typedef CDegree TDegree;
            typedef CMomentabout TMomentabout;
            typedef CLogbase TLogbase;
        
            // getters
            // setters
        
        
            /// Check if variant DCL is selected.
            ///
            /// DCL type is defined as 'typedef C_DCL TDCL'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDCL(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDCL& GetDCL(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDCL& SetDCL(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetDCL(TDCL& value);
        
        
            /// Check if variant Degree is selected.
            ///
            /// Degree type is defined as 'typedef CDegree TDegree'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDegree(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDegree& GetDegree(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDegree& SetDegree(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetDegree(TDegree& value);
        
        
            /// Check if variant Momentabout is selected.
            ///
            /// Momentabout type is defined as 'typedef CMomentabout TMomentabout'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMomentabout(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMomentabout& GetMomentabout(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMomentabout& SetMomentabout(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetMomentabout(TMomentabout& value);
        
        
            /// Check if variant Logbase is selected.
            ///
            /// Logbase type is defined as 'typedef CLogbase TLogbase'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLogbase(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLogbase& GetLogbase(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLogbase& SetLogbase(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetLogbase(TLogbase& value);
        
        
        private:
            // copy constructor and assignment operator
            C_E_Qualifier(const C_E_Qualifier& );
            C_E_Qualifier& operator=(const C_E_Qualifier& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        // types
        typedef C_E_Qualifier C_E;
        typedef list< CRef< C_E_Qualifier > > TQualifier;
    
        // member index
        enum class E_memberIndex {
            e__allMandatory = 0,
            e_Qualifier
        };
        typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
    
        // getters
        // setters
    
        /// Check if a value has been assigned to Qualifier data member.
        ///
        /// Data member Qualifier is optional;
        /// its type is defined as 'typedef list< CRef< C_E_Qualifier > > TQualifier'
        /// @return
        ///   - true, if a value has been assigned.
        ///   - false, otherwise.
        bool IsSetQualifier(void) const;
    
        /// Check if it is safe to call GetQualifier method.
        ///
        /// @return
        ///   - true, if the data member is getatable.
        ///   - false, otherwise.
        bool CanGetQualifier(void) const;
    
        /// Reset Qualifier data member.
        void ResetQualifier(void);
    
        /// Get the Qualifier member data.
        ///
        /// @return
        ///   Reference to the member data.
        const TQualifier& GetQualifier(void) const;
    
        /// Assign a value to Qualifier data member.
        ///
        /// @return
        ///   Reference to the data value.
        TQualifier& SetQualifier(void);
    
        /// Reset the whole object
        void Reset(void);
    
    
    private:
        // Prohibit copy constructor and assignment operator
        C_Qualifier(const C_Qualifier&);
        C_Qualifier& operator=(const C_Qualifier&);
    
        // data
        Uint4 m_set_State[1];
        list< CRef< C_E_Qualifier > > m_Qualifier;
    };
    // types
    typedef C_ContExp TContExp;
    typedef C_BvarQ TBvarQ;
    typedef C_Qualifier TQualifier;
 
    // member index
    enum class E_memberIndex {
        e__allMandatory = 0,
        e_ContExp,
        e_BvarQ,
        e_Qualifier
    };
    typedef Tparent::CMemberIndex<E_memberIndex, 4> TmemberIndex;
 
    // getters
    // setters
 
    /// Check if a value has been assigned to ContExp data member.
    ///
    /// Data member ContExp is optional;
    /// its type is defined as 'typedef C_ContExp TContExp'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetContExp(void) const;
 
    /// Check if it is safe to call GetContExp method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetContExp(void) const;
 
    /// Reset ContExp data member.
    void ResetContExp(void);
 
    /// Get the ContExp member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TContExp& GetContExp(void) const;
 
    /// Assign a value to ContExp data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetContExp(TContExp& value);
 
    /// Assign a value to ContExp data member.
    ///
    /// @return
    ///   Reference to the data value.
    TContExp& SetContExp(void);
 
    /// Check if a value has been assigned to BvarQ data member.
    ///
    /// Data member BvarQ is mandatory;
    /// its type is defined as 'typedef C_BvarQ TBvarQ'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetBvarQ(void) const;
 
    /// Check if it is safe to call GetBvarQ method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetBvarQ(void) const;
 
    /// Reset BvarQ data member.
    void ResetBvarQ(void);
 
    /// Get the BvarQ member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TBvarQ& GetBvarQ(void) const;
 
    /// Assign a value to BvarQ data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetBvarQ(TBvarQ& value);
 
    /// Assign a value to BvarQ data member.
    ///
    /// @return
    ///   Reference to the data value.
    TBvarQ& SetBvarQ(void);
 
    /// Check if a value has been assigned to Qualifier data member.
    ///
    /// Data member Qualifier is optional;
    /// its type is defined as 'typedef C_Qualifier TQualifier'
    /// @return
    ///   - true, if a value has been assigned.
    ///   - false, otherwise.
    bool IsSetQualifier(void) const;
 
    /// Check if it is safe to call GetQualifier method.
    ///
    /// @return
    ///   - true, if the data member is getatable.
    ///   - false, otherwise.
    bool CanGetQualifier(void) const;
 
    /// Reset Qualifier data member.
    void ResetQualifier(void);
 
    /// Get the Qualifier member data.
    ///
    /// @return
    ///   Reference to the member data.
    const TQualifier& GetQualifier(void) const;
 
    /// Assign a value to Qualifier data member.
    ///
    /// @param value
    ///   Reference to value.
    void SetQualifier(TQualifier& value);
 
    /// Assign a value to Qualifier data member.
    ///
    /// @return
    ///   Reference to the data value.
    TQualifier& SetQualifier(void);
 
    /// Reset the whole object
    virtual void Reset(void);
 
 
private:
    // Prohibit copy constructor and assignment operator
    CBind_content_Base(const CBind_content_Base&);
    CBind_content_Base& operator=(const CBind_content_Base&);
 
    // data
    Uint4 m_set_State[1];
    CRef< TContExp > m_ContExp;
    CRef< TBvarQ > m_BvarQ;
    CRef< TQualifier > m_Qualifier;
};
 
/* @} */
 
 
 
 
 
///////////////////////////////////////////////////////////
///////////////////// inline methods //////////////////////
///////////////////////////////////////////////////////////
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::IsReln(void) const
{
    return m_choice == e_Reln;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::IsFn(void) const
{
    return m_choice == e_Fn;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_DeprecatedContExp::IsDeclare(void) const
{
    return m_choice == e_Declare;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::IsSetInterval(void) const
{
    return m_Interval.NotEmpty();
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::CanGetInterval(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::TInterval& CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::GetInterval(void) const
{
    if ( !m_Interval ) {
        const_cast<C_Interval_mmlclass*>(this)->ResetInterval();
    }
    return (*m_Interval);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::TInterval& CBind_content_Base::C_ContExp::C_E_ContExp::C_Interval_mmlclass::SetInterval(void)
{
    if ( !m_Interval ) {
        ResetInterval();
    }
    return (*m_Interval);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsInverse(void) const
{
    return m_choice == e_Inverse;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsIdent(void) const
{
    return m_choice == e_Ident;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsDomain(void) const
{
    return m_choice == e_Domain;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsCodomain(void) const
{
    return m_choice == e_Codomain;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsImage(void) const
{
    return m_choice == e_Image;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsLn(void) const
{
    return m_choice == e_Ln;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsLog(void) const
{
    return m_choice == e_Log;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_functional_mmlclass::IsMoment(void) const
{
    return m_choice == e_Moment;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::IsSetLambda(void) const
{
    return m_Lambda.NotEmpty();
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::CanGetLambda(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::TLambda& CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::GetLambda(void) const
{
    if ( !m_Lambda ) {
        const_cast<C_Lambda_mmlclass*>(this)->ResetLambda();
    }
    return (*m_Lambda);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::TLambda& CBind_content_Base::C_ContExp::C_E_ContExp::C_Lambda_mmlclass::SetLambda(void)
{
    if ( !m_Lambda ) {
        ResetLambda();
    }
    return (*m_Lambda);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_functional_mmlclass::CanGetCompose(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_functional_mmlclass::TCompose& CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_functional_mmlclass::GetCompose(void) const
{
    if ( !m_Compose ) {
        const_cast<C_Nary_functional_mmlclass*>(this)->ResetCompose();
    }
    return (*m_Compose);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsQuotient(void) const
{
    return m_choice == e_Quotient;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsDivide(void) const
{
    return m_choice == e_Divide;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsMinus(void) const
{
    return m_choice == e_Minus;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsPower(void) const
{
    return m_choice == e_Power;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsRem(void) const
{
    return m_choice == e_Rem;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_arith_mmlclass::IsRoot(void) const
{
    return m_choice == e_Root;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsFactorial(void) const
{
    return m_choice == e_Factorial;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsAbs(void) const
{
    return m_choice == e_Abs;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsConjugate(void) const
{
    return m_choice == e_Conjugate;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsArg(void) const
{
    return m_choice == e_Arg;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsReal(void) const
{
    return m_choice == e_Real;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsImaginary(void) const
{
    return m_choice == e_Imaginary;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsFloor(void) const
{
    return m_choice == e_Floor;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsCeiling(void) const
{
    return m_choice == e_Ceiling;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_arith_mmlclass::IsExp(void) const
{
    return m_choice == e_Exp;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::IsMax(void) const
{
    return m_choice == e_Max;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_minmax_mmlclass::IsMin(void) const
{
    return m_choice == e_Min;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::IsPlus(void) const
{
    return m_choice == e_Plus;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::IsTimes(void) const
{
    return m_choice == e_Times;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::IsGcd(void) const
{
    return m_choice == e_Gcd;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_arith_mmlclass::IsLcm(void) const
{
    return m_choice == e_Lcm;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::IsAnd(void) const
{
    return m_choice == e_And;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::IsOr(void) const
{
    return m_choice == e_Or;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_logical_mmlclass::IsXor(void) const
{
    return m_choice == e_Xor;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_logical_mmlclass::CanGetNot(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_logical_mmlclass::TNot& CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_logical_mmlclass::GetNot(void) const
{
    if ( !m_Not ) {
        const_cast<C_Unary_logical_mmlclass*>(this)->ResetNot();
    }
    return (*m_Not);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::IsImplies(void) const
{
    return m_choice == e_Implies;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_logical_mmlclass::IsEquivalent(void) const
{
    return m_choice == e_Equivalent;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::IsForall(void) const
{
    return m_choice == e_Forall;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Quantifier_mmlclass::IsExists(void) const
{
    return m_choice == e_Exists;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::IsEq(void) const
{
    return m_choice == e_Eq;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::IsGt(void) const
{
    return m_choice == e_Gt;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::IsLt(void) const
{
    return m_choice == e_Lt;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::IsGeq(void) const
{
    return m_choice == e_Geq;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_reln_mmlclass::IsLeq(void) const
{
    return m_choice == e_Leq;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::IsNeq(void) const
{
    return m_choice == e_Neq;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::IsApprox(void) const
{
    return m_choice == e_Approx;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::IsFactorof(void) const
{
    return m_choice == e_Factorof;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_reln_mmlclass::IsTendsto(void) const
{
    return m_choice == e_Tendsto;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Int_mmlclass::CanGetInt(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Int_mmlclass::TInt& CBind_content_Base::C_ContExp::C_E_ContExp::C_Int_mmlclass::GetInt(void) const
{
    if ( !m_Int ) {
        const_cast<C_Int_mmlclass*>(this)->ResetInt();
    }
    return (*m_Int);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Differential_Operator_mmlclass::CanGetDiff(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Differential_Operator_mmlclass::TDiff& CBind_content_Base::C_ContExp::C_E_ContExp::C_Differential_Operator_mmlclass::GetDiff(void) const
{
    if ( !m_Diff ) {
        const_cast<C_Differential_Operator_mmlclass*>(this)->ResetDiff();
    }
    return (*m_Diff);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Partialdiff_mmlclass::CanGetPartialdiff(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Partialdiff_mmlclass::TPartialdiff& CBind_content_Base::C_ContExp::C_E_ContExp::C_Partialdiff_mmlclass::GetPartialdiff(void) const
{
    if ( !m_Partialdiff ) {
        const_cast<C_Partialdiff_mmlclass*>(this)->ResetPartialdiff();
    }
    return (*m_Partialdiff);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::IsDivergence(void) const
{
    return m_choice == e_Divergence;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::IsGrad(void) const
{
    return m_choice == e_Grad;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::IsCurl(void) const
{
    return m_choice == e_Curl;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_veccalc_mmlclass::IsLaplacian(void) const
{
    return m_choice == e_Laplacian;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::IsSet(void) const
{
    return m_choice == e_Set;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_setlist_constructor_mmlclass::IsList(void) const
{
    return m_choice == e_List;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::IsUnion(void) const
{
    return m_choice == e_Union;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::IsIntersect(void) const
{
    return m_choice == e_Intersect;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_mmlclass::IsCartesianproduct(void) const
{
    return m_choice == e_Cartesianproduct;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::IsIn(void) const
{
    return m_choice == e_In;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::IsNotin(void) const
{
    return m_choice == e_Notin;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::IsNotsubset(void) const
{
    return m_choice == e_Notsubset;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::IsNotprsubset(void) const
{
    return m_choice == e_Notprsubset;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_set_mmlclass::IsSetdiff(void) const
{
    return m_choice == e_Setdiff;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::IsSubset(void) const
{
    return m_choice == e_Subset;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_set_reln_mmlclass::IsPrsubset(void) const
{
    return m_choice == e_Prsubset;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_set_mmlclass::CanGetCard(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_set_mmlclass::TCard& CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_set_mmlclass::GetCard(void) const
{
    if ( !m_Card ) {
        const_cast<C_Unary_set_mmlclass*>(this)->ResetCard();
    }
    return (*m_Card);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Sum_mmlclass::CanGetSum(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Sum_mmlclass::TSum& CBind_content_Base::C_ContExp::C_E_ContExp::C_Sum_mmlclass::GetSum(void) const
{
    if ( !m_Sum ) {
        const_cast<C_Sum_mmlclass*>(this)->ResetSum();
    }
    return (*m_Sum);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Product_mmlclass::CanGetProduct(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Product_mmlclass::TProduct& CBind_content_Base::C_ContExp::C_E_ContExp::C_Product_mmlclass::GetProduct(void) const
{
    if ( !m_Product ) {
        const_cast<C_Product_mmlclass*>(this)->ResetProduct();
    }
    return (*m_Product);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Limit_mmlclass::CanGetLimit(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Limit_mmlclass::TLimit& CBind_content_Base::C_ContExp::C_E_ContExp::C_Limit_mmlclass::GetLimit(void) const
{
    if ( !m_Limit ) {
        const_cast<C_Limit_mmlclass*>(this)->ResetLimit();
    }
    return (*m_Limit);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsSin(void) const
{
    return m_choice == e_Sin;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCos(void) const
{
    return m_choice == e_Cos;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsTan(void) const
{
    return m_choice == e_Tan;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsSec(void) const
{
    return m_choice == e_Sec;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCsc(void) const
{
    return m_choice == e_Csc;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCot(void) const
{
    return m_choice == e_Cot;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsSinh(void) const
{
    return m_choice == e_Sinh;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCosh(void) const
{
    return m_choice == e_Cosh;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsTanh(void) const
{
    return m_choice == e_Tanh;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsSech(void) const
{
    return m_choice == e_Sech;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCsch(void) const
{
    return m_choice == e_Csch;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsCoth(void) const
{
    return m_choice == e_Coth;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArcsin(void) const
{
    return m_choice == e_Arcsin;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccos(void) const
{
    return m_choice == e_Arccos;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArctan(void) const
{
    return m_choice == e_Arctan;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccosh(void) const
{
    return m_choice == e_Arccosh;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccot(void) const
{
    return m_choice == e_Arccot;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccoth(void) const
{
    return m_choice == e_Arccoth;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccsc(void) const
{
    return m_choice == e_Arccsc;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArccsch(void) const
{
    return m_choice == e_Arccsch;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArcsec(void) const
{
    return m_choice == e_Arcsec;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArcsech(void) const
{
    return m_choice == e_Arcsech;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArcsinh(void) const
{
    return m_choice == e_Arcsinh;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_elementary_mmlclass::IsArctanh(void) const
{
    return m_choice == e_Arctanh;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::IsMean(void) const
{
    return m_choice == e_Mean;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::IsSdev(void) const
{
    return m_choice == e_Sdev;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::IsVariance(void) const
{
    return m_choice == e_Variance;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::IsMedian(void) const
{
    return m_choice == e_Median;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_stats_mmlclass::IsMode(void) const
{
    return m_choice == e_Mode;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::IsVector(void) const
{
    return m_choice == e_Vector;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::IsMatrix(void) const
{
    return m_choice == e_Matrix;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_constructor_mmlclass::IsMatrixrow(void) const
{
    return m_choice == e_Matrixrow;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::IsDeterminant(void) const
{
    return m_choice == e_Determinant;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Unary_linalg_mmlclass::IsTranspose(void) const
{
    return m_choice == e_Transpose;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_linalg_mmlclass::CanGetSelector(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_linalg_mmlclass::TSelector& CBind_content_Base::C_ContExp::C_E_ContExp::C_Nary_linalg_mmlclass::GetSelector(void) const
{
    if ( !m_Selector ) {
        const_cast<C_Nary_linalg_mmlclass*>(this)->ResetSelector();
    }
    return (*m_Selector);
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::IsVectorproduct(void) const
{
    return m_choice == e_Vectorproduct;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::IsScalarproduct(void) const
{
    return m_choice == e_Scalarproduct;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Binary_linalg_mmlclass::IsOuterproduct(void) const
{
    return m_choice == e_Outerproduct;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsIntegers(void) const
{
    return m_choice == e_Integers;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsReals(void) const
{
    return m_choice == e_Reals;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsRationals(void) const
{
    return m_choice == e_Rationals;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsNaturalnumbers(void) const
{
    return m_choice == e_Naturalnumbers;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsComplexes(void) const
{
    return m_choice == e_Complexes;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsPrimes(void) const
{
    return m_choice == e_Primes;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_set_mmlclass::IsEmptyset(void) const
{
    return m_choice == e_Emptyset;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsExponentiale(void) const
{
    return m_choice == e_Exponentiale;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsImaginaryi(void) const
{
    return m_choice == e_Imaginaryi;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsNotanumber(void) const
{
    return m_choice == e_Notanumber;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsTrue(void) const
{
    return m_choice == e_True;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsFalse(void) const
{
    return m_choice == e_False;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsPi(void) const
{
    return m_choice == e_Pi;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsEulergamma(void) const
{
    return m_choice == e_Eulergamma;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::C_Constant_arith_mmlclass::IsInfinity(void) const
{
    return m_choice == e_Infinity;
}
 
inline
CBind_content_Base::C_ContExp::C_E_ContExp::E_Choice CBind_content_Base::C_ContExp::C_E_ContExp::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_ContExp::C_E_ContExp::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsPiecewise(void) const
{
    return m_choice == e_Piecewise;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsDeprecatedContExp(void) const
{
    return m_choice == e_DeprecatedContExp;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsInterval_mmlclass(void) const
{
    return m_choice == e_Interval_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_functional_mmlclass(void) const
{
    return m_choice == e_Unary_functional_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsLambda_mmlclass(void) const
{
    return m_choice == e_Lambda_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_functional_mmlclass(void) const
{
    return m_choice == e_Nary_functional_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBinary_arith_mmlclass(void) const
{
    return m_choice == e_Binary_arith_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_arith_mmlclass(void) const
{
    return m_choice == e_Unary_arith_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_minmax_mmlclass(void) const
{
    return m_choice == e_Nary_minmax_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_arith_mmlclass(void) const
{
    return m_choice == e_Nary_arith_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_logical_mmlclass(void) const
{
    return m_choice == e_Nary_logical_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_logical_mmlclass(void) const
{
    return m_choice == e_Unary_logical_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBinary_logical_mmlclass(void) const
{
    return m_choice == e_Binary_logical_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsQuantifier_mmlclass(void) const
{
    return m_choice == e_Quantifier_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_reln_mmlclass(void) const
{
    return m_choice == e_Nary_reln_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBinary_reln_mmlclass(void) const
{
    return m_choice == e_Binary_reln_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsInt_mmlclass(void) const
{
    return m_choice == e_Int_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsDifferential_Operator_mmlclass(void) const
{
    return m_choice == e_Differential_Operator_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsPartialdiff_mmlclass(void) const
{
    return m_choice == e_Partialdiff_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_veccalc_mmlclass(void) const
{
    return m_choice == e_Unary_veccalc_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_setlist_constructor_mmlclass(void) const
{
    return m_choice == e_Nary_setlist_constructor_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_set_mmlclass(void) const
{
    return m_choice == e_Nary_set_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBinary_set_mmlclass(void) const
{
    return m_choice == e_Binary_set_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_set_reln_mmlclass(void) const
{
    return m_choice == e_Nary_set_reln_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_set_mmlclass(void) const
{
    return m_choice == e_Unary_set_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsSum_mmlclass(void) const
{
    return m_choice == e_Sum_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsProduct_mmlclass(void) const
{
    return m_choice == e_Product_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsLimit_mmlclass(void) const
{
    return m_choice == e_Limit_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_elementary_mmlclass(void) const
{
    return m_choice == e_Unary_elementary_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_stats_mmlclass(void) const
{
    return m_choice == e_Nary_stats_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_constructor_mmlclass(void) const
{
    return m_choice == e_Nary_constructor_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsUnary_linalg_mmlclass(void) const
{
    return m_choice == e_Unary_linalg_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsNary_linalg_mmlclass(void) const
{
    return m_choice == e_Nary_linalg_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBinary_linalg_mmlclass(void) const
{
    return m_choice == e_Binary_linalg_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsConstant_set_mmlclass(void) const
{
    return m_choice == e_Constant_set_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsConstant_arith_mmlclass(void) const
{
    return m_choice == e_Constant_arith_mmlclass;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsSemantics(void) const
{
    return m_choice == e_Semantics;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCn(void) const
{
    return m_choice == e_Cn;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCi(void) const
{
    return m_choice == e_Ci;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCsymbol(void) const
{
    return m_choice == e_Csymbol;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsApply(void) const
{
    return m_choice == e_Apply;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsBind(void) const
{
    return m_choice == e_Bind;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsShare(void) const
{
    return m_choice == e_Share;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCerror(void) const
{
    return m_choice == e_Cerror;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCbytes(void) const
{
    return m_choice == e_Cbytes;
}
 
inline
bool CBind_content_Base::C_ContExp::C_E_ContExp::IsCs(void) const
{
    return m_choice == e_Cs;
}
 
inline
bool CBind_content_Base::C_ContExp::IsSetContExp(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CBind_content_Base::C_ContExp::CanGetContExp(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_ContExp::TContExp& CBind_content_Base::C_ContExp::GetContExp(void) const
{
    return m_ContExp;
}
 
inline
CBind_content_Base::C_ContExp::TContExp& CBind_content_Base::C_ContExp::SetContExp(void)
{
    m_set_State[0] |= 0x1;
    return m_ContExp;
}
 
inline
bool CBind_content_Base::C_BvarQ::IsSetBvar(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CBind_content_Base::C_BvarQ::CanGetBvar(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_BvarQ::TBvar& CBind_content_Base::C_BvarQ::GetBvar(void) const
{
    return m_Bvar;
}
 
inline
CBind_content_Base::C_BvarQ::TBvar& CBind_content_Base::C_BvarQ::SetBvar(void)
{
    m_set_State[0] |= 0x1;
    return m_Bvar;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::IsSetLowlimit(void) const
{
    return m_Lowlimit.NotEmpty();
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::CanGetLowlimit(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::TLowlimit& CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::GetLowlimit(void) const
{
    if ( !m_Lowlimit ) {
        const_cast<C_LU*>(this)->ResetLowlimit();
    }
    return (*m_Lowlimit);
}
 
inline
CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::TLowlimit& CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::SetLowlimit(void)
{
    if ( !m_Lowlimit ) {
        ResetLowlimit();
    }
    return (*m_Lowlimit);
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::IsSetUplimit(void) const
{
    return m_Uplimit.NotEmpty();
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::CanGetUplimit(void) const
{
    return IsSetUplimit();
}
 
inline
const CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::TUplimit& CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::C_LU::GetUplimit(void) const
{
    if (!CanGetUplimit()) {
        ThrowUnassigned(1);
    }
    return (*m_Uplimit);
}
 
inline
CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::E_Choice CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::IsDomainofapplication(void) const
{
    return m_choice == e_Domainofapplication;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::IsCondition(void) const
{
    return m_choice == e_Condition;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::C_DCL::IsLU(void) const
{
    return m_choice == e_LU;
}
 
inline
CBind_content_Base::C_Qualifier::C_E_Qualifier::E_Choice CBind_content_Base::C_Qualifier::C_E_Qualifier::Which(void) const
{
    return m_choice;
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::CheckSelected(E_Choice index) const
{
    if ( m_choice != index )
        ThrowInvalidSelection(index);
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset, NCBI_NS_NCBI::CObjectMemoryPool* pool)
{
    if ( reset == NCBI_NS_NCBI::eDoResetVariant || m_choice != index ) {
        if ( m_choice != e_not_set )
            ResetSelection();
        DoSelect(index, pool);
    }
}
 
inline
void CBind_content_Base::C_Qualifier::C_E_Qualifier::Select(E_Choice index, NCBI_NS_NCBI::EResetVariant reset)
{
    Select(index, reset, 0);
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::IsDCL(void) const
{
    return m_choice == e_DCL;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::IsDegree(void) const
{
    return m_choice == e_Degree;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::IsMomentabout(void) const
{
    return m_choice == e_Momentabout;
}
 
inline
bool CBind_content_Base::C_Qualifier::C_E_Qualifier::IsLogbase(void) const
{
    return m_choice == e_Logbase;
}
 
inline
bool CBind_content_Base::C_Qualifier::IsSetQualifier(void) const
{
    return ((m_set_State[0] & 0x3) != 0);
}
 
inline
bool CBind_content_Base::C_Qualifier::CanGetQualifier(void) const
{
    return true;
}
 
inline
const CBind_content_Base::C_Qualifier::TQualifier& CBind_content_Base::C_Qualifier::GetQualifier(void) const
{
    return m_Qualifier;
}
 
inline
CBind_content_Base::C_Qualifier::TQualifier& CBind_content_Base::C_Qualifier::SetQualifier(void)
{
    m_set_State[0] |= 0x1;
    return m_Qualifier;
}
 
inline
bool CBind_content_Base::IsSetContExp(void) const
{
    return m_ContExp.NotEmpty();
}
 
inline
bool CBind_content_Base::CanGetContExp(void) const
{
    return IsSetContExp();
}
 
inline
const CBind_content_Base::TContExp& CBind_content_Base::GetContExp(void) const
{
    if (!CanGetContExp()) {
        ThrowUnassigned(0);
    }
    return (*m_ContExp);
}
 
inline
bool CBind_content_Base::IsSetBvarQ(void) const
{
    return m_BvarQ.NotEmpty();
}
 
inline
bool CBind_content_Base::CanGetBvarQ(void) const
{
    return true;
}
 
inline
const CBind_content_Base::TBvarQ& CBind_content_Base::GetBvarQ(void) const
{
    if ( !m_BvarQ ) {
        const_cast<CBind_content_Base*>(this)->ResetBvarQ();
    }
    return (*m_BvarQ);
}
 
inline
CBind_content_Base::TBvarQ& CBind_content_Base::SetBvarQ(void)
{
    if ( !m_BvarQ ) {
        ResetBvarQ();
    }
    return (*m_BvarQ);
}
 
inline
bool CBind_content_Base::IsSetQualifier(void) const
{
    return m_Qualifier.NotEmpty();
}
 
inline
bool CBind_content_Base::CanGetQualifier(void) const
{
    return IsSetQualifier();
}
 
inline
const CBind_content_Base::TQualifier& CBind_content_Base::GetQualifier(void) const
{
    if (!CanGetQualifier()) {
        ThrowUnassigned(2);
    }
    return (*m_Qualifier);
}
 
///////////////////////////////////////////////////////////
////////////////// end of inline methods //////////////////
///////////////////////////////////////////////////////////
 
 
 
 
 
END_objects_SCOPE // namespace ncbi::objects::
 
END_NCBI_SCOPE
 
 
#endif // OBJTOOLS_EUTILS_EFETCH_BIND_CONTENT_BASE_HPP