ImpliedMrow_.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 ImpliedMrow_.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_IMPLIEDMROW_BASE_HPP
#define OBJTOOLS_EUTILS_EFETCH_IMPLIEDMROW_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 CCard;
class CCartesianproduct;
class CCbytes;
class CCeiling;
class CCerror;
class CCi;
class CCn;
class CCodomain;
class CComplexes;
class CCompose;
class CConjugate;
class CCos;
class CCosh;
class CCot;
class CCoth;
class CCs;
class CCsc;
class CCsch;
class CCsymbol;
class CCurl;
class CDeclare;
class CDeterminant;
class CDiff;
class CDivergence;
class CDivide;
class CDomain;
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 CLt;
class CMaction;
class CMaligngroup;
class CMalignmark;
class CMatrix;
class CMatrixrow;
class CMax;
class CMean;
class CMedian;
class CMenclose;
class CMerror;
class CMfenced;
class CMfrac;
class CMi;
class CMin;
class CMinus;
class CMlongdiv;
class CMmultiscripts;
class CMn;
class CMo;
class CMode;
class CMoment;
class CMover;
class CMpadded;
class CMphantom;
class CMroot;
class CMrow;
class CMs;
class CMspace;
class CMsqrt;
class CMstack;
class CMstyle;
class CMsub;
class CMsubsup;
class CMsup;
class CMtable;
class CMtext;
class CMunder;
class CMunderover;
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 CVariance;
class CVector;
class CVectorproduct;
class CXor;
 
 
// generated classes
 
 
/** @addtogroup dataspec_pubmed_mathml3
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///
/// CImpliedMrow_Base --
///
 
class CImpliedMrow_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CImpliedMrow_Base(void);
    // destructor
    virtual ~CImpliedMrow_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_E --
    ///
    
    class C_E : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_E(void);
        // destructor
        ~C_E(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_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();