MathExpression_.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 MathExpression_.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_MATHEXPRESSION_BASE_HPP
#define OBJTOOLS_EUTILS_EFETCH_MATHEXPRESSION_BASE_HPP
 
// standard includes
#include <serial/serialbase.hpp>
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
 *
 * @{
 */
 
/////////////////////////////////////////////////////////////////////////////
///
/// CMathExpression_Base --
///
 
class CMathExpression_Base : public CSerialObject
{
    typedef CSerialObject Tparent;
public:
    // constructor
    CMathExpression_Base(void);
    // destructor
    virtual ~CMathExpression_Base(void);
 
    // type info
    DECLARE_INTERNAL_TYPE_INFO();
 
    /////////////////////////////////////////////////////////////////////////////
    ///
    /// C_ContExp --
    ///
    
    class C_ContExp : public CSerialObject
    {
        typedef CSerialObject Tparent;
    public:
        // constructor
        C_ContExp(void);
        // destructor
        ~C_ContExp(void);
    
        // type info
        DECLARE_INTERNAL_TYPE_INFO();
    
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_DeprecatedContExp --
        ///
        
        class C_DeprecatedContExp : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_DeprecatedContExp(void);
            // destructor
            ~C_DeprecatedContExp(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Reln,
                e_Fn,
                e_Declare
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 4 ///< == e_Declare+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CReln TReln;
            typedef CFn TFn;
            typedef CDeclare TDeclare;
        
            // getters
            // setters
        
        
            /// Check if variant Reln is selected.
            ///
            /// Reln type is defined as 'typedef CReln TReln'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsReln(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TReln& GetReln(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TReln& SetReln(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetReln(TReln& value);
        
        
            /// Check if variant Fn is selected.
            ///
            /// Fn type is defined as 'typedef CFn TFn'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsFn(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TFn& GetFn(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TFn& SetFn(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetFn(TFn& value);
        
        
            /// Check if variant Declare is selected.
            ///
            /// Declare type is defined as 'typedef CDeclare TDeclare'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDeclare(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDeclare& GetDeclare(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDeclare& SetDeclare(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetDeclare(TDeclare& value);
        
        
        private:
            // copy constructor and assignment operator
            C_DeprecatedContExp(const C_DeprecatedContExp& );
            C_DeprecatedContExp& operator=(const C_DeprecatedContExp& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Interval_mmlclass --
        ///
        
        class C_Interval_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Interval_mmlclass(void);
            // destructor
            ~C_Interval_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CInterval TInterval;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_interval
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Interval data member.
            ///
            /// Data member Interval is mandatory;
            /// its type is defined as 'typedef CInterval TInterval'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetInterval(void) const;
        
            /// Check if it is safe to call GetInterval method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetInterval(void) const;
        
            /// Reset Interval data member.
            void ResetInterval(void);
        
            /// Get the Interval member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TInterval& GetInterval(void) const;
        
            /// Assign a value to Interval data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetInterval(TInterval& value);
        
            /// Assign a value to Interval data member.
            ///
            /// @return
            ///   Reference to the data value.
            TInterval& SetInterval(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Interval_mmlclass(const C_Interval_mmlclass&);
            C_Interval_mmlclass& operator=(const C_Interval_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TInterval > m_Interval;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_functional_mmlclass --
        ///
        
        class C_Unary_functional_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_functional_mmlclass(void);
            // destructor
            ~C_Unary_functional_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Inverse,
                e_Ident,
                e_Domain,
                e_Codomain,
                e_Image,
                e_Ln,
                e_Log,
                e_Moment
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 9 ///< == e_Moment+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CInverse TInverse;
            typedef CIdent TIdent;
            typedef CDomain TDomain;
            typedef CCodomain TCodomain;
            typedef CImage TImage;
            typedef CLn TLn;
            typedef CLog TLog;
            typedef CMoment TMoment;
        
            // getters
            // setters
        
        
            /// Check if variant Inverse is selected.
            ///
            /// Inverse type is defined as 'typedef CInverse TInverse'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsInverse(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TInverse& GetInverse(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TInverse& SetInverse(void);
        
        
            /// Check if variant Ident is selected.
            ///
            /// Ident type is defined as 'typedef CIdent TIdent'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsIdent(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TIdent& GetIdent(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TIdent& SetIdent(void);
        
        
            /// Check if variant Domain is selected.
            ///
            /// Domain type is defined as 'typedef CDomain TDomain'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDomain(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDomain& GetDomain(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDomain& SetDomain(void);
        
        
            /// Check if variant Codomain is selected.
            ///
            /// Codomain type is defined as 'typedef CCodomain TCodomain'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCodomain(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCodomain& GetCodomain(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCodomain& SetCodomain(void);
        
        
            /// Check if variant Image is selected.
            ///
            /// Image type is defined as 'typedef CImage TImage'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsImage(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TImage& GetImage(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TImage& SetImage(void);
        
        
            /// Check if variant Ln is selected.
            ///
            /// Ln type is defined as 'typedef CLn TLn'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLn(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLn& GetLn(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLn& SetLn(void);
        
        
            /// Check if variant Log is selected.
            ///
            /// Log type is defined as 'typedef CLog TLog'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLog(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLog& GetLog(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLog& SetLog(void);
        
        
            /// Check if variant Moment is selected.
            ///
            /// Moment type is defined as 'typedef CMoment TMoment'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMoment(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMoment& GetMoment(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMoment& SetMoment(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Unary_functional_mmlclass(const C_Unary_functional_mmlclass& );
            C_Unary_functional_mmlclass& operator=(const C_Unary_functional_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Lambda_mmlclass --
        ///
        
        class C_Lambda_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Lambda_mmlclass(void);
            // destructor
            ~C_Lambda_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CLambda TLambda;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_lambda
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Lambda data member.
            ///
            /// Data member Lambda is mandatory;
            /// its type is defined as 'typedef CLambda TLambda'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetLambda(void) const;
        
            /// Check if it is safe to call GetLambda method.
            ///
            /// @return
            ///   - true, if the data member is getatable.
            ///   - false, otherwise.
            bool CanGetLambda(void) const;
        
            /// Reset Lambda data member.
            void ResetLambda(void);
        
            /// Get the Lambda member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TLambda& GetLambda(void) const;
        
            /// Assign a value to Lambda data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetLambda(TLambda& value);
        
            /// Assign a value to Lambda data member.
            ///
            /// @return
            ///   Reference to the data value.
            TLambda& SetLambda(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Lambda_mmlclass(const C_Lambda_mmlclass&);
            C_Lambda_mmlclass& operator=(const C_Lambda_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TLambda > m_Lambda;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_functional_mmlclass --
        ///
        
        class C_Nary_functional_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_functional_mmlclass(void);
            // destructor
            ~C_Nary_functional_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CCompose TCompose;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_compose
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Compose data member.
            ///
            /// Data member Compose is mandatory;
            /// its type is defined as 'typedef CCompose TCompose'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetCompose(void) const;
        
            /// Check if value of Compose member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetCompose(void) const;
        
            /// Reset Compose data member.
            void ResetCompose(void);
        
            /// Get the Compose member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TCompose& GetCompose(void) const;
        
            /// Assign a value to Compose data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetCompose(TCompose& value);
        
            /// Assign a value to Compose data member.
            ///
            /// @return
            ///   Reference to the data value.
            TCompose& SetCompose(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Nary_functional_mmlclass(const C_Nary_functional_mmlclass&);
            C_Nary_functional_mmlclass& operator=(const C_Nary_functional_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TCompose > m_Compose;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Binary_arith_mmlclass --
        ///
        
        class C_Binary_arith_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Binary_arith_mmlclass(void);
            // destructor
            ~C_Binary_arith_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Quotient,
                e_Divide,
                e_Minus,
                e_Power,
                e_Rem,
                e_Root
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 7 ///< == e_Root+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CQuotient TQuotient;
            typedef CDivide TDivide;
            typedef CMinus TMinus;
            typedef CPower TPower;
            typedef CRem TRem;
            typedef CRoot TRoot;
        
            // getters
            // setters
        
        
            /// Check if variant Quotient is selected.
            ///
            /// Quotient type is defined as 'typedef CQuotient TQuotient'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsQuotient(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TQuotient& GetQuotient(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TQuotient& SetQuotient(void);
        
        
            /// Check if variant Divide is selected.
            ///
            /// Divide type is defined as 'typedef CDivide TDivide'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDivide(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDivide& GetDivide(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDivide& SetDivide(void);
        
        
            /// Check if variant Minus is selected.
            ///
            /// Minus type is defined as 'typedef CMinus TMinus'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMinus(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMinus& GetMinus(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMinus& SetMinus(void);
        
        
            /// Check if variant Power is selected.
            ///
            /// Power type is defined as 'typedef CPower TPower'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsPower(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TPower& GetPower(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TPower& SetPower(void);
        
        
            /// Check if variant Rem is selected.
            ///
            /// Rem type is defined as 'typedef CRem TRem'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsRem(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TRem& GetRem(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TRem& SetRem(void);
        
        
            /// Check if variant Root is selected.
            ///
            /// Root type is defined as 'typedef CRoot TRoot'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsRoot(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TRoot& GetRoot(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TRoot& SetRoot(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Binary_arith_mmlclass(const C_Binary_arith_mmlclass& );
            C_Binary_arith_mmlclass& operator=(const C_Binary_arith_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_arith_mmlclass --
        ///
        
        class C_Unary_arith_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_arith_mmlclass(void);
            // destructor
            ~C_Unary_arith_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Factorial,
                e_Abs,
                e_Conjugate,
                e_Arg,
                e_Real,
                e_Imaginary,
                e_Floor,
                e_Ceiling,
                e_Exp
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 10 ///< == e_Exp+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CFactorial TFactorial;
            typedef CAbs TAbs;
            typedef CConjugate TConjugate;
            typedef CArg TArg;
            typedef CReal TReal;
            typedef CImaginary TImaginary;
            typedef CFloor TFloor;
            typedef CCeiling TCeiling;
            typedef CExp TExp;
        
            // getters
            // setters
        
        
            /// Check if variant Factorial is selected.
            ///
            /// Factorial type is defined as 'typedef CFactorial TFactorial'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsFactorial(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TFactorial& GetFactorial(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TFactorial& SetFactorial(void);
        
        
            /// Check if variant Abs is selected.
            ///
            /// Abs type is defined as 'typedef CAbs TAbs'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsAbs(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TAbs& GetAbs(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TAbs& SetAbs(void);
        
        
            /// Check if variant Conjugate is selected.
            ///
            /// Conjugate type is defined as 'typedef CConjugate TConjugate'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsConjugate(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TConjugate& GetConjugate(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TConjugate& SetConjugate(void);
        
        
            /// Check if variant Arg is selected.
            ///
            /// Arg type is defined as 'typedef CArg TArg'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArg(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArg& GetArg(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArg& SetArg(void);
        
        
            /// Check if variant Real is selected.
            ///
            /// Real type is defined as 'typedef CReal TReal'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsReal(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TReal& GetReal(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TReal& SetReal(void);
        
        
            /// Check if variant Imaginary is selected.
            ///
            /// Imaginary type is defined as 'typedef CImaginary TImaginary'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsImaginary(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TImaginary& GetImaginary(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TImaginary& SetImaginary(void);
        
        
            /// Check if variant Floor is selected.
            ///
            /// Floor type is defined as 'typedef CFloor TFloor'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsFloor(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TFloor& GetFloor(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TFloor& SetFloor(void);
        
        
            /// Check if variant Ceiling is selected.
            ///
            /// Ceiling type is defined as 'typedef CCeiling TCeiling'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCeiling(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCeiling& GetCeiling(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCeiling& SetCeiling(void);
        
        
            /// Check if variant Exp is selected.
            ///
            /// Exp type is defined as 'typedef CExp TExp'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsExp(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TExp& GetExp(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TExp& SetExp(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Unary_arith_mmlclass(const C_Unary_arith_mmlclass& );
            C_Unary_arith_mmlclass& operator=(const C_Unary_arith_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_minmax_mmlclass --
        ///
        
        class C_Nary_minmax_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_minmax_mmlclass(void);
            // destructor
            ~C_Nary_minmax_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Max,
                e_Min
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_Min+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CMax TMax;
            typedef CMin TMin;
        
            // getters
            // setters
        
        
            /// Check if variant Max is selected.
            ///
            /// Max type is defined as 'typedef CMax TMax'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMax(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMax& GetMax(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMax& SetMax(void);
        
        
            /// Check if variant Min is selected.
            ///
            /// Min type is defined as 'typedef CMin TMin'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMin(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMin& GetMin(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMin& SetMin(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_minmax_mmlclass(const C_Nary_minmax_mmlclass& );
            C_Nary_minmax_mmlclass& operator=(const C_Nary_minmax_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_arith_mmlclass --
        ///
        
        class C_Nary_arith_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_arith_mmlclass(void);
            // destructor
            ~C_Nary_arith_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Plus,
                e_Times,
                e_Gcd,
                e_Lcm
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 5 ///< == e_Lcm+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CPlus TPlus;
            typedef CTimes TTimes;
            typedef CGcd TGcd;
            typedef CLcm TLcm;
        
            // getters
            // setters
        
        
            /// Check if variant Plus is selected.
            ///
            /// Plus type is defined as 'typedef CPlus TPlus'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsPlus(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TPlus& GetPlus(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TPlus& SetPlus(void);
        
        
            /// Check if variant Times is selected.
            ///
            /// Times type is defined as 'typedef CTimes TTimes'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsTimes(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TTimes& GetTimes(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TTimes& SetTimes(void);
        
        
            /// Check if variant Gcd is selected.
            ///
            /// Gcd type is defined as 'typedef CGcd TGcd'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsGcd(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TGcd& GetGcd(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TGcd& SetGcd(void);
        
        
            /// Check if variant Lcm is selected.
            ///
            /// Lcm type is defined as 'typedef CLcm TLcm'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLcm(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLcm& GetLcm(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLcm& SetLcm(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_arith_mmlclass(const C_Nary_arith_mmlclass& );
            C_Nary_arith_mmlclass& operator=(const C_Nary_arith_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_logical_mmlclass --
        ///
        
        class C_Nary_logical_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_logical_mmlclass(void);
            // destructor
            ~C_Nary_logical_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_And,
                e_Or,
                e_Xor
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 4 ///< == e_Xor+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CAnd TAnd;
            typedef COr TOr;
            typedef CXor TXor;
        
            // getters
            // setters
        
        
            /// Check if variant And is selected.
            ///
            /// And type is defined as 'typedef CAnd TAnd'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsAnd(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TAnd& GetAnd(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TAnd& SetAnd(void);
        
        
            /// Check if variant Or is selected.
            ///
            /// Or type is defined as 'typedef COr TOr'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsOr(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TOr& GetOr(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TOr& SetOr(void);
        
        
            /// Check if variant Xor is selected.
            ///
            /// Xor type is defined as 'typedef CXor TXor'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsXor(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TXor& GetXor(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TXor& SetXor(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_logical_mmlclass(const C_Nary_logical_mmlclass& );
            C_Nary_logical_mmlclass& operator=(const C_Nary_logical_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_logical_mmlclass --
        ///
        
        class C_Unary_logical_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_logical_mmlclass(void);
            // destructor
            ~C_Unary_logical_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CNot TNot;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_not
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Not data member.
            ///
            /// Data member Not is mandatory;
            /// its type is defined as 'typedef CNot TNot'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetNot(void) const;
        
            /// Check if value of Not member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetNot(void) const;
        
            /// Reset Not data member.
            void ResetNot(void);
        
            /// Get the Not member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TNot& GetNot(void) const;
        
            /// Assign a value to Not data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetNot(TNot& value);
        
            /// Assign a value to Not data member.
            ///
            /// @return
            ///   Reference to the data value.
            TNot& SetNot(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Unary_logical_mmlclass(const C_Unary_logical_mmlclass&);
            C_Unary_logical_mmlclass& operator=(const C_Unary_logical_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TNot > m_Not;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Binary_logical_mmlclass --
        ///
        
        class C_Binary_logical_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Binary_logical_mmlclass(void);
            // destructor
            ~C_Binary_logical_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Implies,
                e_Equivalent
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_Equivalent+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CImplies TImplies;
            typedef CEquivalent TEquivalent;
        
            // getters
            // setters
        
        
            /// Check if variant Implies is selected.
            ///
            /// Implies type is defined as 'typedef CImplies TImplies'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsImplies(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TImplies& GetImplies(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TImplies& SetImplies(void);
        
        
            /// Check if variant Equivalent is selected.
            ///
            /// Equivalent type is defined as 'typedef CEquivalent TEquivalent'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsEquivalent(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TEquivalent& GetEquivalent(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TEquivalent& SetEquivalent(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Binary_logical_mmlclass(const C_Binary_logical_mmlclass& );
            C_Binary_logical_mmlclass& operator=(const C_Binary_logical_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Quantifier_mmlclass --
        ///
        
        class C_Quantifier_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Quantifier_mmlclass(void);
            // destructor
            ~C_Quantifier_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Forall,
                e_Exists
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_Exists+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CForall TForall;
            typedef CExists TExists;
        
            // getters
            // setters
        
        
            /// Check if variant Forall is selected.
            ///
            /// Forall type is defined as 'typedef CForall TForall'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsForall(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TForall& GetForall(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TForall& SetForall(void);
        
        
            /// Check if variant Exists is selected.
            ///
            /// Exists type is defined as 'typedef CExists TExists'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsExists(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TExists& GetExists(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TExists& SetExists(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Quantifier_mmlclass(const C_Quantifier_mmlclass& );
            C_Quantifier_mmlclass& operator=(const C_Quantifier_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_reln_mmlclass --
        ///
        
        class C_Nary_reln_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_reln_mmlclass(void);
            // destructor
            ~C_Nary_reln_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Eq,
                e_Gt,
                e_Lt,
                e_Geq,
                e_Leq
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 6 ///< == e_Leq+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CEq TEq;
            typedef CGt TGt;
            typedef CLt TLt;
            typedef CGeq TGeq;
            typedef CLeq TLeq;
        
            // getters
            // setters
        
        
            /// Check if variant Eq is selected.
            ///
            /// Eq type is defined as 'typedef CEq TEq'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsEq(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TEq& GetEq(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TEq& SetEq(void);
        
        
            /// Check if variant Gt is selected.
            ///
            /// Gt type is defined as 'typedef CGt TGt'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsGt(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TGt& GetGt(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TGt& SetGt(void);
        
        
            /// Check if variant Lt is selected.
            ///
            /// Lt type is defined as 'typedef CLt TLt'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLt(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLt& GetLt(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLt& SetLt(void);
        
        
            /// Check if variant Geq is selected.
            ///
            /// Geq type is defined as 'typedef CGeq TGeq'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsGeq(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TGeq& GetGeq(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TGeq& SetGeq(void);
        
        
            /// Check if variant Leq is selected.
            ///
            /// Leq type is defined as 'typedef CLeq TLeq'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLeq(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLeq& GetLeq(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLeq& SetLeq(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_reln_mmlclass(const C_Nary_reln_mmlclass& );
            C_Nary_reln_mmlclass& operator=(const C_Nary_reln_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Binary_reln_mmlclass --
        ///
        
        class C_Binary_reln_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Binary_reln_mmlclass(void);
            // destructor
            ~C_Binary_reln_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Neq,
                e_Approx,
                e_Factorof,
                e_Tendsto
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 5 ///< == e_Tendsto+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CNeq TNeq;
            typedef CApprox TApprox;
            typedef CFactorof TFactorof;
            typedef CTendsto TTendsto;
        
            // getters
            // setters
        
        
            /// Check if variant Neq is selected.
            ///
            /// Neq type is defined as 'typedef CNeq TNeq'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNeq(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNeq& GetNeq(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNeq& SetNeq(void);
        
        
            /// Check if variant Approx is selected.
            ///
            /// Approx type is defined as 'typedef CApprox TApprox'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsApprox(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TApprox& GetApprox(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TApprox& SetApprox(void);
        
        
            /// Check if variant Factorof is selected.
            ///
            /// Factorof type is defined as 'typedef CFactorof TFactorof'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsFactorof(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TFactorof& GetFactorof(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TFactorof& SetFactorof(void);
        
        
            /// Check if variant Tendsto is selected.
            ///
            /// Tendsto type is defined as 'typedef CTendsto TTendsto'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsTendsto(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TTendsto& GetTendsto(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TTendsto& SetTendsto(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Binary_reln_mmlclass(const C_Binary_reln_mmlclass& );
            C_Binary_reln_mmlclass& operator=(const C_Binary_reln_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Int_mmlclass --
        ///
        
        class C_Int_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Int_mmlclass(void);
            // destructor
            ~C_Int_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CInt TInt;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_int
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Int data member.
            ///
            /// Data member Int is mandatory;
            /// its type is defined as 'typedef CInt TInt'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetInt(void) const;
        
            /// Check if value of Int member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetInt(void) const;
        
            /// Reset Int data member.
            void ResetInt(void);
        
            /// Get the Int member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TInt& GetInt(void) const;
        
            /// Assign a value to Int data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetInt(TInt& value);
        
            /// Assign a value to Int data member.
            ///
            /// @return
            ///   Reference to the data value.
            TInt& SetInt(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Int_mmlclass(const C_Int_mmlclass&);
            C_Int_mmlclass& operator=(const C_Int_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TInt > m_Int;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Differential_Operator_mmlclass --
        ///
        
        class C_Differential_Operator_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Differential_Operator_mmlclass(void);
            // destructor
            ~C_Differential_Operator_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CDiff TDiff;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_diff
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Diff data member.
            ///
            /// Data member Diff is mandatory;
            /// its type is defined as 'typedef CDiff TDiff'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetDiff(void) const;
        
            /// Check if value of Diff member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetDiff(void) const;
        
            /// Reset Diff data member.
            void ResetDiff(void);
        
            /// Get the Diff member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TDiff& GetDiff(void) const;
        
            /// Assign a value to Diff data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetDiff(TDiff& value);
        
            /// Assign a value to Diff data member.
            ///
            /// @return
            ///   Reference to the data value.
            TDiff& SetDiff(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Differential_Operator_mmlclass(const C_Differential_Operator_mmlclass&);
            C_Differential_Operator_mmlclass& operator=(const C_Differential_Operator_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TDiff > m_Diff;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Partialdiff_mmlclass --
        ///
        
        class C_Partialdiff_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Partialdiff_mmlclass(void);
            // destructor
            ~C_Partialdiff_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CPartialdiff TPartialdiff;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_partialdiff
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Partialdiff data member.
            ///
            /// Data member Partialdiff is mandatory;
            /// its type is defined as 'typedef CPartialdiff TPartialdiff'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetPartialdiff(void) const;
        
            /// Check if value of Partialdiff member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetPartialdiff(void) const;
        
            /// Reset Partialdiff data member.
            void ResetPartialdiff(void);
        
            /// Get the Partialdiff member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TPartialdiff& GetPartialdiff(void) const;
        
            /// Assign a value to Partialdiff data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetPartialdiff(TPartialdiff& value);
        
            /// Assign a value to Partialdiff data member.
            ///
            /// @return
            ///   Reference to the data value.
            TPartialdiff& SetPartialdiff(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Partialdiff_mmlclass(const C_Partialdiff_mmlclass&);
            C_Partialdiff_mmlclass& operator=(const C_Partialdiff_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TPartialdiff > m_Partialdiff;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_veccalc_mmlclass --
        ///
        
        class C_Unary_veccalc_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_veccalc_mmlclass(void);
            // destructor
            ~C_Unary_veccalc_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Divergence,
                e_Grad,
                e_Curl,
                e_Laplacian
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 5 ///< == e_Laplacian+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CDivergence TDivergence;
            typedef CGrad TGrad;
            typedef CCurl TCurl;
            typedef CLaplacian TLaplacian;
        
            // getters
            // setters
        
        
            /// Check if variant Divergence is selected.
            ///
            /// Divergence type is defined as 'typedef CDivergence TDivergence'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDivergence(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDivergence& GetDivergence(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDivergence& SetDivergence(void);
        
        
            /// Check if variant Grad is selected.
            ///
            /// Grad type is defined as 'typedef CGrad TGrad'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsGrad(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TGrad& GetGrad(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TGrad& SetGrad(void);
        
        
            /// Check if variant Curl is selected.
            ///
            /// Curl type is defined as 'typedef CCurl TCurl'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCurl(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCurl& GetCurl(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCurl& SetCurl(void);
        
        
            /// Check if variant Laplacian is selected.
            ///
            /// Laplacian type is defined as 'typedef CLaplacian TLaplacian'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsLaplacian(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TLaplacian& GetLaplacian(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TLaplacian& SetLaplacian(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Unary_veccalc_mmlclass(const C_Unary_veccalc_mmlclass& );
            C_Unary_veccalc_mmlclass& operator=(const C_Unary_veccalc_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_setlist_constructor_mmlclass --
        ///
        
        class C_Nary_setlist_constructor_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_setlist_constructor_mmlclass(void);
            // destructor
            ~C_Nary_setlist_constructor_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Set,
                e_List
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_List+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CSet TSet;
            typedef CList TList;
        
            // getters
            // setters
        
        
            /// Check if variant Set is selected.
            ///
            /// Set type is defined as 'typedef CSet TSet'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSet(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSet& GetSet(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSet& SetSet(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetSet(TSet& value);
        
        
            /// Check if variant List is selected.
            ///
            /// List type is defined as 'typedef CList TList'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsList(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TList& GetList(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TList& SetList(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetList(TList& value);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_setlist_constructor_mmlclass(const C_Nary_setlist_constructor_mmlclass& );
            C_Nary_setlist_constructor_mmlclass& operator=(const C_Nary_setlist_constructor_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_set_mmlclass --
        ///
        
        class C_Nary_set_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_set_mmlclass(void);
            // destructor
            ~C_Nary_set_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,       ///< No variant selected
                e_Union,
                e_Intersect,
                e_Cartesianproduct
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 4 ///< == e_Cartesianproduct+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CUnion TUnion;
            typedef CIntersect TIntersect;
            typedef CCartesianproduct TCartesianproduct;
        
            // getters
            // setters
        
        
            /// Check if variant Union is selected.
            ///
            /// Union type is defined as 'typedef CUnion TUnion'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsUnion(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TUnion& GetUnion(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TUnion& SetUnion(void);
        
        
            /// Check if variant Intersect is selected.
            ///
            /// Intersect type is defined as 'typedef CIntersect TIntersect'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsIntersect(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TIntersect& GetIntersect(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TIntersect& SetIntersect(void);
        
        
            /// Check if variant Cartesianproduct is selected.
            ///
            /// Cartesianproduct type is defined as 'typedef CCartesianproduct TCartesianproduct'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCartesianproduct(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCartesianproduct& GetCartesianproduct(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCartesianproduct& SetCartesianproduct(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_set_mmlclass(const C_Nary_set_mmlclass& );
            C_Nary_set_mmlclass& operator=(const C_Nary_set_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Binary_set_mmlclass --
        ///
        
        class C_Binary_set_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Binary_set_mmlclass(void);
            // destructor
            ~C_Binary_set_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_In,
                e_Notin,
                e_Notsubset,
                e_Notprsubset,
                e_Setdiff
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 6 ///< == e_Setdiff+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CIn TIn;
            typedef CNotin TNotin;
            typedef CNotsubset TNotsubset;
            typedef CNotprsubset TNotprsubset;
            typedef CSetdiff TSetdiff;
        
            // getters
            // setters
        
        
            /// Check if variant In is selected.
            ///
            /// In type is defined as 'typedef CIn TIn'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsIn(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TIn& GetIn(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TIn& SetIn(void);
        
        
            /// Check if variant Notin is selected.
            ///
            /// Notin type is defined as 'typedef CNotin TNotin'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNotin(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNotin& GetNotin(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNotin& SetNotin(void);
        
        
            /// Check if variant Notsubset is selected.
            ///
            /// Notsubset type is defined as 'typedef CNotsubset TNotsubset'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNotsubset(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNotsubset& GetNotsubset(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNotsubset& SetNotsubset(void);
        
        
            /// Check if variant Notprsubset is selected.
            ///
            /// Notprsubset type is defined as 'typedef CNotprsubset TNotprsubset'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsNotprsubset(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TNotprsubset& GetNotprsubset(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TNotprsubset& SetNotprsubset(void);
        
        
            /// Check if variant Setdiff is selected.
            ///
            /// Setdiff type is defined as 'typedef CSetdiff TSetdiff'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSetdiff(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSetdiff& GetSetdiff(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSetdiff& SetSetdiff(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Binary_set_mmlclass(const C_Binary_set_mmlclass& );
            C_Binary_set_mmlclass& operator=(const C_Binary_set_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_set_reln_mmlclass --
        ///
        
        class C_Nary_set_reln_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_set_reln_mmlclass(void);
            // destructor
            ~C_Nary_set_reln_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Subset,
                e_Prsubset
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_Prsubset+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CSubset TSubset;
            typedef CPrsubset TPrsubset;
        
            // getters
            // setters
        
        
            /// Check if variant Subset is selected.
            ///
            /// Subset type is defined as 'typedef CSubset TSubset'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSubset(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSubset& GetSubset(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSubset& SetSubset(void);
        
        
            /// Check if variant Prsubset is selected.
            ///
            /// Prsubset type is defined as 'typedef CPrsubset TPrsubset'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsPrsubset(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TPrsubset& GetPrsubset(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TPrsubset& SetPrsubset(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_set_reln_mmlclass(const C_Nary_set_reln_mmlclass& );
            C_Nary_set_reln_mmlclass& operator=(const C_Nary_set_reln_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_set_mmlclass --
        ///
        
        class C_Unary_set_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_set_mmlclass(void);
            // destructor
            ~C_Unary_set_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CCard TCard;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_card
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Card data member.
            ///
            /// Data member Card is mandatory;
            /// its type is defined as 'typedef CCard TCard'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetCard(void) const;
        
            /// Check if value of Card member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetCard(void) const;
        
            /// Reset Card data member.
            void ResetCard(void);
        
            /// Get the Card member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TCard& GetCard(void) const;
        
            /// Assign a value to Card data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetCard(TCard& value);
        
            /// Assign a value to Card data member.
            ///
            /// @return
            ///   Reference to the data value.
            TCard& SetCard(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Unary_set_mmlclass(const C_Unary_set_mmlclass&);
            C_Unary_set_mmlclass& operator=(const C_Unary_set_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TCard > m_Card;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Sum_mmlclass --
        ///
        
        class C_Sum_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Sum_mmlclass(void);
            // destructor
            ~C_Sum_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CSum TSum;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_sum
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Sum data member.
            ///
            /// Data member Sum is mandatory;
            /// its type is defined as 'typedef CSum TSum'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetSum(void) const;
        
            /// Check if value of Sum member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetSum(void) const;
        
            /// Reset Sum data member.
            void ResetSum(void);
        
            /// Get the Sum member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TSum& GetSum(void) const;
        
            /// Assign a value to Sum data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetSum(TSum& value);
        
            /// Assign a value to Sum data member.
            ///
            /// @return
            ///   Reference to the data value.
            TSum& SetSum(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Sum_mmlclass(const C_Sum_mmlclass&);
            C_Sum_mmlclass& operator=(const C_Sum_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TSum > m_Sum;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Product_mmlclass --
        ///
        
        class C_Product_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Product_mmlclass(void);
            // destructor
            ~C_Product_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CProduct TProduct;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_product
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Product data member.
            ///
            /// Data member Product is mandatory;
            /// its type is defined as 'typedef CProduct TProduct'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetProduct(void) const;
        
            /// Check if value of Product member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetProduct(void) const;
        
            /// Reset Product data member.
            void ResetProduct(void);
        
            /// Get the Product member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TProduct& GetProduct(void) const;
        
            /// Assign a value to Product data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetProduct(TProduct& value);
        
            /// Assign a value to Product data member.
            ///
            /// @return
            ///   Reference to the data value.
            TProduct& SetProduct(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Product_mmlclass(const C_Product_mmlclass&);
            C_Product_mmlclass& operator=(const C_Product_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TProduct > m_Product;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Limit_mmlclass --
        ///
        
        class C_Limit_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Limit_mmlclass(void);
            // destructor
            ~C_Limit_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
            // types
            typedef CLimit TLimit;
        
            // member index
            enum class E_memberIndex {
                e__allMandatory = 0,
                e_limit
            };
            typedef Tparent::CMemberIndex<E_memberIndex, 2> TmemberIndex;
        
            // getters
            // setters
        
            /// Check if a value has been assigned to Limit data member.
            ///
            /// Data member Limit is mandatory;
            /// its type is defined as 'typedef CLimit TLimit'
            /// @return
            ///   - true, if a value has been assigned.
            ///   - false, otherwise.
            bool IsSetLimit(void) const;
        
            /// Check if value of Limit member is getatable.
            ///
            /// @return
            ///   - false; the data member of type 'NULL' has no value.
            bool CanGetLimit(void) const;
        
            /// Reset Limit data member.
            void ResetLimit(void);
        
            /// Get the Limit member data.
            ///
            /// @return
            ///   Reference to the member data.
            const TLimit& GetLimit(void) const;
        
            /// Assign a value to Limit data member.
            ///
            /// @param value
            ///   Reference to value.
            void SetLimit(TLimit& value);
        
            /// Assign a value to Limit data member.
            ///
            /// @return
            ///   Reference to the data value.
            TLimit& SetLimit(void);
        
            /// Reset the whole object
            void Reset(void);
        
        
        private:
            // Prohibit copy constructor and assignment operator
            C_Limit_mmlclass(const C_Limit_mmlclass&);
            C_Limit_mmlclass& operator=(const C_Limit_mmlclass&);
        
            // data
            Uint4 m_set_State[1];
            CRef< TLimit > m_Limit;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_elementary_mmlclass --
        ///
        
        class C_Unary_elementary_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_elementary_mmlclass(void);
            // destructor
            ~C_Unary_elementary_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Sin,
                e_Cos,
                e_Tan,
                e_Sec,
                e_Csc,
                e_Cot,
                e_Sinh,
                e_Cosh,
                e_Tanh,
                e_Sech,
                e_Csch,
                e_Coth,
                e_Arcsin,
                e_Arccos,
                e_Arctan,
                e_Arccosh,
                e_Arccot,
                e_Arccoth,
                e_Arccsc,
                e_Arccsch,
                e_Arcsec,
                e_Arcsech,
                e_Arcsinh,
                e_Arctanh
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 25 ///< == e_Arctanh+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CSin TSin;
            typedef CCos TCos;
            typedef CTan TTan;
            typedef CSec TSec;
            typedef CCsc TCsc;
            typedef CCot TCot;
            typedef CSinh TSinh;
            typedef CCosh TCosh;
            typedef CTanh TTanh;
            typedef CSech TSech;
            typedef CCsch TCsch;
            typedef CCoth TCoth;
            typedef CArcsin TArcsin;
            typedef CArccos TArccos;
            typedef CArctan TArctan;
            typedef CArccosh TArccosh;
            typedef CArccot TArccot;
            typedef CArccoth TArccoth;
            typedef CArccsc TArccsc;
            typedef CArccsch TArccsch;
            typedef CArcsec TArcsec;
            typedef CArcsech TArcsech;
            typedef CArcsinh TArcsinh;
            typedef CArctanh TArctanh;
        
            // getters
            // setters
        
        
            /// Check if variant Sin is selected.
            ///
            /// Sin type is defined as 'typedef CSin TSin'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSin(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSin& GetSin(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSin& SetSin(void);
        
        
            /// Check if variant Cos is selected.
            ///
            /// Cos type is defined as 'typedef CCos TCos'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCos(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCos& GetCos(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCos& SetCos(void);
        
        
            /// Check if variant Tan is selected.
            ///
            /// Tan type is defined as 'typedef CTan TTan'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsTan(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TTan& GetTan(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TTan& SetTan(void);
        
        
            /// Check if variant Sec is selected.
            ///
            /// Sec type is defined as 'typedef CSec TSec'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSec(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSec& GetSec(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSec& SetSec(void);
        
        
            /// Check if variant Csc is selected.
            ///
            /// Csc type is defined as 'typedef CCsc TCsc'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCsc(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCsc& GetCsc(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCsc& SetCsc(void);
        
        
            /// Check if variant Cot is selected.
            ///
            /// Cot type is defined as 'typedef CCot TCot'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCot(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCot& GetCot(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCot& SetCot(void);
        
        
            /// Check if variant Sinh is selected.
            ///
            /// Sinh type is defined as 'typedef CSinh TSinh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSinh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSinh& GetSinh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSinh& SetSinh(void);
        
        
            /// Check if variant Cosh is selected.
            ///
            /// Cosh type is defined as 'typedef CCosh TCosh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCosh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCosh& GetCosh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCosh& SetCosh(void);
        
        
            /// Check if variant Tanh is selected.
            ///
            /// Tanh type is defined as 'typedef CTanh TTanh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsTanh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TTanh& GetTanh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TTanh& SetTanh(void);
        
        
            /// Check if variant Sech is selected.
            ///
            /// Sech type is defined as 'typedef CSech TSech'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSech(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSech& GetSech(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSech& SetSech(void);
        
        
            /// Check if variant Csch is selected.
            ///
            /// Csch type is defined as 'typedef CCsch TCsch'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCsch(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCsch& GetCsch(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCsch& SetCsch(void);
        
        
            /// Check if variant Coth is selected.
            ///
            /// Coth type is defined as 'typedef CCoth TCoth'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsCoth(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TCoth& GetCoth(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TCoth& SetCoth(void);
        
        
            /// Check if variant Arcsin is selected.
            ///
            /// Arcsin type is defined as 'typedef CArcsin TArcsin'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArcsin(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArcsin& GetArcsin(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArcsin& SetArcsin(void);
        
        
            /// Check if variant Arccos is selected.
            ///
            /// Arccos type is defined as 'typedef CArccos TArccos'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccos(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccos& GetArccos(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccos& SetArccos(void);
        
        
            /// Check if variant Arctan is selected.
            ///
            /// Arctan type is defined as 'typedef CArctan TArctan'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArctan(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArctan& GetArctan(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArctan& SetArctan(void);
        
        
            /// Check if variant Arccosh is selected.
            ///
            /// Arccosh type is defined as 'typedef CArccosh TArccosh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccosh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccosh& GetArccosh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccosh& SetArccosh(void);
        
        
            /// Check if variant Arccot is selected.
            ///
            /// Arccot type is defined as 'typedef CArccot TArccot'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccot(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccot& GetArccot(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccot& SetArccot(void);
        
        
            /// Check if variant Arccoth is selected.
            ///
            /// Arccoth type is defined as 'typedef CArccoth TArccoth'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccoth(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccoth& GetArccoth(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccoth& SetArccoth(void);
        
        
            /// Check if variant Arccsc is selected.
            ///
            /// Arccsc type is defined as 'typedef CArccsc TArccsc'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccsc(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccsc& GetArccsc(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccsc& SetArccsc(void);
        
        
            /// Check if variant Arccsch is selected.
            ///
            /// Arccsch type is defined as 'typedef CArccsch TArccsch'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArccsch(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArccsch& GetArccsch(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArccsch& SetArccsch(void);
        
        
            /// Check if variant Arcsec is selected.
            ///
            /// Arcsec type is defined as 'typedef CArcsec TArcsec'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArcsec(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArcsec& GetArcsec(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArcsec& SetArcsec(void);
        
        
            /// Check if variant Arcsech is selected.
            ///
            /// Arcsech type is defined as 'typedef CArcsech TArcsech'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArcsech(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArcsech& GetArcsech(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArcsech& SetArcsech(void);
        
        
            /// Check if variant Arcsinh is selected.
            ///
            /// Arcsinh type is defined as 'typedef CArcsinh TArcsinh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArcsinh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArcsinh& GetArcsinh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArcsinh& SetArcsinh(void);
        
        
            /// Check if variant Arctanh is selected.
            ///
            /// Arctanh type is defined as 'typedef CArctanh TArctanh'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsArctanh(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TArctanh& GetArctanh(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TArctanh& SetArctanh(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Unary_elementary_mmlclass(const C_Unary_elementary_mmlclass& );
            C_Unary_elementary_mmlclass& operator=(const C_Unary_elementary_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_stats_mmlclass --
        ///
        
        class C_Nary_stats_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_stats_mmlclass(void);
            // destructor
            ~C_Nary_stats_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Mean,
                e_Sdev,
                e_Variance,
                e_Median,
                e_Mode
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 6 ///< == e_Mode+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CMean TMean;
            typedef CSdev TSdev;
            typedef CVariance TVariance;
            typedef CMedian TMedian;
            typedef CMode TMode;
        
            // getters
            // setters
        
        
            /// Check if variant Mean is selected.
            ///
            /// Mean type is defined as 'typedef CMean TMean'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMean(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMean& GetMean(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMean& SetMean(void);
        
        
            /// Check if variant Sdev is selected.
            ///
            /// Sdev type is defined as 'typedef CSdev TSdev'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsSdev(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TSdev& GetSdev(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TSdev& SetSdev(void);
        
        
            /// Check if variant Variance is selected.
            ///
            /// Variance type is defined as 'typedef CVariance TVariance'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsVariance(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TVariance& GetVariance(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TVariance& SetVariance(void);
        
        
            /// Check if variant Median is selected.
            ///
            /// Median type is defined as 'typedef CMedian TMedian'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMedian(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMedian& GetMedian(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMedian& SetMedian(void);
        
        
            /// Check if variant Mode is selected.
            ///
            /// Mode type is defined as 'typedef CMode TMode'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMode(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMode& GetMode(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMode& SetMode(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_stats_mmlclass(const C_Nary_stats_mmlclass& );
            C_Nary_stats_mmlclass& operator=(const C_Nary_stats_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Nary_constructor_mmlclass --
        ///
        
        class C_Nary_constructor_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Nary_constructor_mmlclass(void);
            // destructor
            ~C_Nary_constructor_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Vector,
                e_Matrix,
                e_Matrixrow
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 4 ///< == e_Matrixrow+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CVector TVector;
            typedef CMatrix TMatrix;
            typedef CMatrixrow TMatrixrow;
        
            // getters
            // setters
        
        
            /// Check if variant Vector is selected.
            ///
            /// Vector type is defined as 'typedef CVector TVector'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsVector(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TVector& GetVector(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TVector& SetVector(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetVector(TVector& value);
        
        
            /// Check if variant Matrix is selected.
            ///
            /// Matrix type is defined as 'typedef CMatrix TMatrix'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMatrix(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMatrix& GetMatrix(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMatrix& SetMatrix(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetMatrix(TMatrix& value);
        
        
            /// Check if variant Matrixrow is selected.
            ///
            /// Matrixrow type is defined as 'typedef CMatrixrow TMatrixrow'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsMatrixrow(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TMatrixrow& GetMatrixrow(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TMatrixrow& SetMatrixrow(void);
            /// Select the variant and set its data.
            ///
            /// @param value
            ///   Reference to the data.
            void SetMatrixrow(TMatrixrow& value);
        
        
        private:
            // copy constructor and assignment operator
            C_Nary_constructor_mmlclass(const C_Nary_constructor_mmlclass& );
            C_Nary_constructor_mmlclass& operator=(const C_Nary_constructor_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
        
            static const char* const sm_SelectionNames[];
            // data
            NCBI_NS_NCBI::CSerialObject *m_object;
        };
        /////////////////////////////////////////////////////////////////////////////
        ///
        /// C_Unary_linalg_mmlclass --
        ///
        
        class C_Unary_linalg_mmlclass : public CSerialObject
        {
            typedef CSerialObject Tparent;
        public:
            // constructor
            C_Unary_linalg_mmlclass(void);
            // destructor
            ~C_Unary_linalg_mmlclass(void);
        
            // type info
            DECLARE_INTERNAL_TYPE_INFO();
        
        
            /// Choice variants.
            enum E_Choice {
                e_not_set = 0,  ///< No variant selected
                e_Determinant,
                e_Transpose
            };
            /// Maximum+1 value of the choice variant enumerator.
            enum E_ChoiceStopper {
                e_MaxChoice = 3 ///< == e_Transpose+1
            };
        
            /// Reset the whole object
            void Reset(void);
        
            /// Reset the selection (set it to e_not_set).
            void ResetSelection(void);
        
            /// Which variant is currently selected.
            ///
            /// @return
            ///   Choice state enumerator.
            E_Choice Which(void) const;
        
            /// Verify selection, throw exception if it differs from the expected.
            ///
            /// @param index
            ///   Expected selection.
            void CheckSelected(E_Choice index) const;
        
            /// Throw 'InvalidSelection' exception.
            ///
            /// @param index
            ///   Expected selection.
            NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
        
            /// Retrieve selection name (for diagnostic purposes).
            ///
            /// @param index
            ///   One of possible selection states.
            /// @return
            ///   Name string.
            static string SelectionName(E_Choice index);
        
            /// Select the requested variant if needed.
            ///
            /// @param index
            ///   New selection state.
            /// @param reset
            ///   Flag that defines the resetting of the variant data. The data will
            ///   be reset if either the current selection differs from the new one,
            ///   or the flag is set to eDoResetVariant.
            void Select(E_Choice index, EResetVariant reset = eDoResetVariant);
            /// Select the requested variant if needed,
            /// allocating CObject variants from memory pool.
            void Select(E_Choice index,
                        EResetVariant reset,
                        CObjectMemoryPool* pool);
        
            // types
            typedef CDeterminant TDeterminant;
            typedef CTranspose TTranspose;
        
            // getters
            // setters
        
        
            /// Check if variant Determinant is selected.
            ///
            /// Determinant type is defined as 'typedef CDeterminant TDeterminant'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsDeterminant(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TDeterminant& GetDeterminant(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TDeterminant& SetDeterminant(void);
        
        
            /// Check if variant Transpose is selected.
            ///
            /// Transpose type is defined as 'typedef CTranspose TTranspose'.
            /// @return
            ///   - true, if the variant is selected.
            ///   - false, otherwise.
            bool IsTranspose(void) const;
        
            /// Get the variant data.
            ///
            /// @return
            ///   Reference to the data.
            const TTranspose& GetTranspose(void) const;
        
            /// Select the variant.
            ///
            /// @return
            ///   Reference to the variant data.
            TTranspose& SetTranspose(void);
        
        
        private:
            // copy constructor and assignment operator
            C_Unary_linalg_mmlclass(const C_Unary_linalg_mmlclass& );
            C_Unary_linalg_mmlclass& operator=(const C_Unary_linalg_mmlclass& );
            // choice state
            E_Choice m_choice;
            // helper methods
            void DoSel