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