NCBI C++ ToolKit
ContExp_.hpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id$
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  */
27 
28 /// @file ContExp_.hpp
29 /// Data storage class.
30 ///
31 /// This file was generated by application DATATOOL
32 /// using the following specifications:
33 /// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objtools/eutils/efetch/pubmed_mathml3.xsd">pubmed_mathml3.xsd</a>
34 /// and additional tune-up parameters:
35 /// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objtools/eutils/efetch/pubmed_mathml3.def">pubmed_mathml3.def</a>
36 ///
37 /// ATTENTION:
38 /// Don't edit or commit this file into CVS as this file will
39 /// be overridden (by DATATOOL) without warning!
40 
41 #ifndef OBJTOOLS_EUTILS_EFETCH_CONTEXP_BASE_HPP
42 #define OBJTOOLS_EUTILS_EFETCH_CONTEXP_BASE_HPP
43 
44 // standard includes
45 #include <serial/serialbase.hpp>
47 
48 #ifndef BEGIN_objects_SCOPE
49 # define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
50 # define END_objects_SCOPE END_SCOPE(objects)
51 #endif
52 BEGIN_objects_SCOPE // namespace ncbi::objects::
53 
54 
55 // forward declarations
56 class CAbs;
57 class CAnd;
58 class CApply;
59 class CApprox;
60 class CArccos;
61 class CArccosh;
62 class CArccot;
63 class CArccoth;
64 class CArccsc;
65 class CArccsch;
66 class CArcsec;
67 class CArcsech;
68 class CArcsin;
69 class CArcsinh;
70 class CArctan;
71 class CArctanh;
72 class CArg;
73 class CBind;
74 class CCard;
75 class CCartesianproduct;
76 class CCbytes;
77 class CCeiling;
78 class CCerror;
79 class CCi;
80 class CCn;
81 class CCodomain;
82 class CComplexes;
83 class CCompose;
84 class CConjugate;
85 class CCos;
86 class CCosh;
87 class CCot;
88 class CCoth;
89 class CCs;
90 class CCsc;
91 class CCsch;
92 class CCsymbol;
93 class CCurl;
94 class CDeclare;
95 class CDeterminant;
96 class CDiff;
97 class CDivergence;
98 class CDivide;
99 class CDomain;
100 class CEmptyset;
101 class CEq;
102 class CEquivalent;
103 class CEulergamma;
104 class CExists;
105 class CExp;
106 class CExponentiale;
107 class CFactorial;
108 class CFactorof;
109 class CFalse;
110 class CFloor;
111 class CFn;
112 class CForall;
113 class CGcd;
114 class CGeq;
115 class CGrad;
116 class CGt;
117 class CIdent;
118 class CImage;
119 class CImaginary;
120 class CImaginaryi;
121 class CImplies;
122 class CIn;
123 class CInfinity;
124 class CInt;
125 class CIntegers;
126 class CIntersect;
127 class CInterval;
128 class CInverse;
129 class CLambda;
130 class CLaplacian;
131 class CLcm;
132 class CLeq;
133 class CLimit;
134 class CList;
135 class CLn;
136 class CLog;
137 class CLt;
138 class CMatrix;
139 class CMatrixrow;
140 class CMax;
141 class CMean;
142 class CMedian;
143 class CMin;
144 class CMinus;
145 class CMode;
146 class CMoment;
147 class CNaturalnumbers;
148 class CNeq;
149 class CNot;
150 class CNotanumber;
151 class CNotin;
152 class CNotprsubset;
153 class CNotsubset;
154 class COr;
155 class COuterproduct;
156 class CPartialdiff;
157 class CPi;
158 class CPiecewise;
159 class CPlus;
160 class CPower;
161 class CPrimes;
162 class CProduct;
163 class CPrsubset;
164 class CQuotient;
165 class CRationals;
166 class CReal;
167 class CReals;
168 class CReln;
169 class CRem;
170 class CRoot;
171 class CScalarproduct;
172 class CSdev;
173 class CSec;
174 class CSech;
175 class CSelector;
176 class CSemantics;
177 class CSet;
178 class CSetdiff;
179 class CShare;
180 class CSin;
181 class CSinh;
182 class CSubset;
183 class CSum;
184 class CTan;
185 class CTanh;
186 class CTendsto;
187 class CTimes;
188 class CTranspose;
189 class CTrue;
190 class CUnion;
191 class CVariance;
192 class CVector;
193 class CVectorproduct;
194 class CXor;
195 
196 
197 // generated classes
198 
199 
200 /** @addtogroup dataspec_pubmed_mathml3
201  *
202  * @{
203  */
204 
205 /////////////////////////////////////////////////////////////////////////////
206 ///
207 /// CContExp_Base --
208 ///
209 
211 {
213 public:
214  // constructor
215  CContExp_Base(void);
216  // destructor
217  virtual ~CContExp_Base(void);
218 
219  // type info
221 
222  /////////////////////////////////////////////////////////////////////////////
223  ///
224  /// C_DeprecatedContExp --
225  ///
226 
228  {
230  public:
231  // constructor
232  C_DeprecatedContExp(void);
233  // destructor
234  ~C_DeprecatedContExp(void);
235 
236  // type info
238 
239 
240  /// Choice variants.
241  enum E_Choice {
242  e_not_set = 0, ///< No variant selected
245  e_Declare
246  };
247  /// Maximum+1 value of the choice variant enumerator.
249  e_MaxChoice = 4 ///< == e_Declare+1
250  };
251 
252  /// Reset the whole object
253  void Reset(void);
254 
255  /// Reset the selection (set it to e_not_set).
256  void ResetSelection(void);
257 
258  /// Which variant is currently selected.
259  ///
260  /// @return
261  /// Choice state enumerator.
262  E_Choice Which(void) const;
263 
264  /// Verify selection, throw exception if it differs from the expected.
265  ///
266  /// @param index
267  /// Expected selection.
268  void CheckSelected(E_Choice index) const;
269 
270  /// Throw 'InvalidSelection' exception.
271  ///
272  /// @param index
273  /// Expected selection.
274  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
275 
276  /// Retrieve selection name (for diagnostic purposes).
277  ///
278  /// @param index
279  /// One of possible selection states.
280  /// @return
281  /// Name string.
282  static string SelectionName(E_Choice index);
283 
284  /// Select the requested variant if needed.
285  ///
286  /// @param index
287  /// New selection state.
288  /// @param reset
289  /// Flag that defines the resetting of the variant data. The data will
290  /// be reset if either the current selection differs from the new one,
291  /// or the flag is set to eDoResetVariant.
293  /// Select the requested variant if needed,
294  /// allocating CObject variants from memory pool.
295  void Select(E_Choice index,
296  EResetVariant reset,
297  CObjectMemoryPool* pool);
298 
299  // types
300  typedef CReln TReln;
301  typedef CFn TFn;
303 
304  // getters
305  // setters
306 
307 
308  /// Check if variant Reln is selected.
309  ///
310  /// Reln type is defined as 'typedef CReln TReln'.
311  /// @return
312  /// - true, if the variant is selected.
313  /// - false, otherwise.
314  bool IsReln(void) const;
315 
316  /// Get the variant data.
317  ///
318  /// @return
319  /// Reference to the data.
320  const TReln& GetReln(void) const;
321 
322  /// Select the variant.
323  ///
324  /// @return
325  /// Reference to the variant data.
326  TReln& SetReln(void);
327  /// Select the variant and set its data.
328  ///
329  /// @param value
330  /// Reference to the data.
331  void SetReln(TReln& value);
332 
333 
334  /// Check if variant Fn is selected.
335  ///
336  /// Fn type is defined as 'typedef CFn TFn'.
337  /// @return
338  /// - true, if the variant is selected.
339  /// - false, otherwise.
340  bool IsFn(void) const;
341 
342  /// Get the variant data.
343  ///
344  /// @return
345  /// Reference to the data.
346  const TFn& GetFn(void) const;
347 
348  /// Select the variant.
349  ///
350  /// @return
351  /// Reference to the variant data.
352  TFn& SetFn(void);
353  /// Select the variant and set its data.
354  ///
355  /// @param value
356  /// Reference to the data.
357  void SetFn(TFn& value);
358 
359 
360  /// Check if variant Declare is selected.
361  ///
362  /// Declare type is defined as 'typedef CDeclare TDeclare'.
363  /// @return
364  /// - true, if the variant is selected.
365  /// - false, otherwise.
366  bool IsDeclare(void) const;
367 
368  /// Get the variant data.
369  ///
370  /// @return
371  /// Reference to the data.
372  const TDeclare& GetDeclare(void) const;
373 
374  /// Select the variant.
375  ///
376  /// @return
377  /// Reference to the variant data.
378  TDeclare& SetDeclare(void);
379  /// Select the variant and set its data.
380  ///
381  /// @param value
382  /// Reference to the data.
383  void SetDeclare(TDeclare& value);
384 
385 
386  private:
387  // copy constructor and assignment operator
390  // choice state
392  // helper methods
393  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
394 
395  static const char* const sm_SelectionNames[];
396  // data
397  NCBI_NS_NCBI::CSerialObject *m_object;
398  };
399  /////////////////////////////////////////////////////////////////////////////
400  ///
401  /// C_Interval_mmlclass --
402  ///
403 
405  {
407  public:
408  // constructor
409  C_Interval_mmlclass(void);
410  // destructor
411  ~C_Interval_mmlclass(void);
412 
413  // type info
415 
416  // types
418 
419  // member index
420  enum class E_memberIndex {
421  e__allMandatory = 0,
422  e_interval
423  };
425 
426  // getters
427  // setters
428 
429  /// Check if a value has been assigned to Interval data member.
430  ///
431  /// Data member Interval is mandatory;
432  /// its type is defined as 'typedef CInterval TInterval'
433  /// @return
434  /// - true, if a value has been assigned.
435  /// - false, otherwise.
436  bool IsSetInterval(void) const;
437 
438  /// Check if it is safe to call GetInterval method.
439  ///
440  /// @return
441  /// - true, if the data member is getatable.
442  /// - false, otherwise.
443  bool CanGetInterval(void) const;
444 
445  /// Reset Interval data member.
446  void ResetInterval(void);
447 
448  /// Get the Interval member data.
449  ///
450  /// @return
451  /// Reference to the member data.
452  const TInterval& GetInterval(void) const;
453 
454  /// Assign a value to Interval data member.
455  ///
456  /// @param value
457  /// Reference to value.
458  void SetInterval(TInterval& value);
459 
460  /// Assign a value to Interval data member.
461  ///
462  /// @return
463  /// Reference to the data value.
464  TInterval& SetInterval(void);
465 
466  /// Reset the whole object
467  void Reset(void);
468 
469 
470  private:
471  // Prohibit copy constructor and assignment operator
474 
475  // data
478  };
479  /////////////////////////////////////////////////////////////////////////////
480  ///
481  /// C_Unary_functional_mmlclass --
482  ///
483 
485  {
487  public:
488  // constructor
490  // destructor
492 
493  // type info
495 
496 
497  /// Choice variants.
498  enum E_Choice {
499  e_not_set = 0, ///< No variant selected
507  e_Moment
508  };
509  /// Maximum+1 value of the choice variant enumerator.
511  e_MaxChoice = 9 ///< == e_Moment+1
512  };
513 
514  /// Reset the whole object
515  void Reset(void);
516 
517  /// Reset the selection (set it to e_not_set).
518  void ResetSelection(void);
519 
520  /// Which variant is currently selected.
521  ///
522  /// @return
523  /// Choice state enumerator.
524  E_Choice Which(void) const;
525 
526  /// Verify selection, throw exception if it differs from the expected.
527  ///
528  /// @param index
529  /// Expected selection.
530  void CheckSelected(E_Choice index) const;
531 
532  /// Throw 'InvalidSelection' exception.
533  ///
534  /// @param index
535  /// Expected selection.
536  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
537 
538  /// Retrieve selection name (for diagnostic purposes).
539  ///
540  /// @param index
541  /// One of possible selection states.
542  /// @return
543  /// Name string.
544  static string SelectionName(E_Choice index);
545 
546  /// Select the requested variant if needed.
547  ///
548  /// @param index
549  /// New selection state.
550  /// @param reset
551  /// Flag that defines the resetting of the variant data. The data will
552  /// be reset if either the current selection differs from the new one,
553  /// or the flag is set to eDoResetVariant.
555  /// Select the requested variant if needed,
556  /// allocating CObject variants from memory pool.
557  void Select(E_Choice index,
558  EResetVariant reset,
559  CObjectMemoryPool* pool);
560 
561  // types
563  typedef CIdent TIdent;
564  typedef CDomain TDomain;
566  typedef CImage TImage;
567  typedef CLn TLn;
568  typedef CLog TLog;
569  typedef CMoment TMoment;
570 
571  // getters
572  // setters
573 
574 
575  /// Check if variant Inverse is selected.
576  ///
577  /// Inverse type is defined as 'typedef CInverse TInverse'.
578  /// @return
579  /// - true, if the variant is selected.
580  /// - false, otherwise.
581  bool IsInverse(void) const;
582 
583  /// Get the variant data.
584  ///
585  /// @return
586  /// Reference to the data.
587  const TInverse& GetInverse(void) const;
588 
589  /// Select the variant.
590  ///
591  /// @return
592  /// Reference to the variant data.
593  TInverse& SetInverse(void);
594 
595 
596  /// Check if variant Ident is selected.
597  ///
598  /// Ident type is defined as 'typedef CIdent TIdent'.
599  /// @return
600  /// - true, if the variant is selected.
601  /// - false, otherwise.
602  bool IsIdent(void) const;
603 
604  /// Get the variant data.
605  ///
606  /// @return
607  /// Reference to the data.
608  const TIdent& GetIdent(void) const;
609 
610  /// Select the variant.
611  ///
612  /// @return
613  /// Reference to the variant data.
614  TIdent& SetIdent(void);
615 
616 
617  /// Check if variant Domain is selected.
618  ///
619  /// Domain type is defined as 'typedef CDomain TDomain'.
620  /// @return
621  /// - true, if the variant is selected.
622  /// - false, otherwise.
623  bool IsDomain(void) const;
624 
625  /// Get the variant data.
626  ///
627  /// @return
628  /// Reference to the data.
629  const TDomain& GetDomain(void) const;
630 
631  /// Select the variant.
632  ///
633  /// @return
634  /// Reference to the variant data.
635  TDomain& SetDomain(void);
636 
637 
638  /// Check if variant Codomain is selected.
639  ///
640  /// Codomain type is defined as 'typedef CCodomain TCodomain'.
641  /// @return
642  /// - true, if the variant is selected.
643  /// - false, otherwise.
644  bool IsCodomain(void) const;
645 
646  /// Get the variant data.
647  ///
648  /// @return
649  /// Reference to the data.
650  const TCodomain& GetCodomain(void) const;
651 
652  /// Select the variant.
653  ///
654  /// @return
655  /// Reference to the variant data.
656  TCodomain& SetCodomain(void);
657 
658 
659  /// Check if variant Image is selected.
660  ///
661  /// Image type is defined as 'typedef CImage TImage'.
662  /// @return
663  /// - true, if the variant is selected.
664  /// - false, otherwise.
665  bool IsImage(void) const;
666 
667  /// Get the variant data.
668  ///
669  /// @return
670  /// Reference to the data.
671  const TImage& GetImage(void) const;
672 
673  /// Select the variant.
674  ///
675  /// @return
676  /// Reference to the variant data.
677  TImage& SetImage(void);
678 
679 
680  /// Check if variant Ln is selected.
681  ///
682  /// Ln type is defined as 'typedef CLn TLn'.
683  /// @return
684  /// - true, if the variant is selected.
685  /// - false, otherwise.
686  bool IsLn(void) const;
687 
688  /// Get the variant data.
689  ///
690  /// @return
691  /// Reference to the data.
692  const TLn& GetLn(void) const;
693 
694  /// Select the variant.
695  ///
696  /// @return
697  /// Reference to the variant data.
698  TLn& SetLn(void);
699 
700 
701  /// Check if variant Log is selected.
702  ///
703  /// Log type is defined as 'typedef CLog TLog'.
704  /// @return
705  /// - true, if the variant is selected.
706  /// - false, otherwise.
707  bool IsLog(void) const;
708 
709  /// Get the variant data.
710  ///
711  /// @return
712  /// Reference to the data.
713  const TLog& GetLog(void) const;
714 
715  /// Select the variant.
716  ///
717  /// @return
718  /// Reference to the variant data.
719  TLog& SetLog(void);
720 
721 
722  /// Check if variant Moment is selected.
723  ///
724  /// Moment type is defined as 'typedef CMoment TMoment'.
725  /// @return
726  /// - true, if the variant is selected.
727  /// - false, otherwise.
728  bool IsMoment(void) const;
729 
730  /// Get the variant data.
731  ///
732  /// @return
733  /// Reference to the data.
734  const TMoment& GetMoment(void) const;
735 
736  /// Select the variant.
737  ///
738  /// @return
739  /// Reference to the variant data.
740  TMoment& SetMoment(void);
741 
742 
743  private:
744  // copy constructor and assignment operator
747  // choice state
749  // helper methods
750  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
751 
752  static const char* const sm_SelectionNames[];
753  // data
754  NCBI_NS_NCBI::CSerialObject *m_object;
755  };
756  /////////////////////////////////////////////////////////////////////////////
757  ///
758  /// C_Lambda_mmlclass --
759  ///
760 
762  {
764  public:
765  // constructor
766  C_Lambda_mmlclass(void);
767  // destructor
768  ~C_Lambda_mmlclass(void);
769 
770  // type info
772 
773  // types
774  typedef CLambda TLambda;
775 
776  // member index
777  enum class E_memberIndex {
778  e__allMandatory = 0,
779  e_lambda
780  };
782 
783  // getters
784  // setters
785 
786  /// Check if a value has been assigned to Lambda data member.
787  ///
788  /// Data member Lambda is mandatory;
789  /// its type is defined as 'typedef CLambda TLambda'
790  /// @return
791  /// - true, if a value has been assigned.
792  /// - false, otherwise.
793  bool IsSetLambda(void) const;
794 
795  /// Check if it is safe to call GetLambda method.
796  ///
797  /// @return
798  /// - true, if the data member is getatable.
799  /// - false, otherwise.
800  bool CanGetLambda(void) const;
801 
802  /// Reset Lambda data member.
803  void ResetLambda(void);
804 
805  /// Get the Lambda member data.
806  ///
807  /// @return
808  /// Reference to the member data.
809  const TLambda& GetLambda(void) const;
810 
811  /// Assign a value to Lambda data member.
812  ///
813  /// @param value
814  /// Reference to value.
815  void SetLambda(TLambda& value);
816 
817  /// Assign a value to Lambda data member.
818  ///
819  /// @return
820  /// Reference to the data value.
821  TLambda& SetLambda(void);
822 
823  /// Reset the whole object
824  void Reset(void);
825 
826 
827  private:
828  // Prohibit copy constructor and assignment operator
831 
832  // data
835  };
836  /////////////////////////////////////////////////////////////////////////////
837  ///
838  /// C_Nary_functional_mmlclass --
839  ///
840 
842  {
844  public:
845  // constructor
847  // destructor
849 
850  // type info
852 
853  // types
855 
856  // member index
857  enum class E_memberIndex {
858  e__allMandatory = 0,
859  e_compose
860  };
862 
863  // getters
864  // setters
865 
866  /// Check if a value has been assigned to Compose data member.
867  ///
868  /// Data member Compose is mandatory;
869  /// its type is defined as 'typedef CCompose TCompose'
870  /// @return
871  /// - true, if a value has been assigned.
872  /// - false, otherwise.
873  bool IsSetCompose(void) const;
874 
875  /// Check if value of Compose member is getatable.
876  ///
877  /// @return
878  /// - false; the data member of type 'NULL' has no value.
879  bool CanGetCompose(void) const;
880 
881  /// Reset Compose data member.
882  void ResetCompose(void);
883 
884  /// Get the Compose member data.
885  ///
886  /// @return
887  /// Reference to the member data.
888  const TCompose& GetCompose(void) const;
889 
890  /// Assign a value to Compose data member.
891  ///
892  /// @param value
893  /// Reference to value.
894  void SetCompose(TCompose& value);
895 
896  /// Assign a value to Compose data member.
897  ///
898  /// @return
899  /// Reference to the data value.
900  TCompose& SetCompose(void);
901 
902  /// Reset the whole object
903  void Reset(void);
904 
905 
906  private:
907  // Prohibit copy constructor and assignment operator
910 
911  // data
914  };
915  /////////////////////////////////////////////////////////////////////////////
916  ///
917  /// C_Binary_arith_mmlclass --
918  ///
919 
921  {
923  public:
924  // constructor
926  // destructor
928 
929  // type info
931 
932 
933  /// Choice variants.
934  enum E_Choice {
935  e_not_set = 0, ///< No variant selected
941  e_Root
942  };
943  /// Maximum+1 value of the choice variant enumerator.
945  e_MaxChoice = 7 ///< == e_Root+1
946  };
947 
948  /// Reset the whole object
949  void Reset(void);
950 
951  /// Reset the selection (set it to e_not_set).
952  void ResetSelection(void);
953 
954  /// Which variant is currently selected.
955  ///
956  /// @return
957  /// Choice state enumerator.
958  E_Choice Which(void) const;
959 
960  /// Verify selection, throw exception if it differs from the expected.
961  ///
962  /// @param index
963  /// Expected selection.
964  void CheckSelected(E_Choice index) const;
965 
966  /// Throw 'InvalidSelection' exception.
967  ///
968  /// @param index
969  /// Expected selection.
970  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
971 
972  /// Retrieve selection name (for diagnostic purposes).
973  ///
974  /// @param index
975  /// One of possible selection states.
976  /// @return
977  /// Name string.
978  static string SelectionName(E_Choice index);
979 
980  /// Select the requested variant if needed.
981  ///
982  /// @param index
983  /// New selection state.
984  /// @param reset
985  /// Flag that defines the resetting of the variant data. The data will
986  /// be reset if either the current selection differs from the new one,
987  /// or the flag is set to eDoResetVariant.
989  /// Select the requested variant if needed,
990  /// allocating CObject variants from memory pool.
991  void Select(E_Choice index,
992  EResetVariant reset,
993  CObjectMemoryPool* pool);
994 
995  // types
997  typedef CDivide TDivide;
998  typedef CMinus TMinus;
999  typedef CPower TPower;
1000  typedef CRem TRem;
1001  typedef CRoot TRoot;
1002 
1003  // getters
1004  // setters
1005 
1006 
1007  /// Check if variant Quotient is selected.
1008  ///
1009  /// Quotient type is defined as 'typedef CQuotient TQuotient'.
1010  /// @return
1011  /// - true, if the variant is selected.
1012  /// - false, otherwise.
1013  bool IsQuotient(void) const;
1014 
1015  /// Get the variant data.
1016  ///
1017  /// @return
1018  /// Reference to the data.
1019  const TQuotient& GetQuotient(void) const;
1020 
1021  /// Select the variant.
1022  ///
1023  /// @return
1024  /// Reference to the variant data.
1025  TQuotient& SetQuotient(void);
1026 
1027 
1028  /// Check if variant Divide is selected.
1029  ///
1030  /// Divide type is defined as 'typedef CDivide TDivide'.
1031  /// @return
1032  /// - true, if the variant is selected.
1033  /// - false, otherwise.
1034  bool IsDivide(void) const;
1035 
1036  /// Get the variant data.
1037  ///
1038  /// @return
1039  /// Reference to the data.
1040  const TDivide& GetDivide(void) const;
1041 
1042  /// Select the variant.
1043  ///
1044  /// @return
1045  /// Reference to the variant data.
1046  TDivide& SetDivide(void);
1047 
1048 
1049  /// Check if variant Minus is selected.
1050  ///
1051  /// Minus type is defined as 'typedef CMinus TMinus'.
1052  /// @return
1053  /// - true, if the variant is selected.
1054  /// - false, otherwise.
1055  bool IsMinus(void) const;
1056 
1057  /// Get the variant data.
1058  ///
1059  /// @return
1060  /// Reference to the data.
1061  const TMinus& GetMinus(void) const;
1062 
1063  /// Select the variant.
1064  ///
1065  /// @return
1066  /// Reference to the variant data.
1067  TMinus& SetMinus(void);
1068 
1069 
1070  /// Check if variant Power is selected.
1071  ///
1072  /// Power type is defined as 'typedef CPower TPower'.
1073  /// @return
1074  /// - true, if the variant is selected.
1075  /// - false, otherwise.
1076  bool IsPower(void) const;
1077 
1078  /// Get the variant data.
1079  ///
1080  /// @return
1081  /// Reference to the data.
1082  const TPower& GetPower(void) const;
1083 
1084  /// Select the variant.
1085  ///
1086  /// @return
1087  /// Reference to the variant data.
1088  TPower& SetPower(void);
1089 
1090 
1091  /// Check if variant Rem is selected.
1092  ///
1093  /// Rem type is defined as 'typedef CRem TRem'.
1094  /// @return
1095  /// - true, if the variant is selected.
1096  /// - false, otherwise.
1097  bool IsRem(void) const;
1098 
1099  /// Get the variant data.
1100  ///
1101  /// @return
1102  /// Reference to the data.
1103  const TRem& GetRem(void) const;
1104 
1105  /// Select the variant.
1106  ///
1107  /// @return
1108  /// Reference to the variant data.
1109  TRem& SetRem(void);
1110 
1111 
1112  /// Check if variant Root is selected.
1113  ///
1114  /// Root type is defined as 'typedef CRoot TRoot'.
1115  /// @return
1116  /// - true, if the variant is selected.
1117  /// - false, otherwise.
1118  bool IsRoot(void) const;
1119 
1120  /// Get the variant data.
1121  ///
1122  /// @return
1123  /// Reference to the data.
1124  const TRoot& GetRoot(void) const;
1125 
1126  /// Select the variant.
1127  ///
1128  /// @return
1129  /// Reference to the variant data.
1130  TRoot& SetRoot(void);
1131 
1132 
1133  private:
1134  // copy constructor and assignment operator
1137  // choice state
1139  // helper methods
1140  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
1141 
1142  static const char* const sm_SelectionNames[];
1143  // data
1144  NCBI_NS_NCBI::CSerialObject *m_object;
1145  };
1146  /////////////////////////////////////////////////////////////////////////////
1147  ///
1148  /// C_Unary_arith_mmlclass --
1149  ///
1150 
1152  {
1154  public:
1155  // constructor
1156  C_Unary_arith_mmlclass(void);
1157  // destructor
1159 
1160  // type info
1162 
1163 
1164  /// Choice variants.
1165  enum E_Choice {
1166  e_not_set = 0, ///< No variant selected
1175  e_Exp
1176  };
1177  /// Maximum+1 value of the choice variant enumerator.
1179  e_MaxChoice = 10 ///< == e_Exp+1
1180  };
1181 
1182  /// Reset the whole object
1183  void Reset(void);
1184 
1185  /// Reset the selection (set it to e_not_set).
1186  void ResetSelection(void);
1187 
1188  /// Which variant is currently selected.
1189  ///
1190  /// @return
1191  /// Choice state enumerator.
1192  E_Choice Which(void) const;
1193 
1194  /// Verify selection, throw exception if it differs from the expected.
1195  ///
1196  /// @param index
1197  /// Expected selection.
1198  void CheckSelected(E_Choice index) const;
1199 
1200  /// Throw 'InvalidSelection' exception.
1201  ///
1202  /// @param index
1203  /// Expected selection.
1204  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
1205 
1206  /// Retrieve selection name (for diagnostic purposes).
1207  ///
1208  /// @param index
1209  /// One of possible selection states.
1210  /// @return
1211  /// Name string.
1212  static string SelectionName(E_Choice index);
1213 
1214  /// Select the requested variant if needed.
1215  ///
1216  /// @param index
1217  /// New selection state.
1218  /// @param reset
1219  /// Flag that defines the resetting of the variant data. The data will
1220  /// be reset if either the current selection differs from the new one,
1221  /// or the flag is set to eDoResetVariant.
1223  /// Select the requested variant if needed,
1224  /// allocating CObject variants from memory pool.
1225  void Select(E_Choice index,
1226  EResetVariant reset,
1227  CObjectMemoryPool* pool);
1228 
1229  // types
1231  typedef CAbs TAbs;
1233  typedef CArg TArg;
1234  typedef CReal TReal;
1236  typedef CFloor TFloor;
1238  typedef CExp TExp;
1239 
1240  // getters
1241  // setters
1242 
1243 
1244  /// Check if variant Factorial is selected.
1245  ///
1246  /// Factorial type is defined as 'typedef CFactorial TFactorial'.
1247  /// @return
1248  /// - true, if the variant is selected.
1249  /// - false, otherwise.
1250  bool IsFactorial(void) const;
1251 
1252  /// Get the variant data.
1253  ///
1254  /// @return
1255  /// Reference to the data.
1256  const TFactorial& GetFactorial(void) const;
1257 
1258  /// Select the variant.
1259  ///
1260  /// @return
1261  /// Reference to the variant data.
1262  TFactorial& SetFactorial(void);
1263 
1264 
1265  /// Check if variant Abs is selected.
1266  ///
1267  /// Abs type is defined as 'typedef CAbs TAbs'.
1268  /// @return
1269  /// - true, if the variant is selected.
1270  /// - false, otherwise.
1271  bool IsAbs(void) const;
1272 
1273  /// Get the variant data.
1274  ///
1275  /// @return
1276  /// Reference to the data.
1277  const TAbs& GetAbs(void) const;
1278 
1279  /// Select the variant.
1280  ///
1281  /// @return
1282  /// Reference to the variant data.
1283  TAbs& SetAbs(void);
1284 
1285 
1286  /// Check if variant Conjugate is selected.
1287  ///
1288  /// Conjugate type is defined as 'typedef CConjugate TConjugate'.
1289  /// @return
1290  /// - true, if the variant is selected.
1291  /// - false, otherwise.
1292  bool IsConjugate(void) const;
1293 
1294  /// Get the variant data.
1295  ///
1296  /// @return
1297  /// Reference to the data.
1298  const TConjugate& GetConjugate(void) const;
1299 
1300  /// Select the variant.
1301  ///
1302  /// @return
1303  /// Reference to the variant data.
1304  TConjugate& SetConjugate(void);
1305 
1306 
1307  /// Check if variant Arg is selected.
1308  ///
1309  /// Arg type is defined as 'typedef CArg TArg'.
1310  /// @return
1311  /// - true, if the variant is selected.
1312  /// - false, otherwise.
1313  bool IsArg(void) const;
1314 
1315  /// Get the variant data.
1316  ///
1317  /// @return
1318  /// Reference to the data.
1319  const TArg& GetArg(void) const;
1320 
1321  /// Select the variant.
1322  ///
1323  /// @return
1324  /// Reference to the variant data.
1325  TArg& SetArg(void);
1326 
1327 
1328  /// Check if variant Real is selected.
1329  ///
1330  /// Real type is defined as 'typedef CReal TReal'.
1331  /// @return
1332  /// - true, if the variant is selected.
1333  /// - false, otherwise.
1334  bool IsReal(void) const;
1335 
1336  /// Get the variant data.
1337  ///
1338  /// @return
1339  /// Reference to the data.
1340  const TReal& GetReal(void) const;
1341 
1342  /// Select the variant.
1343  ///
1344  /// @return
1345  /// Reference to the variant data.
1346  TReal& SetReal(void);
1347 
1348 
1349  /// Check if variant Imaginary is selected.
1350  ///
1351  /// Imaginary type is defined as 'typedef CImaginary TImaginary'.
1352  /// @return
1353  /// - true, if the variant is selected.
1354  /// - false, otherwise.
1355  bool IsImaginary(void) const;
1356 
1357  /// Get the variant data.
1358  ///
1359  /// @return
1360  /// Reference to the data.
1361  const TImaginary& GetImaginary(void) const;
1362 
1363  /// Select the variant.
1364  ///
1365  /// @return
1366  /// Reference to the variant data.
1367  TImaginary& SetImaginary(void);
1368 
1369 
1370  /// Check if variant Floor is selected.
1371  ///
1372  /// Floor type is defined as 'typedef CFloor TFloor'.
1373  /// @return
1374  /// - true, if the variant is selected.
1375  /// - false, otherwise.
1376  bool IsFloor(void) const;
1377 
1378  /// Get the variant data.
1379  ///
1380  /// @return
1381  /// Reference to the data.
1382  const TFloor& GetFloor(void) const;
1383 
1384  /// Select the variant.
1385  ///
1386  /// @return
1387  /// Reference to the variant data.
1388  TFloor& SetFloor(void);
1389 
1390 
1391  /// Check if variant Ceiling is selected.
1392  ///
1393  /// Ceiling type is defined as 'typedef CCeiling TCeiling'.
1394  /// @return
1395  /// - true, if the variant is selected.
1396  /// - false, otherwise.
1397  bool IsCeiling(void) const;
1398 
1399  /// Get the variant data.
1400  ///
1401  /// @return
1402  /// Reference to the data.
1403  const TCeiling& GetCeiling(void) const;
1404 
1405  /// Select the variant.
1406  ///
1407  /// @return
1408  /// Reference to the variant data.
1409  TCeiling& SetCeiling(void);
1410 
1411 
1412  /// Check if variant Exp is selected.
1413  ///
1414  /// Exp type is defined as 'typedef CExp TExp'.
1415  /// @return
1416  /// - true, if the variant is selected.
1417  /// - false, otherwise.
1418  bool IsExp(void) const;
1419 
1420  /// Get the variant data.
1421  ///
1422  /// @return
1423  /// Reference to the data.
1424  const TExp& GetExp(void) const;
1425 
1426  /// Select the variant.
1427  ///
1428  /// @return
1429  /// Reference to the variant data.
1430  TExp& SetExp(void);
1431 
1432 
1433  private:
1434  // copy constructor and assignment operator
1437  // choice state
1439  // helper methods
1440  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
1441 
1442  static const char* const sm_SelectionNames[];
1443  // data
1444  NCBI_NS_NCBI::CSerialObject *m_object;
1445  };
1446  /////////////////////////////////////////////////////////////////////////////
1447  ///
1448  /// C_Nary_minmax_mmlclass --
1449  ///
1450 
1452  {
1454  public:
1455  // constructor
1456  C_Nary_minmax_mmlclass(void);
1457  // destructor
1459 
1460  // type info
1462 
1463 
1464  /// Choice variants.
1465  enum E_Choice {
1466  e_not_set = 0, ///< No variant selected
1468  e_Min
1469  };
1470  /// Maximum+1 value of the choice variant enumerator.
1472  e_MaxChoice = 3 ///< == e_Min+1
1473  };
1474 
1475  /// Reset the whole object
1476  void Reset(void);
1477 
1478  /// Reset the selection (set it to e_not_set).
1479  void ResetSelection(void);
1480 
1481  /// Which variant is currently selected.
1482  ///
1483  /// @return
1484  /// Choice state enumerator.
1485  E_Choice Which(void) const;
1486 
1487  /// Verify selection, throw exception if it differs from the expected.
1488  ///
1489  /// @param index
1490  /// Expected selection.
1491  void CheckSelected(E_Choice index) const;
1492 
1493  /// Throw 'InvalidSelection' exception.
1494  ///
1495  /// @param index
1496  /// Expected selection.
1497  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
1498 
1499  /// Retrieve selection name (for diagnostic purposes).
1500  ///
1501  /// @param index
1502  /// One of possible selection states.
1503  /// @return
1504  /// Name string.
1505  static string SelectionName(E_Choice index);
1506 
1507  /// Select the requested variant if needed.
1508  ///
1509  /// @param index
1510  /// New selection state.
1511  /// @param reset
1512  /// Flag that defines the resetting of the variant data. The data will
1513  /// be reset if either the current selection differs from the new one,
1514  /// or the flag is set to eDoResetVariant.
1516  /// Select the requested variant if needed,
1517  /// allocating CObject variants from memory pool.
1518  void Select(E_Choice index,
1519  EResetVariant reset,
1520  CObjectMemoryPool* pool);
1521 
1522  // types
1523  typedef CMax TMax;
1524  typedef CMin TMin;
1525 
1526  // getters
1527  // setters
1528 
1529 
1530  /// Check if variant Max is selected.
1531  ///
1532  /// Max type is defined as 'typedef CMax TMax'.
1533  /// @return
1534  /// - true, if the variant is selected.
1535  /// - false, otherwise.
1536  bool IsMax(void) const;
1537 
1538  /// Get the variant data.
1539  ///
1540  /// @return
1541  /// Reference to the data.
1542  const TMax& GetMax(void) const;
1543 
1544  /// Select the variant.
1545  ///
1546  /// @return
1547  /// Reference to the variant data.
1548  TMax& SetMax(void);
1549 
1550 
1551  /// Check if variant Min is selected.
1552  ///
1553  /// Min type is defined as 'typedef CMin TMin'.
1554  /// @return
1555  /// - true, if the variant is selected.
1556  /// - false, otherwise.
1557  bool IsMin(void) const;
1558 
1559  /// Get the variant data.
1560  ///
1561  /// @return
1562  /// Reference to the data.
1563  const TMin& GetMin(void) const;
1564 
1565  /// Select the variant.
1566  ///
1567  /// @return
1568  /// Reference to the variant data.
1569  TMin& SetMin(void);
1570 
1571 
1572  private:
1573  // copy constructor and assignment operator
1576  // choice state
1578  // helper methods
1579  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
1580 
1581  static const char* const sm_SelectionNames[];
1582  // data
1583  NCBI_NS_NCBI::CSerialObject *m_object;
1584  };
1585  /////////////////////////////////////////////////////////////////////////////
1586  ///
1587  /// C_Nary_arith_mmlclass --
1588  ///
1589 
1591  {
1593  public:
1594  // constructor
1595  C_Nary_arith_mmlclass(void);
1596  // destructor
1597  ~C_Nary_arith_mmlclass(void);
1598 
1599  // type info
1601 
1602 
1603  /// Choice variants.
1604  enum E_Choice {
1605  e_not_set = 0, ///< No variant selected
1609  e_Lcm
1610  };
1611  /// Maximum+1 value of the choice variant enumerator.
1613  e_MaxChoice = 5 ///< == e_Lcm+1
1614  };
1615 
1616  /// Reset the whole object
1617  void Reset(void);
1618 
1619  /// Reset the selection (set it to e_not_set).
1620  void ResetSelection(void);
1621 
1622  /// Which variant is currently selected.
1623  ///
1624  /// @return
1625  /// Choice state enumerator.
1626  E_Choice Which(void) const;
1627 
1628  /// Verify selection, throw exception if it differs from the expected.
1629  ///
1630  /// @param index
1631  /// Expected selection.
1632  void CheckSelected(E_Choice index) const;
1633 
1634  /// Throw 'InvalidSelection' exception.
1635  ///
1636  /// @param index
1637  /// Expected selection.
1638  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
1639 
1640  /// Retrieve selection name (for diagnostic purposes).
1641  ///
1642  /// @param index
1643  /// One of possible selection states.
1644  /// @return
1645  /// Name string.
1646  static string SelectionName(E_Choice index);
1647 
1648  /// Select the requested variant if needed.
1649  ///
1650  /// @param index
1651  /// New selection state.
1652  /// @param reset
1653  /// Flag that defines the resetting of the variant data. The data will
1654  /// be reset if either the current selection differs from the new one,
1655  /// or the flag is set to eDoResetVariant.
1657  /// Select the requested variant if needed,
1658  /// allocating CObject variants from memory pool.
1659  void Select(E_Choice index,
1660  EResetVariant reset,
1661  CObjectMemoryPool* pool);
1662 
1663  // types
1664  typedef CPlus TPlus;
1665  typedef CTimes TTimes;
1666  typedef CGcd TGcd;
1667  typedef CLcm TLcm;
1668 
1669  // getters
1670  // setters
1671 
1672 
1673  /// Check if variant Plus is selected.
1674  ///
1675  /// Plus type is defined as 'typedef CPlus TPlus'.
1676  /// @return
1677  /// - true, if the variant is selected.
1678  /// - false, otherwise.
1679  bool IsPlus(void) const;
1680 
1681  /// Get the variant data.
1682  ///
1683  /// @return
1684  /// Reference to the data.
1685  const TPlus& GetPlus(void) const;
1686 
1687  /// Select the variant.
1688  ///
1689  /// @return
1690  /// Reference to the variant data.
1691  TPlus& SetPlus(void);
1692 
1693 
1694  /// Check if variant Times is selected.
1695  ///
1696  /// Times type is defined as 'typedef CTimes TTimes'.
1697  /// @return
1698  /// - true, if the variant is selected.
1699  /// - false, otherwise.
1700  bool IsTimes(void) const;
1701 
1702  /// Get the variant data.
1703  ///
1704  /// @return
1705  /// Reference to the data.
1706  const TTimes& GetTimes(void) const;
1707 
1708  /// Select the variant.
1709  ///
1710  /// @return
1711  /// Reference to the variant data.
1712  TTimes& SetTimes(void);
1713 
1714 
1715  /// Check if variant Gcd is selected.
1716  ///
1717  /// Gcd type is defined as 'typedef CGcd TGcd'.
1718  /// @return
1719  /// - true, if the variant is selected.
1720  /// - false, otherwise.
1721  bool IsGcd(void) const;
1722 
1723  /// Get the variant data.
1724  ///
1725  /// @return
1726  /// Reference to the data.
1727  const TGcd& GetGcd(void) const;
1728 
1729  /// Select the variant.
1730  ///
1731  /// @return
1732  /// Reference to the variant data.
1733  TGcd& SetGcd(void);
1734 
1735 
1736  /// Check if variant Lcm is selected.
1737  ///
1738  /// Lcm type is defined as 'typedef CLcm TLcm'.
1739  /// @return
1740  /// - true, if the variant is selected.
1741  /// - false, otherwise.
1742  bool IsLcm(void) const;
1743 
1744  /// Get the variant data.
1745  ///
1746  /// @return
1747  /// Reference to the data.
1748  const TLcm& GetLcm(void) const;
1749 
1750  /// Select the variant.
1751  ///
1752  /// @return
1753  /// Reference to the variant data.
1754  TLcm& SetLcm(void);
1755 
1756 
1757  private:
1758  // copy constructor and assignment operator
1761  // choice state
1763  // helper methods
1764  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
1765 
1766  static const char* const sm_SelectionNames[];
1767  // data
1768  NCBI_NS_NCBI::CSerialObject *m_object;
1769  };
1770  /////////////////////////////////////////////////////////////////////////////
1771  ///
1772  /// C_Nary_logical_mmlclass --
1773  ///
1774 
1776  {
1778  public:
1779  // constructor
1781  // destructor
1783 
1784  // type info
1786 
1787 
1788  /// Choice variants.
1789  enum E_Choice {
1790  e_not_set = 0, ///< No variant selected
1793  e_Xor
1794  };
1795  /// Maximum+1 value of the choice variant enumerator.
1797  e_MaxChoice = 4 ///< == e_Xor+1
1798  };
1799 
1800  /// Reset the whole object
1801  void Reset(void);
1802 
1803  /// Reset the selection (set it to e_not_set).
1804  void ResetSelection(void);
1805 
1806  /// Which variant is currently selected.
1807  ///
1808  /// @return
1809  /// Choice state enumerator.
1810  E_Choice Which(void) const;
1811 
1812  /// Verify selection, throw exception if it differs from the expected.
1813  ///
1814  /// @param index
1815  /// Expected selection.
1816  void CheckSelected(E_Choice index) const;
1817 
1818  /// Throw 'InvalidSelection' exception.
1819  ///
1820  /// @param index
1821  /// Expected selection.
1822  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
1823 
1824  /// Retrieve selection name (for diagnostic purposes).
1825  ///
1826  /// @param index
1827  /// One of possible selection states.
1828  /// @return
1829  /// Name string.
1830  static string SelectionName(E_Choice index);
1831 
1832  /// Select the requested variant if needed.
1833  ///
1834  /// @param index
1835  /// New selection state.
1836  /// @param reset
1837  /// Flag that defines the resetting of the variant data. The data will
1838  /// be reset if either the current selection differs from the new one,
1839  /// or the flag is set to eDoResetVariant.
1841  /// Select the requested variant if needed,
1842  /// allocating CObject variants from memory pool.
1843  void Select(E_Choice index,
1844  EResetVariant reset,
1845  CObjectMemoryPool* pool);
1846 
1847  // types
1848  typedef CAnd TAnd;
1849  typedef COr TOr;
1850  typedef CXor TXor;
1851 
1852  // getters
1853  // setters
1854 
1855 
1856  /// Check if variant And is selected.
1857  ///
1858  /// And type is defined as 'typedef CAnd TAnd'.
1859  /// @return
1860  /// - true, if the variant is selected.
1861  /// - false, otherwise.
1862  bool IsAnd(void) const;
1863 
1864  /// Get the variant data.
1865  ///
1866  /// @return
1867  /// Reference to the data.
1868  const TAnd& GetAnd(void) const;
1869 
1870  /// Select the variant.
1871  ///
1872  /// @return
1873  /// Reference to the variant data.
1874  TAnd& SetAnd(void);
1875 
1876 
1877  /// Check if variant Or is selected.
1878  ///
1879  /// Or type is defined as 'typedef COr TOr'.
1880  /// @return
1881  /// - true, if the variant is selected.
1882  /// - false, otherwise.
1883  bool IsOr(void) const;
1884 
1885  /// Get the variant data.
1886  ///
1887  /// @return
1888  /// Reference to the data.
1889  const TOr& GetOr(void) const;
1890 
1891  /// Select the variant.
1892  ///
1893  /// @return
1894  /// Reference to the variant data.
1895  TOr& SetOr(void);
1896 
1897 
1898  /// Check if variant Xor is selected.
1899  ///
1900  /// Xor type is defined as 'typedef CXor TXor'.
1901  /// @return
1902  /// - true, if the variant is selected.
1903  /// - false, otherwise.
1904  bool IsXor(void) const;
1905 
1906  /// Get the variant data.
1907  ///
1908  /// @return
1909  /// Reference to the data.
1910  const TXor& GetXor(void) const;
1911 
1912  /// Select the variant.
1913  ///
1914  /// @return
1915  /// Reference to the variant data.
1916  TXor& SetXor(void);
1917 
1918 
1919  private:
1920  // copy constructor and assignment operator
1923  // choice state
1925  // helper methods
1926  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
1927 
1928  static const char* const sm_SelectionNames[];
1929  // data
1930  NCBI_NS_NCBI::CSerialObject *m_object;
1931  };
1932  /////////////////////////////////////////////////////////////////////////////
1933  ///
1934  /// C_Unary_logical_mmlclass --
1935  ///
1936 
1938  {
1940  public:
1941  // constructor
1943  // destructor
1945 
1946  // type info
1948 
1949  // types
1950  typedef CNot TNot;
1951 
1952  // member index
1953  enum class E_memberIndex {
1954  e__allMandatory = 0,
1955  e_not
1956  };
1958 
1959  // getters
1960  // setters
1961 
1962  /// Check if a value has been assigned to Not data member.
1963  ///
1964  /// Data member Not is mandatory;
1965  /// its type is defined as 'typedef CNot TNot'
1966  /// @return
1967  /// - true, if a value has been assigned.
1968  /// - false, otherwise.
1969  bool IsSetNot(void) const;
1970 
1971  /// Check if value of Not member is getatable.
1972  ///
1973  /// @return
1974  /// - false; the data member of type 'NULL' has no value.
1975  bool CanGetNot(void) const;
1976 
1977  /// Reset Not data member.
1978  void ResetNot(void);
1979 
1980  /// Get the Not member data.
1981  ///
1982  /// @return
1983  /// Reference to the member data.
1984  const TNot& GetNot(void) const;
1985 
1986  /// Assign a value to Not data member.
1987  ///
1988  /// @param value
1989  /// Reference to value.
1990  void SetNot(TNot& value);
1991 
1992  /// Assign a value to Not data member.
1993  ///
1994  /// @return
1995  /// Reference to the data value.
1996  TNot& SetNot(void);
1997 
1998  /// Reset the whole object
1999  void Reset(void);
2000 
2001 
2002  private:
2003  // Prohibit copy constructor and assignment operator
2006 
2007  // data
2010  };
2011  /////////////////////////////////////////////////////////////////////////////
2012  ///
2013  /// C_Binary_logical_mmlclass --
2014  ///
2015 
2017  {
2019  public:
2020  // constructor
2022  // destructor
2024 
2025  // type info
2027 
2028 
2029  /// Choice variants.
2030  enum E_Choice {
2031  e_not_set = 0, ///< No variant selected
2033  e_Equivalent
2034  };
2035  /// Maximum+1 value of the choice variant enumerator.
2037  e_MaxChoice = 3 ///< == e_Equivalent+1
2038  };
2039 
2040  /// Reset the whole object
2041  void Reset(void);
2042 
2043  /// Reset the selection (set it to e_not_set).
2044  void ResetSelection(void);
2045 
2046  /// Which variant is currently selected.
2047  ///
2048  /// @return
2049  /// Choice state enumerator.
2050  E_Choice Which(void) const;
2051 
2052  /// Verify selection, throw exception if it differs from the expected.
2053  ///
2054  /// @param index
2055  /// Expected selection.
2056  void CheckSelected(E_Choice index) const;
2057 
2058  /// Throw 'InvalidSelection' exception.
2059  ///
2060  /// @param index
2061  /// Expected selection.
2062  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
2063 
2064  /// Retrieve selection name (for diagnostic purposes).
2065  ///
2066  /// @param index
2067  /// One of possible selection states.
2068  /// @return
2069  /// Name string.
2070  static string SelectionName(E_Choice index);
2071 
2072  /// Select the requested variant if needed.
2073  ///
2074  /// @param index
2075  /// New selection state.
2076  /// @param reset
2077  /// Flag that defines the resetting of the variant data. The data will
2078  /// be reset if either the current selection differs from the new one,
2079  /// or the flag is set to eDoResetVariant.
2081  /// Select the requested variant if needed,
2082  /// allocating CObject variants from memory pool.
2083  void Select(E_Choice index,
2084  EResetVariant reset,
2085  CObjectMemoryPool* pool);
2086 
2087  // types
2090 
2091  // getters
2092  // setters
2093 
2094 
2095  /// Check if variant Implies is selected.
2096  ///
2097  /// Implies type is defined as 'typedef CImplies TImplies'.
2098  /// @return
2099  /// - true, if the variant is selected.
2100  /// - false, otherwise.
2101  bool IsImplies(void) const;
2102 
2103  /// Get the variant data.
2104  ///
2105  /// @return
2106  /// Reference to the data.
2107  const TImplies& GetImplies(void) const;
2108 
2109  /// Select the variant.
2110  ///
2111  /// @return
2112  /// Reference to the variant data.
2113  TImplies& SetImplies(void);
2114 
2115 
2116  /// Check if variant Equivalent is selected.
2117  ///
2118  /// Equivalent type is defined as 'typedef CEquivalent TEquivalent'.
2119  /// @return
2120  /// - true, if the variant is selected.
2121  /// - false, otherwise.
2122  bool IsEquivalent(void) const;
2123 
2124  /// Get the variant data.
2125  ///
2126  /// @return
2127  /// Reference to the data.
2128  const TEquivalent& GetEquivalent(void) const;
2129 
2130  /// Select the variant.
2131  ///
2132  /// @return
2133  /// Reference to the variant data.
2134  TEquivalent& SetEquivalent(void);
2135 
2136 
2137  private:
2138  // copy constructor and assignment operator
2141  // choice state
2143  // helper methods
2144  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
2145 
2146  static const char* const sm_SelectionNames[];
2147  // data
2148  NCBI_NS_NCBI::CSerialObject *m_object;
2149  };
2150  /////////////////////////////////////////////////////////////////////////////
2151  ///
2152  /// C_Quantifier_mmlclass --
2153  ///
2154 
2156  {
2158  public:
2159  // constructor
2160  C_Quantifier_mmlclass(void);
2161  // destructor
2162  ~C_Quantifier_mmlclass(void);
2163 
2164  // type info
2166 
2167 
2168  /// Choice variants.
2169  enum E_Choice {
2170  e_not_set = 0, ///< No variant selected
2172  e_Exists
2173  };
2174  /// Maximum+1 value of the choice variant enumerator.
2176  e_MaxChoice = 3 ///< == e_Exists+1
2177  };
2178 
2179  /// Reset the whole object
2180  void Reset(void);
2181 
2182  /// Reset the selection (set it to e_not_set).
2183  void ResetSelection(void);
2184 
2185  /// Which variant is currently selected.
2186  ///
2187  /// @return
2188  /// Choice state enumerator.
2189  E_Choice Which(void) const;
2190 
2191  /// Verify selection, throw exception if it differs from the expected.
2192  ///
2193  /// @param index
2194  /// Expected selection.
2195  void CheckSelected(E_Choice index) const;
2196 
2197  /// Throw 'InvalidSelection' exception.
2198  ///
2199  /// @param index
2200  /// Expected selection.
2201  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
2202 
2203  /// Retrieve selection name (for diagnostic purposes).
2204  ///
2205  /// @param index
2206  /// One of possible selection states.
2207  /// @return
2208  /// Name string.
2209  static string SelectionName(E_Choice index);
2210 
2211  /// Select the requested variant if needed.
2212  ///
2213  /// @param index
2214  /// New selection state.
2215  /// @param reset
2216  /// Flag that defines the resetting of the variant data. The data will
2217  /// be reset if either the current selection differs from the new one,
2218  /// or the flag is set to eDoResetVariant.
2220  /// Select the requested variant if needed,
2221  /// allocating CObject variants from memory pool.
2222  void Select(E_Choice index,
2223  EResetVariant reset,
2224  CObjectMemoryPool* pool);
2225 
2226  // types
2227  typedef CForall TForall;
2228  typedef CExists TExists;
2229 
2230  // getters
2231  // setters
2232 
2233 
2234  /// Check if variant Forall is selected.
2235  ///
2236  /// Forall type is defined as 'typedef CForall TForall'.
2237  /// @return
2238  /// - true, if the variant is selected.
2239  /// - false, otherwise.
2240  bool IsForall(void) const;
2241 
2242  /// Get the variant data.
2243  ///
2244  /// @return
2245  /// Reference to the data.
2246  const TForall& GetForall(void) const;
2247 
2248  /// Select the variant.
2249  ///
2250  /// @return
2251  /// Reference to the variant data.
2252  TForall& SetForall(void);
2253 
2254 
2255  /// Check if variant Exists is selected.
2256  ///
2257  /// Exists type is defined as 'typedef CExists TExists'.
2258  /// @return
2259  /// - true, if the variant is selected.
2260  /// - false, otherwise.
2261  bool IsExists(void) const;
2262 
2263  /// Get the variant data.
2264  ///
2265  /// @return
2266  /// Reference to the data.
2267  const TExists& GetExists(void) const;
2268 
2269  /// Select the variant.
2270  ///
2271  /// @return
2272  /// Reference to the variant data.
2273  TExists& SetExists(void);
2274 
2275 
2276  private:
2277  // copy constructor and assignment operator
2280  // choice state
2282  // helper methods
2283  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
2284 
2285  static const char* const sm_SelectionNames[];
2286  // data
2287  NCBI_NS_NCBI::CSerialObject *m_object;
2288  };
2289  /////////////////////////////////////////////////////////////////////////////
2290  ///
2291  /// C_Nary_reln_mmlclass --
2292  ///
2293 
2295  {
2297  public:
2298  // constructor
2299  C_Nary_reln_mmlclass(void);
2300  // destructor
2301  ~C_Nary_reln_mmlclass(void);
2302 
2303  // type info
2305 
2306 
2307  /// Choice variants.
2308  enum E_Choice {
2309  e_not_set = 0, ///< No variant selected
2314  e_Leq
2315  };
2316  /// Maximum+1 value of the choice variant enumerator.
2318  e_MaxChoice = 6 ///< == e_Leq+1
2319  };
2320 
2321  /// Reset the whole object
2322  void Reset(void);
2323 
2324  /// Reset the selection (set it to e_not_set).
2325  void ResetSelection(void);
2326 
2327  /// Which variant is currently selected.
2328  ///
2329  /// @return
2330  /// Choice state enumerator.
2331  E_Choice Which(void) const;
2332 
2333  /// Verify selection, throw exception if it differs from the expected.
2334  ///
2335  /// @param index
2336  /// Expected selection.
2337  void CheckSelected(E_Choice index) const;
2338 
2339  /// Throw 'InvalidSelection' exception.
2340  ///
2341  /// @param index
2342  /// Expected selection.
2343  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
2344 
2345  /// Retrieve selection name (for diagnostic purposes).
2346  ///
2347  /// @param index
2348  /// One of possible selection states.
2349  /// @return
2350  /// Name string.
2351  static string SelectionName(E_Choice index);
2352 
2353  /// Select the requested variant if needed.
2354  ///
2355  /// @param index
2356  /// New selection state.
2357  /// @param reset
2358  /// Flag that defines the resetting of the variant data. The data will
2359  /// be reset if either the current selection differs from the new one,
2360  /// or the flag is set to eDoResetVariant.
2362  /// Select the requested variant if needed,
2363  /// allocating CObject variants from memory pool.
2364  void Select(E_Choice index,
2365  EResetVariant reset,
2366  CObjectMemoryPool* pool);
2367 
2368  // types
2369  typedef CEq TEq;
2370  typedef CGt TGt;
2371  typedef CLt TLt;
2372  typedef CGeq TGeq;
2373  typedef CLeq TLeq;
2374 
2375  // getters
2376  // setters
2377 
2378 
2379  /// Check if variant Eq is selected.
2380  ///
2381  /// Eq type is defined as 'typedef CEq TEq'.
2382  /// @return
2383  /// - true, if the variant is selected.
2384  /// - false, otherwise.
2385  bool IsEq(void) const;
2386 
2387  /// Get the variant data.
2388  ///
2389  /// @return
2390  /// Reference to the data.
2391  const TEq& GetEq(void) const;
2392 
2393  /// Select the variant.
2394  ///
2395  /// @return
2396  /// Reference to the variant data.
2397  TEq& SetEq(void);
2398 
2399 
2400  /// Check if variant Gt is selected.
2401  ///
2402  /// Gt type is defined as 'typedef CGt TGt'.
2403  /// @return
2404  /// - true, if the variant is selected.
2405  /// - false, otherwise.
2406  bool IsGt(void) const;
2407 
2408  /// Get the variant data.
2409  ///
2410  /// @return
2411  /// Reference to the data.
2412  const TGt& GetGt(void) const;
2413 
2414  /// Select the variant.
2415  ///
2416  /// @return
2417  /// Reference to the variant data.
2418  TGt& SetGt(void);
2419 
2420 
2421  /// Check if variant Lt is selected.
2422  ///
2423  /// Lt type is defined as 'typedef CLt TLt'.
2424  /// @return
2425  /// - true, if the variant is selected.
2426  /// - false, otherwise.
2427  bool IsLt(void) const;
2428 
2429  /// Get the variant data.
2430  ///
2431  /// @return
2432  /// Reference to the data.
2433  const TLt& GetLt(void) const;
2434 
2435  /// Select the variant.
2436  ///
2437  /// @return
2438  /// Reference to the variant data.
2439  TLt& SetLt(void);
2440 
2441 
2442  /// Check if variant Geq is selected.
2443  ///
2444  /// Geq type is defined as 'typedef CGeq TGeq'.
2445  /// @return
2446  /// - true, if the variant is selected.
2447  /// - false, otherwise.
2448  bool IsGeq(void) const;
2449 
2450  /// Get the variant data.
2451  ///
2452  /// @return
2453  /// Reference to the data.
2454  const TGeq& GetGeq(void) const;
2455 
2456  /// Select the variant.
2457  ///
2458  /// @return
2459  /// Reference to the variant data.
2460  TGeq& SetGeq(void);
2461 
2462 
2463  /// Check if variant Leq is selected.
2464  ///
2465  /// Leq type is defined as 'typedef CLeq TLeq'.
2466  /// @return
2467  /// - true, if the variant is selected.
2468  /// - false, otherwise.
2469  bool IsLeq(void) const;
2470 
2471  /// Get the variant data.
2472  ///
2473  /// @return
2474  /// Reference to the data.
2475  const TLeq& GetLeq(void) const;
2476 
2477  /// Select the variant.
2478  ///
2479  /// @return
2480  /// Reference to the variant data.
2481  TLeq& SetLeq(void);
2482 
2483 
2484  private:
2485  // copy constructor and assignment operator
2488  // choice state
2490  // helper methods
2491  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
2492 
2493  static const char* const sm_SelectionNames[];
2494  // data
2495  NCBI_NS_NCBI::CSerialObject *m_object;
2496  };
2497  /////////////////////////////////////////////////////////////////////////////
2498  ///
2499  /// C_Binary_reln_mmlclass --
2500  ///
2501 
2503  {
2505  public:
2506  // constructor
2507  C_Binary_reln_mmlclass(void);
2508  // destructor
2510 
2511  // type info
2513 
2514 
2515  /// Choice variants.
2516  enum E_Choice {
2517  e_not_set = 0, ///< No variant selected
2521  e_Tendsto
2522  };
2523  /// Maximum+1 value of the choice variant enumerator.
2525  e_MaxChoice = 5 ///< == e_Tendsto+1
2526  };
2527 
2528  /// Reset the whole object
2529  void Reset(void);
2530 
2531  /// Reset the selection (set it to e_not_set).
2532  void ResetSelection(void);
2533 
2534  /// Which variant is currently selected.
2535  ///
2536  /// @return
2537  /// Choice state enumerator.
2538  E_Choice Which(void) const;
2539 
2540  /// Verify selection, throw exception if it differs from the expected.
2541  ///
2542  /// @param index
2543  /// Expected selection.
2544  void CheckSelected(E_Choice index) const;
2545 
2546  /// Throw 'InvalidSelection' exception.
2547  ///
2548  /// @param index
2549  /// Expected selection.
2550  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
2551 
2552  /// Retrieve selection name (for diagnostic purposes).
2553  ///
2554  /// @param index
2555  /// One of possible selection states.
2556  /// @return
2557  /// Name string.
2558  static string SelectionName(E_Choice index);
2559 
2560  /// Select the requested variant if needed.
2561  ///
2562  /// @param index
2563  /// New selection state.
2564  /// @param reset
2565  /// Flag that defines the resetting of the variant data. The data will
2566  /// be reset if either the current selection differs from the new one,
2567  /// or the flag is set to eDoResetVariant.
2569  /// Select the requested variant if needed,
2570  /// allocating CObject variants from memory pool.
2571  void Select(E_Choice index,
2572  EResetVariant reset,
2573  CObjectMemoryPool* pool);
2574 
2575  // types
2576  typedef CNeq TNeq;
2577  typedef CApprox TApprox;
2580 
2581  // getters
2582  // setters
2583 
2584 
2585  /// Check if variant Neq is selected.
2586  ///
2587  /// Neq type is defined as 'typedef CNeq TNeq'.
2588  /// @return
2589  /// - true, if the variant is selected.
2590  /// - false, otherwise.
2591  bool IsNeq(void) const;
2592 
2593  /// Get the variant data.
2594  ///
2595  /// @return
2596  /// Reference to the data.
2597  const TNeq& GetNeq(void) const;
2598 
2599  /// Select the variant.
2600  ///
2601  /// @return
2602  /// Reference to the variant data.
2603  TNeq& SetNeq(void);
2604 
2605 
2606  /// Check if variant Approx is selected.
2607  ///
2608  /// Approx type is defined as 'typedef CApprox TApprox'.
2609  /// @return
2610  /// - true, if the variant is selected.
2611  /// - false, otherwise.
2612  bool IsApprox(void) const;
2613 
2614  /// Get the variant data.
2615  ///
2616  /// @return
2617  /// Reference to the data.
2618  const TApprox& GetApprox(void) const;
2619 
2620  /// Select the variant.
2621  ///
2622  /// @return
2623  /// Reference to the variant data.
2624  TApprox& SetApprox(void);
2625 
2626 
2627  /// Check if variant Factorof is selected.
2628  ///
2629  /// Factorof type is defined as 'typedef CFactorof TFactorof'.
2630  /// @return
2631  /// - true, if the variant is selected.
2632  /// - false, otherwise.
2633  bool IsFactorof(void) const;
2634 
2635  /// Get the variant data.
2636  ///
2637  /// @return
2638  /// Reference to the data.
2639  const TFactorof& GetFactorof(void) const;
2640 
2641  /// Select the variant.
2642  ///
2643  /// @return
2644  /// Reference to the variant data.
2645  TFactorof& SetFactorof(void);
2646 
2647 
2648  /// Check if variant Tendsto is selected.
2649  ///
2650  /// Tendsto type is defined as 'typedef CTendsto TTendsto'.
2651  /// @return
2652  /// - true, if the variant is selected.
2653  /// - false, otherwise.
2654  bool IsTendsto(void) const;
2655 
2656  /// Get the variant data.
2657  ///
2658  /// @return
2659  /// Reference to the data.
2660  const TTendsto& GetTendsto(void) const;
2661 
2662  /// Select the variant.
2663  ///
2664  /// @return
2665  /// Reference to the variant data.
2666  TTendsto& SetTendsto(void);
2667 
2668 
2669  private:
2670  // copy constructor and assignment operator
2673  // choice state
2675  // helper methods
2676  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
2677 
2678  static const char* const sm_SelectionNames[];
2679  // data
2680  NCBI_NS_NCBI::CSerialObject *m_object;
2681  };
2682  /////////////////////////////////////////////////////////////////////////////
2683  ///
2684  /// C_Int_mmlclass --
2685  ///
2686 
2688  {
2690  public:
2691  // constructor
2692  C_Int_mmlclass(void);
2693  // destructor
2694  ~C_Int_mmlclass(void);
2695 
2696  // type info
2698 
2699  // types
2700  typedef CInt TInt;
2701 
2702  // member index
2703  enum class E_memberIndex {
2704  e__allMandatory = 0,
2705  e_int
2706  };
2708 
2709  // getters
2710  // setters
2711 
2712  /// Check if a value has been assigned to Int data member.
2713  ///
2714  /// Data member Int is mandatory;
2715  /// its type is defined as 'typedef CInt TInt'
2716  /// @return
2717  /// - true, if a value has been assigned.
2718  /// - false, otherwise.
2719  bool IsSetInt(void) const;
2720 
2721  /// Check if value of Int member is getatable.
2722  ///
2723  /// @return
2724  /// - false; the data member of type 'NULL' has no value.
2725  bool CanGetInt(void) const;
2726 
2727  /// Reset Int data member.
2728  void ResetInt(void);
2729 
2730  /// Get the Int member data.
2731  ///
2732  /// @return
2733  /// Reference to the member data.
2734  const TInt& GetInt(void) const;
2735 
2736  /// Assign a value to Int data member.
2737  ///
2738  /// @param value
2739  /// Reference to value.
2740  void SetInt(TInt& value);
2741 
2742  /// Assign a value to Int data member.
2743  ///
2744  /// @return
2745  /// Reference to the data value.
2746  TInt& SetInt(void);
2747 
2748  /// Reset the whole object
2749  void Reset(void);
2750 
2751 
2752  private:
2753  // Prohibit copy constructor and assignment operator
2756 
2757  // data
2760  };
2761  /////////////////////////////////////////////////////////////////////////////
2762  ///
2763  /// C_Differential_Operator_mmlclass --
2764  ///
2765 
2767  {
2769  public:
2770  // constructor
2772  // destructor
2774 
2775  // type info
2777 
2778  // types
2779  typedef CDiff TDiff;
2780 
2781  // member index
2782  enum class E_memberIndex {
2783  e__allMandatory = 0,
2784  e_diff
2785  };
2787 
2788  // getters
2789  // setters
2790 
2791  /// Check if a value has been assigned to Diff data member.
2792  ///
2793  /// Data member Diff is mandatory;
2794  /// its type is defined as 'typedef CDiff TDiff'
2795  /// @return
2796  /// - true, if a value has been assigned.
2797  /// - false, otherwise.
2798  bool IsSetDiff(void) const;
2799 
2800  /// Check if value of Diff member is getatable.
2801  ///
2802  /// @return
2803  /// - false; the data member of type 'NULL' has no value.
2804  bool CanGetDiff(void) const;
2805 
2806  /// Reset Diff data member.
2807  void ResetDiff(void);
2808 
2809  /// Get the Diff member data.
2810  ///
2811  /// @return
2812  /// Reference to the member data.
2813  const TDiff& GetDiff(void) const;
2814 
2815  /// Assign a value to Diff data member.
2816  ///
2817  /// @param value
2818  /// Reference to value.
2819  void SetDiff(TDiff& value);
2820 
2821  /// Assign a value to Diff data member.
2822  ///
2823  /// @return
2824  /// Reference to the data value.
2825  TDiff& SetDiff(void);
2826 
2827  /// Reset the whole object
2828  void Reset(void);
2829 
2830 
2831  private:
2832  // Prohibit copy constructor and assignment operator
2835 
2836  // data
2839  };
2840  /////////////////////////////////////////////////////////////////////////////
2841  ///
2842  /// C_Partialdiff_mmlclass --
2843  ///
2844 
2846  {
2848  public:
2849  // constructor
2850  C_Partialdiff_mmlclass(void);
2851  // destructor
2853 
2854  // type info
2856 
2857  // types
2859 
2860  // member index
2861  enum class E_memberIndex {
2862  e__allMandatory = 0,
2864  };
2866 
2867  // getters
2868  // setters
2869 
2870  /// Check if a value has been assigned to Partialdiff data member.
2871  ///
2872  /// Data member Partialdiff is mandatory;
2873  /// its type is defined as 'typedef CPartialdiff TPartialdiff'
2874  /// @return
2875  /// - true, if a value has been assigned.
2876  /// - false, otherwise.
2877  bool IsSetPartialdiff(void) const;
2878 
2879  /// Check if value of Partialdiff member is getatable.
2880  ///
2881  /// @return
2882  /// - false; the data member of type 'NULL' has no value.
2883  bool CanGetPartialdiff(void) const;
2884 
2885  /// Reset Partialdiff data member.
2886  void ResetPartialdiff(void);
2887 
2888  /// Get the Partialdiff member data.
2889  ///
2890  /// @return
2891  /// Reference to the member data.
2892  const TPartialdiff& GetPartialdiff(void) const;
2893 
2894  /// Assign a value to Partialdiff data member.
2895  ///
2896  /// @param value
2897  /// Reference to value.
2899 
2900  /// Assign a value to Partialdiff data member.
2901  ///
2902  /// @return
2903  /// Reference to the data value.
2905 
2906  /// Reset the whole object
2907  void Reset(void);
2908 
2909 
2910  private:
2911  // Prohibit copy constructor and assignment operator
2914 
2915  // data
2918  };
2919  /////////////////////////////////////////////////////////////////////////////
2920  ///
2921  /// C_Unary_veccalc_mmlclass --
2922  ///
2923 
2925  {
2927  public:
2928  // constructor
2930  // destructor
2932 
2933  // type info
2935 
2936 
2937  /// Choice variants.
2938  enum E_Choice {
2939  e_not_set = 0, ///< No variant selected
2943  e_Laplacian
2944  };
2945  /// Maximum+1 value of the choice variant enumerator.
2947  e_MaxChoice = 5 ///< == e_Laplacian+1
2948  };
2949 
2950  /// Reset the whole object
2951  void Reset(void);
2952 
2953  /// Reset the selection (set it to e_not_set).
2954  void ResetSelection(void);
2955 
2956  /// Which variant is currently selected.
2957  ///
2958  /// @return
2959  /// Choice state enumerator.
2960  E_Choice Which(void) const;
2961 
2962  /// Verify selection, throw exception if it differs from the expected.
2963  ///
2964  /// @param index
2965  /// Expected selection.
2966  void CheckSelected(E_Choice index) const;
2967 
2968  /// Throw 'InvalidSelection' exception.
2969  ///
2970  /// @param index
2971  /// Expected selection.
2972  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
2973 
2974  /// Retrieve selection name (for diagnostic purposes).
2975  ///
2976  /// @param index
2977  /// One of possible selection states.
2978  /// @return
2979  /// Name string.
2980  static string SelectionName(E_Choice index);
2981 
2982  /// Select the requested variant if needed.
2983  ///
2984  /// @param index
2985  /// New selection state.
2986  /// @param reset
2987  /// Flag that defines the resetting of the variant data. The data will
2988  /// be reset if either the current selection differs from the new one,
2989  /// or the flag is set to eDoResetVariant.
2991  /// Select the requested variant if needed,
2992  /// allocating CObject variants from memory pool.
2993  void Select(E_Choice index,
2994  EResetVariant reset,
2995  CObjectMemoryPool* pool);
2996 
2997  // types
2999  typedef CGrad TGrad;
3000  typedef CCurl TCurl;
3002 
3003  // getters
3004  // setters
3005 
3006 
3007  /// Check if variant Divergence is selected.
3008  ///
3009  /// Divergence type is defined as 'typedef CDivergence TDivergence'.
3010  /// @return
3011  /// - true, if the variant is selected.
3012  /// - false, otherwise.
3013  bool IsDivergence(void) const;
3014 
3015  /// Get the variant data.
3016  ///
3017  /// @return
3018  /// Reference to the data.
3019  const TDivergence& GetDivergence(void) const;
3020 
3021  /// Select the variant.
3022  ///
3023  /// @return
3024  /// Reference to the variant data.
3025  TDivergence& SetDivergence(void);
3026 
3027 
3028  /// Check if variant Grad is selected.
3029  ///
3030  /// Grad type is defined as 'typedef CGrad TGrad'.
3031  /// @return
3032  /// - true, if the variant is selected.
3033  /// - false, otherwise.
3034  bool IsGrad(void) const;
3035 
3036  /// Get the variant data.
3037  ///
3038  /// @return
3039  /// Reference to the data.
3040  const TGrad& GetGrad(void) const;
3041 
3042  /// Select the variant.
3043  ///
3044  /// @return
3045  /// Reference to the variant data.
3046  TGrad& SetGrad(void);
3047 
3048 
3049  /// Check if variant Curl is selected.
3050  ///
3051  /// Curl type is defined as 'typedef CCurl TCurl'.
3052  /// @return
3053  /// - true, if the variant is selected.
3054  /// - false, otherwise.
3055  bool IsCurl(void) const;
3056 
3057  /// Get the variant data.
3058  ///
3059  /// @return
3060  /// Reference to the data.
3061  const TCurl& GetCurl(void) const;
3062 
3063  /// Select the variant.
3064  ///
3065  /// @return
3066  /// Reference to the variant data.
3067  TCurl& SetCurl(void);
3068 
3069 
3070  /// Check if variant Laplacian is selected.
3071  ///
3072  /// Laplacian type is defined as 'typedef CLaplacian TLaplacian'.
3073  /// @return
3074  /// - true, if the variant is selected.
3075  /// - false, otherwise.
3076  bool IsLaplacian(void) const;
3077 
3078  /// Get the variant data.
3079  ///
3080  /// @return
3081  /// Reference to the data.
3082  const TLaplacian& GetLaplacian(void) const;
3083 
3084  /// Select the variant.
3085  ///
3086  /// @return
3087  /// Reference to the variant data.
3088  TLaplacian& SetLaplacian(void);
3089 
3090 
3091  private:
3092  // copy constructor and assignment operator
3095  // choice state
3097  // helper methods
3098  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
3099 
3100  static const char* const sm_SelectionNames[];
3101  // data
3102  NCBI_NS_NCBI::CSerialObject *m_object;
3103  };
3104  /////////////////////////////////////////////////////////////////////////////
3105  ///
3106  /// C_Nary_setlist_constructor_mmlclass --
3107  ///
3108 
3110  {
3112  public:
3113  // constructor
3115  // destructor
3117 
3118  // type info
3120 
3121 
3122  /// Choice variants.
3123  enum E_Choice {
3124  e_not_set = 0, ///< No variant selected
3126  e_List
3127  };
3128  /// Maximum+1 value of the choice variant enumerator.
3130  e_MaxChoice = 3 ///< == e_List+1
3131  };
3132 
3133  /// Reset the whole object
3134  void Reset(void);
3135 
3136  /// Reset the selection (set it to e_not_set).
3137  void ResetSelection(void);
3138 
3139  /// Which variant is currently selected.
3140  ///
3141  /// @return
3142  /// Choice state enumerator.
3143  E_Choice Which(void) const;
3144 
3145  /// Verify selection, throw exception if it differs from the expected.
3146  ///
3147  /// @param index
3148  /// Expected selection.
3149  void CheckSelected(E_Choice index) const;
3150 
3151  /// Throw 'InvalidSelection' exception.
3152  ///
3153  /// @param index
3154  /// Expected selection.
3155  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
3156 
3157  /// Retrieve selection name (for diagnostic purposes).
3158  ///
3159  /// @param index
3160  /// One of possible selection states.
3161  /// @return
3162  /// Name string.
3163  static string SelectionName(E_Choice index);
3164 
3165  /// Select the requested variant if needed.
3166  ///
3167  /// @param index
3168  /// New selection state.
3169  /// @param reset
3170  /// Flag that defines the resetting of the variant data. The data will
3171  /// be reset if either the current selection differs from the new one,
3172  /// or the flag is set to eDoResetVariant.
3174  /// Select the requested variant if needed,
3175  /// allocating CObject variants from memory pool.
3176  void Select(E_Choice index,
3177  EResetVariant reset,
3178  CObjectMemoryPool* pool);
3179 
3180  // types
3181  typedef CSet TSet;
3182  typedef CList TList;
3183 
3184  // getters
3185  // setters
3186 
3187 
3188  /// Check if variant Set is selected.
3189  ///
3190  /// Set type is defined as 'typedef CSet TSet'.
3191  /// @return
3192  /// - true, if the variant is selected.
3193  /// - false, otherwise.
3194  bool IsSet(void) const;
3195 
3196  /// Get the variant data.
3197  ///
3198  /// @return
3199  /// Reference to the data.
3200  const TSet& GetSet(void) const;
3201 
3202  /// Select the variant.
3203  ///
3204  /// @return
3205  /// Reference to the variant data.
3206  TSet& SetSet(void);
3207  /// Select the variant and set its data.
3208  ///
3209  /// @param value
3210  /// Reference to the data.
3211  void SetSet(TSet& value);
3212 
3213 
3214  /// Check if variant List is selected.
3215  ///
3216  /// List type is defined as 'typedef CList TList'.
3217  /// @return
3218  /// - true, if the variant is selected.
3219  /// - false, otherwise.
3220  bool IsList(void) const;
3221 
3222  /// Get the variant data.
3223  ///
3224  /// @return
3225  /// Reference to the data.
3226  const TList& GetList(void) const;
3227 
3228  /// Select the variant.
3229  ///
3230  /// @return
3231  /// Reference to the variant data.
3232  TList& SetList(void);
3233  /// Select the variant and set its data.
3234  ///
3235  /// @param value
3236  /// Reference to the data.
3237  void SetList(TList& value);
3238 
3239 
3240  private:
3241  // copy constructor and assignment operator
3244  // choice state
3246  // helper methods
3247  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
3248 
3249  static const char* const sm_SelectionNames[];
3250  // data
3251  NCBI_NS_NCBI::CSerialObject *m_object;
3252  };
3253  /////////////////////////////////////////////////////////////////////////////
3254  ///
3255  /// C_Nary_set_mmlclass --
3256  ///
3257 
3259  {
3261  public:
3262  // constructor
3263  C_Nary_set_mmlclass(void);
3264  // destructor
3265  ~C_Nary_set_mmlclass(void);
3266 
3267  // type info
3269 
3270 
3271  /// Choice variants.
3272  enum E_Choice {
3273  e_not_set = 0, ///< No variant selected
3277  };
3278  /// Maximum+1 value of the choice variant enumerator.
3280  e_MaxChoice = 4 ///< == e_Cartesianproduct+1
3281  };
3282 
3283  /// Reset the whole object
3284  void Reset(void);
3285 
3286  /// Reset the selection (set it to e_not_set).
3287  void ResetSelection(void);
3288 
3289  /// Which variant is currently selected.
3290  ///
3291  /// @return
3292  /// Choice state enumerator.
3293  E_Choice Which(void) const;
3294 
3295  /// Verify selection, throw exception if it differs from the expected.
3296  ///
3297  /// @param index
3298  /// Expected selection.
3299  void CheckSelected(E_Choice index) const;
3300 
3301  /// Throw 'InvalidSelection' exception.
3302  ///
3303  /// @param index
3304  /// Expected selection.
3305  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
3306 
3307  /// Retrieve selection name (for diagnostic purposes).
3308  ///
3309  /// @param index
3310  /// One of possible selection states.
3311  /// @return
3312  /// Name string.
3313  static string SelectionName(E_Choice index);
3314 
3315  /// Select the requested variant if needed.
3316  ///
3317  /// @param index
3318  /// New selection state.
3319  /// @param reset
3320  /// Flag that defines the resetting of the variant data. The data will
3321  /// be reset if either the current selection differs from the new one,
3322  /// or the flag is set to eDoResetVariant.
3324  /// Select the requested variant if needed,
3325  /// allocating CObject variants from memory pool.
3326  void Select(E_Choice index,
3327  EResetVariant reset,
3328  CObjectMemoryPool* pool);
3329 
3330  // types
3331  typedef CUnion TUnion;
3334 
3335  // getters
3336  // setters
3337 
3338 
3339  /// Check if variant Union is selected.
3340  ///
3341  /// Union type is defined as 'typedef CUnion TUnion'.
3342  /// @return
3343  /// - true, if the variant is selected.
3344  /// - false, otherwise.
3345  bool IsUnion(void) const;
3346 
3347  /// Get the variant data.
3348  ///
3349  /// @return
3350  /// Reference to the data.
3351  const TUnion& GetUnion(void) const;
3352 
3353  /// Select the variant.
3354  ///
3355  /// @return
3356  /// Reference to the variant data.
3357  TUnion& SetUnion(void);
3358 
3359 
3360  /// Check if variant Intersect is selected.
3361  ///
3362  /// Intersect type is defined as 'typedef CIntersect TIntersect'.
3363  /// @return
3364  /// - true, if the variant is selected.
3365  /// - false, otherwise.
3366  bool IsIntersect(void) const;
3367 
3368  /// Get the variant data.
3369  ///
3370  /// @return
3371  /// Reference to the data.
3372  const TIntersect& GetIntersect(void) const;
3373 
3374  /// Select the variant.
3375  ///
3376  /// @return
3377  /// Reference to the variant data.
3378  TIntersect& SetIntersect(void);
3379 
3380 
3381  /// Check if variant Cartesianproduct is selected.
3382  ///
3383  /// Cartesianproduct type is defined as 'typedef CCartesianproduct TCartesianproduct'.
3384  /// @return
3385  /// - true, if the variant is selected.
3386  /// - false, otherwise.
3387  bool IsCartesianproduct(void) const;
3388 
3389  /// Get the variant data.
3390  ///
3391  /// @return
3392  /// Reference to the data.
3393  const TCartesianproduct& GetCartesianproduct(void) const;
3394 
3395  /// Select the variant.
3396  ///
3397  /// @return
3398  /// Reference to the variant data.
3400 
3401 
3402  private:
3403  // copy constructor and assignment operator
3406  // choice state
3408  // helper methods
3409  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
3410 
3411  static const char* const sm_SelectionNames[];
3412  // data
3413  NCBI_NS_NCBI::CSerialObject *m_object;
3414  };
3415  /////////////////////////////////////////////////////////////////////////////
3416  ///
3417  /// C_Binary_set_mmlclass --
3418  ///
3419 
3421  {
3423  public:
3424  // constructor
3425  C_Binary_set_mmlclass(void);
3426  // destructor
3427  ~C_Binary_set_mmlclass(void);
3428 
3429  // type info
3431 
3432 
3433  /// Choice variants.
3434  enum E_Choice {
3435  e_not_set = 0, ///< No variant selected
3440  e_Setdiff
3441  };
3442  /// Maximum+1 value of the choice variant enumerator.
3444  e_MaxChoice = 6 ///< == e_Setdiff+1
3445  };
3446 
3447  /// Reset the whole object
3448  void Reset(void);
3449 
3450  /// Reset the selection (set it to e_not_set).
3451  void ResetSelection(void);
3452 
3453  /// Which variant is currently selected.
3454  ///
3455  /// @return
3456  /// Choice state enumerator.
3457  E_Choice Which(void) const;
3458 
3459  /// Verify selection, throw exception if it differs from the expected.
3460  ///
3461  /// @param index
3462  /// Expected selection.
3463  void CheckSelected(E_Choice index) const;
3464 
3465  /// Throw 'InvalidSelection' exception.
3466  ///
3467  /// @param index
3468  /// Expected selection.
3469  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
3470 
3471  /// Retrieve selection name (for diagnostic purposes).
3472  ///
3473  /// @param index
3474  /// One of possible selection states.
3475  /// @return
3476  /// Name string.
3477  static string SelectionName(E_Choice index);
3478 
3479  /// Select the requested variant if needed.
3480  ///
3481  /// @param index
3482  /// New selection state.
3483  /// @param reset
3484  /// Flag that defines the resetting of the variant data. The data will
3485  /// be reset if either the current selection differs from the new one,
3486  /// or the flag is set to eDoResetVariant.
3488  /// Select the requested variant if needed,
3489  /// allocating CObject variants from memory pool.
3490  void Select(E_Choice index,
3491  EResetVariant reset,
3492  CObjectMemoryPool* pool);
3493 
3494  // types
3495  typedef CIn TIn;
3496  typedef CNotin TNotin;
3500 
3501  // getters
3502  // setters
3503 
3504 
3505  /// Check if variant In is selected.
3506  ///
3507  /// In type is defined as 'typedef CIn TIn'.
3508  /// @return
3509  /// - true, if the variant is selected.
3510  /// - false, otherwise.
3511  bool IsIn(void) const;
3512 
3513  /// Get the variant data.
3514  ///
3515  /// @return
3516  /// Reference to the data.
3517  const TIn& GetIn(void) const;
3518 
3519  /// Select the variant.
3520  ///
3521  /// @return
3522  /// Reference to the variant data.
3523  TIn& SetIn(void);
3524 
3525 
3526  /// Check if variant Notin is selected.
3527  ///
3528  /// Notin type is defined as 'typedef CNotin TNotin'.
3529  /// @return
3530  /// - true, if the variant is selected.
3531  /// - false, otherwise.
3532  bool IsNotin(void) const;
3533 
3534  /// Get the variant data.
3535  ///
3536  /// @return
3537  /// Reference to the data.
3538  const TNotin& GetNotin(void) const;
3539 
3540  /// Select the variant.
3541  ///
3542  /// @return
3543  /// Reference to the variant data.
3544  TNotin& SetNotin(void);
3545 
3546 
3547  /// Check if variant Notsubset is selected.
3548  ///
3549  /// Notsubset type is defined as 'typedef CNotsubset TNotsubset'.
3550  /// @return
3551  /// - true, if the variant is selected.
3552  /// - false, otherwise.
3553  bool IsNotsubset(void) const;
3554 
3555  /// Get the variant data.
3556  ///
3557  /// @return
3558  /// Reference to the data.
3559  const TNotsubset& GetNotsubset(void) const;
3560 
3561  /// Select the variant.
3562  ///
3563  /// @return
3564  /// Reference to the variant data.
3565  TNotsubset& SetNotsubset(void);
3566 
3567 
3568  /// Check if variant Notprsubset is selected.
3569  ///
3570  /// Notprsubset type is defined as 'typedef CNotprsubset TNotprsubset'.
3571  /// @return
3572  /// - true, if the variant is selected.
3573  /// - false, otherwise.
3574  bool IsNotprsubset(void) const;
3575 
3576  /// Get the variant data.
3577  ///
3578  /// @return
3579  /// Reference to the data.
3580  const TNotprsubset& GetNotprsubset(void) const;
3581 
3582  /// Select the variant.
3583  ///
3584  /// @return
3585  /// Reference to the variant data.
3587 
3588 
3589  /// Check if variant Setdiff is selected.
3590  ///
3591  /// Setdiff type is defined as 'typedef CSetdiff TSetdiff'.
3592  /// @return
3593  /// - true, if the variant is selected.
3594  /// - false, otherwise.
3595  bool IsSetdiff(void) const;
3596 
3597  /// Get the variant data.
3598  ///
3599  /// @return
3600  /// Reference to the data.
3601  const TSetdiff& GetSetdiff(void) const;
3602 
3603  /// Select the variant.
3604  ///
3605  /// @return
3606  /// Reference to the variant data.
3607  TSetdiff& SetSetdiff(void);
3608 
3609 
3610  private:
3611  // copy constructor and assignment operator
3614  // choice state
3616  // helper methods
3617  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
3618 
3619  static const char* const sm_SelectionNames[];
3620  // data
3621  NCBI_NS_NCBI::CSerialObject *m_object;
3622  };
3623  /////////////////////////////////////////////////////////////////////////////
3624  ///
3625  /// C_Nary_set_reln_mmlclass --
3626  ///
3627 
3629  {
3631  public:
3632  // constructor
3634  // destructor
3636 
3637  // type info
3639 
3640 
3641  /// Choice variants.
3642  enum E_Choice {
3643  e_not_set = 0, ///< No variant selected
3645  e_Prsubset
3646  };
3647  /// Maximum+1 value of the choice variant enumerator.
3649  e_MaxChoice = 3 ///< == e_Prsubset+1
3650  };
3651 
3652  /// Reset the whole object
3653  void Reset(void);
3654 
3655  /// Reset the selection (set it to e_not_set).
3656  void ResetSelection(void);
3657 
3658  /// Which variant is currently selected.
3659  ///
3660  /// @return
3661  /// Choice state enumerator.
3662  E_Choice Which(void) const;
3663 
3664  /// Verify selection, throw exception if it differs from the expected.
3665  ///
3666  /// @param index
3667  /// Expected selection.
3668  void CheckSelected(E_Choice index) const;
3669 
3670  /// Throw 'InvalidSelection' exception.
3671  ///
3672  /// @param index
3673  /// Expected selection.
3674  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
3675 
3676  /// Retrieve selection name (for diagnostic purposes).
3677  ///
3678  /// @param index
3679  /// One of possible selection states.
3680  /// @return
3681  /// Name string.
3682  static string SelectionName(E_Choice index);
3683 
3684  /// Select the requested variant if needed.
3685  ///
3686  /// @param index
3687  /// New selection state.
3688  /// @param reset
3689  /// Flag that defines the resetting of the variant data. The data will
3690  /// be reset if either the current selection differs from the new one,
3691  /// or the flag is set to eDoResetVariant.
3693  /// Select the requested variant if needed,
3694  /// allocating CObject variants from memory pool.
3695  void Select(E_Choice index,
3696  EResetVariant reset,
3697  CObjectMemoryPool* pool);
3698 
3699  // types
3700  typedef CSubset TSubset;
3702 
3703  // getters
3704  // setters
3705 
3706 
3707  /// Check if variant Subset is selected.
3708  ///
3709  /// Subset type is defined as 'typedef CSubset TSubset'.
3710  /// @return
3711  /// - true, if the variant is selected.
3712  /// - false, otherwise.
3713  bool IsSubset(void) const;
3714 
3715  /// Get the variant data.
3716  ///
3717  /// @return
3718  /// Reference to the data.
3719  const TSubset& GetSubset(void) const;
3720 
3721  /// Select the variant.
3722  ///
3723  /// @return
3724  /// Reference to the variant data.
3725  TSubset& SetSubset(void);
3726 
3727 
3728  /// Check if variant Prsubset is selected.
3729  ///
3730  /// Prsubset type is defined as 'typedef CPrsubset TPrsubset'.
3731  /// @return
3732  /// - true, if the variant is selected.
3733  /// - false, otherwise.
3734  bool IsPrsubset(void) const;
3735 
3736  /// Get the variant data.
3737  ///
3738  /// @return
3739  /// Reference to the data.
3740  const TPrsubset& GetPrsubset(void) const;
3741 
3742  /// Select the variant.
3743  ///
3744  /// @return
3745  /// Reference to the variant data.
3746  TPrsubset& SetPrsubset(void);
3747 
3748 
3749  private:
3750  // copy constructor and assignment operator
3753  // choice state
3755  // helper methods
3756  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
3757 
3758  static const char* const sm_SelectionNames[];
3759  // data
3760  NCBI_NS_NCBI::CSerialObject *m_object;
3761  };
3762  /////////////////////////////////////////////////////////////////////////////
3763  ///
3764  /// C_Unary_set_mmlclass --
3765  ///
3766 
3768  {
3770  public:
3771  // constructor
3772  C_Unary_set_mmlclass(void);
3773  // destructor
3774  ~C_Unary_set_mmlclass(void);
3775 
3776  // type info
3778 
3779  // types
3780  typedef CCard TCard;
3781 
3782  // member index
3783  enum class E_memberIndex {
3784  e__allMandatory = 0,
3785  e_card
3786  };
3788 
3789  // getters
3790  // setters
3791 
3792  /// Check if a value has been assigned to Card data member.
3793  ///
3794  /// Data member Card is mandatory;
3795  /// its type is defined as 'typedef CCard TCard'
3796  /// @return
3797  /// - true, if a value has been assigned.
3798  /// - false, otherwise.
3799  bool IsSetCard(void) const;
3800 
3801  /// Check if value of Card member is getatable.
3802  ///
3803  /// @return
3804  /// - false; the data member of type 'NULL' has no value.
3805  bool CanGetCard(void) const;
3806 
3807  /// Reset Card data member.
3808  void ResetCard(void);
3809 
3810  /// Get the Card member data.
3811  ///
3812  /// @return
3813  /// Reference to the member data.
3814  const TCard& GetCard(void) const;
3815 
3816  /// Assign a value to Card data member.
3817  ///
3818  /// @param value
3819  /// Reference to value.
3820  void SetCard(TCard& value);
3821 
3822  /// Assign a value to Card data member.
3823  ///
3824  /// @return
3825  /// Reference to the data value.
3826  TCard& SetCard(void);
3827 
3828  /// Reset the whole object
3829  void Reset(void);
3830 
3831 
3832  private:
3833  // Prohibit copy constructor and assignment operator
3836 
3837  // data
3840  };
3841  /////////////////////////////////////////////////////////////////////////////
3842  ///
3843  /// C_Sum_mmlclass --
3844  ///
3845 
3847  {
3849  public:
3850  // constructor
3851  C_Sum_mmlclass(void);
3852  // destructor
3853  ~C_Sum_mmlclass(void);
3854 
3855  // type info
3857 
3858  // types
3859  typedef CSum TSum;
3860 
3861  // member index
3862  enum class E_memberIndex {
3863  e__allMandatory = 0,
3864  e_sum
3865  };
3867 
3868  // getters
3869  // setters
3870 
3871  /// Check if a value has been assigned to Sum data member.
3872  ///
3873  /// Data member Sum is mandatory;
3874  /// its type is defined as 'typedef CSum TSum'
3875  /// @return
3876  /// - true, if a value has been assigned.
3877  /// - false, otherwise.
3878  bool IsSetSum(void) const;
3879 
3880  /// Check if value of Sum member is getatable.
3881  ///
3882  /// @return
3883  /// - false; the data member of type 'NULL' has no value.
3884  bool CanGetSum(void) const;
3885 
3886  /// Reset Sum data member.
3887  void ResetSum(void);
3888 
3889  /// Get the Sum member data.
3890  ///
3891  /// @return
3892  /// Reference to the member data.
3893  const TSum& GetSum(void) const;
3894 
3895  /// Assign a value to Sum data member.
3896  ///
3897  /// @param value
3898  /// Reference to value.
3899  void SetSum(TSum& value);
3900 
3901  /// Assign a value to Sum data member.
3902  ///
3903  /// @return
3904  /// Reference to the data value.
3905  TSum& SetSum(void);
3906 
3907  /// Reset the whole object
3908  void Reset(void);
3909 
3910 
3911  private:
3912  // Prohibit copy constructor and assignment operator
3915 
3916  // data
3919  };
3920  /////////////////////////////////////////////////////////////////////////////
3921  ///
3922  /// C_Product_mmlclass --
3923  ///
3924 
3926  {
3928  public:
3929  // constructor
3930  C_Product_mmlclass(void);
3931  // destructor
3932  ~C_Product_mmlclass(void);
3933 
3934  // type info
3936 
3937  // types
3939 
3940  // member index
3941  enum class E_memberIndex {
3942  e__allMandatory = 0,
3943  e_product
3944  };
3946 
3947  // getters
3948  // setters
3949 
3950  /// Check if a value has been assigned to Product data member.
3951  ///
3952  /// Data member Product is mandatory;
3953  /// its type is defined as 'typedef CProduct TProduct'
3954  /// @return
3955  /// - true, if a value has been assigned.
3956  /// - false, otherwise.
3957  bool IsSetProduct(void) const;
3958 
3959  /// Check if value of Product member is getatable.
3960  ///
3961  /// @return
3962  /// - false; the data member of type 'NULL' has no value.
3963  bool CanGetProduct(void) const;
3964 
3965  /// Reset Product data member.
3966  void ResetProduct(void);
3967 
3968  /// Get the Product member data.
3969  ///
3970  /// @return
3971  /// Reference to the member data.
3972  const TProduct& GetProduct(void) const;
3973 
3974  /// Assign a value to Product data member.
3975  ///
3976  /// @param value
3977  /// Reference to value.
3978  void SetProduct(TProduct& value);
3979 
3980  /// Assign a value to Product data member.
3981  ///
3982  /// @return
3983  /// Reference to the data value.
3984  TProduct& SetProduct(void);
3985 
3986  /// Reset the whole object
3987  void Reset(void);
3988 
3989 
3990  private:
3991  // Prohibit copy constructor and assignment operator
3994 
3995  // data
3998  };
3999  /////////////////////////////////////////////////////////////////////////////
4000  ///
4001  /// C_Limit_mmlclass --
4002  ///
4003 
4005  {
4007  public:
4008  // constructor
4009  C_Limit_mmlclass(void);
4010  // destructor
4011  ~C_Limit_mmlclass(void);
4012 
4013  // type info
4015 
4016  // types
4017  typedef CLimit TLimit;
4018 
4019  // member index
4020  enum class E_memberIndex {
4021  e__allMandatory = 0,
4022  e_limit
4023  };
4025 
4026  // getters
4027  // setters
4028 
4029  /// Check if a value has been assigned to Limit data member.
4030  ///
4031  /// Data member Limit is mandatory;
4032  /// its type is defined as 'typedef CLimit TLimit'
4033  /// @return
4034  /// - true, if a value has been assigned.
4035  /// - false, otherwise.
4036  bool IsSetLimit(void) const;
4037 
4038  /// Check if value of Limit member is getatable.
4039  ///
4040  /// @return
4041  /// - false; the data member of type 'NULL' has no value.
4042  bool CanGetLimit(void) const;
4043 
4044  /// Reset Limit data member.
4045  void ResetLimit(void);
4046 
4047  /// Get the Limit member data.
4048  ///
4049  /// @return
4050  /// Reference to the member data.
4051  const TLimit& GetLimit(void) const;
4052 
4053  /// Assign a value to Limit data member.
4054  ///
4055  /// @param value
4056  /// Reference to value.
4057  void SetLimit(TLimit& value);
4058 
4059  /// Assign a value to Limit data member.
4060  ///
4061  /// @return
4062  /// Reference to the data value.
4063  TLimit& SetLimit(void);
4064 
4065  /// Reset the whole object
4066  void Reset(void);
4067 
4068 
4069  private:
4070  // Prohibit copy constructor and assignment operator
4073 
4074  // data
4077  };
4078  /////////////////////////////////////////////////////////////////////////////
4079  ///
4080  /// C_Unary_elementary_mmlclass --
4081  ///
4082 
4084  {
4086  public:
4087  // constructor
4089  // destructor
4091 
4092  // type info
4094 
4095 
4096  /// Choice variants.
4097  enum E_Choice {
4098  e_not_set = 0, ///< No variant selected
4122  e_Arctanh
4123  };
4124  /// Maximum+1 value of the choice variant enumerator.
4126  e_MaxChoice = 25 ///< == e_Arctanh+1
4127  };
4128 
4129  /// Reset the whole object
4130  void Reset(void);
4131 
4132  /// Reset the selection (set it to e_not_set).
4133  void ResetSelection(void);
4134 
4135  /// Which variant is currently selected.
4136  ///
4137  /// @return
4138  /// Choice state enumerator.
4139  E_Choice Which(void) const;
4140 
4141  /// Verify selection, throw exception if it differs from the expected.
4142  ///
4143  /// @param index
4144  /// Expected selection.
4145  void CheckSelected(E_Choice index) const;
4146 
4147  /// Throw 'InvalidSelection' exception.
4148  ///
4149  /// @param index
4150  /// Expected selection.
4151  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
4152 
4153  /// Retrieve selection name (for diagnostic purposes).
4154  ///
4155  /// @param index
4156  /// One of possible selection states.
4157  /// @return
4158  /// Name string.
4159  static string SelectionName(E_Choice index);
4160 
4161  /// Select the requested variant if needed.
4162  ///
4163  /// @param index
4164  /// New selection state.
4165  /// @param reset
4166  /// Flag that defines the resetting of the variant data. The data will
4167  /// be reset if either the current selection differs from the new one,
4168  /// or the flag is set to eDoResetVariant.
4170  /// Select the requested variant if needed,
4171  /// allocating CObject variants from memory pool.
4172  void Select(E_Choice index,
4173  EResetVariant reset,
4174  CObjectMemoryPool* pool);
4175 
4176  // types
4177  typedef CSin TSin;
4178  typedef CCos TCos;
4179  typedef CTan TTan;
4180  typedef CSec TSec;
4181  typedef CCsc TCsc;
4182  typedef CCot TCot;
4183  typedef CSinh TSinh;
4184  typedef CCosh TCosh;
4185  typedef CTanh TTanh;
4186  typedef CSech TSech;
4187  typedef CCsch TCsch;
4188  typedef CCoth TCoth;
4189  typedef CArcsin TArcsin;
4190  typedef CArccos TArccos;
4191  typedef CArctan TArctan;
4193  typedef CArccot TArccot;
4195  typedef CArccsc TArccsc;
4197  typedef CArcsec TArcsec;
4201 
4202  // getters
4203  // setters
4204 
4205 
4206  /// Check if variant Sin is selected.
4207  ///
4208  /// Sin type is defined as 'typedef CSin TSin'.
4209  /// @return
4210  /// - true, if the variant is selected.
4211  /// - false, otherwise.
4212  bool IsSin(void) const;
4213 
4214  /// Get the variant data.
4215  ///
4216  /// @return
4217  /// Reference to the data.
4218  const TSin& GetSin(void) const;
4219 
4220  /// Select the variant.
4221  ///
4222  /// @return
4223  /// Reference to the variant data.
4224  TSin& SetSin(void);
4225 
4226 
4227  /// Check if variant Cos is selected.
4228  ///
4229  /// Cos type is defined as 'typedef CCos TCos'.
4230  /// @return
4231  /// - true, if the variant is selected.
4232  /// - false, otherwise.
4233  bool IsCos(void) const;
4234 
4235  /// Get the variant data.
4236  ///
4237  /// @return
4238  /// Reference to the data.
4239  const TCos& GetCos(void) const;
4240 
4241  /// Select the variant.
4242  ///
4243  /// @return
4244  /// Reference to the variant data.
4245  TCos& SetCos(void);
4246 
4247 
4248  /// Check if variant Tan is selected.
4249  ///
4250  /// Tan type is defined as 'typedef CTan TTan'.
4251  /// @return
4252  /// - true, if the variant is selected.
4253  /// - false, otherwise.
4254  bool IsTan(void) const;
4255 
4256  /// Get the variant data.
4257  ///
4258  /// @return
4259  /// Reference to the data.
4260  const TTan& GetTan(void) const;
4261 
4262  /// Select the variant.
4263  ///
4264  /// @return
4265  /// Reference to the variant data.
4266  TTan& SetTan(void);
4267 
4268 
4269  /// Check if variant Sec is selected.
4270  ///
4271  /// Sec type is defined as 'typedef CSec TSec'.
4272  /// @return
4273  /// - true, if the variant is selected.
4274  /// - false, otherwise.
4275  bool IsSec(void) const;
4276 
4277  /// Get the variant data.
4278  ///
4279  /// @return
4280  /// Reference to the data.
4281  const TSec& GetSec(void) const;
4282 
4283  /// Select the variant.
4284  ///
4285  /// @return
4286  /// Reference to the variant data.
4287  TSec& SetSec(void);
4288 
4289 
4290  /// Check if variant Csc is selected.
4291  ///
4292  /// Csc type is defined as 'typedef CCsc TCsc'.
4293  /// @return
4294  /// - true, if the variant is selected.
4295  /// - false, otherwise.
4296  bool IsCsc(void) const;
4297 
4298  /// Get the variant data.
4299  ///
4300  /// @return
4301  /// Reference to the data.
4302  const TCsc& GetCsc(void) const;
4303 
4304  /// Select the variant.
4305  ///
4306  /// @return
4307  /// Reference to the variant data.
4308  TCsc& SetCsc(void);
4309 
4310 
4311  /// Check if variant Cot is selected.
4312  ///
4313  /// Cot type is defined as 'typedef CCot TCot'.
4314  /// @return
4315  /// - true, if the variant is selected.
4316  /// - false, otherwise.
4317  bool IsCot(void) const;
4318 
4319  /// Get the variant data.
4320  ///
4321  /// @return
4322  /// Reference to the data.
4323  const TCot& GetCot(void) const;
4324 
4325  /// Select the variant.
4326  ///
4327  /// @return
4328  /// Reference to the variant data.
4329  TCot& SetCot(void);
4330 
4331 
4332  /// Check if variant Sinh is selected.
4333  ///
4334  /// Sinh type is defined as 'typedef CSinh TSinh'.
4335  /// @return
4336  /// - true, if the variant is selected.
4337  /// - false, otherwise.
4338  bool IsSinh(void) const;
4339 
4340  /// Get the variant data.
4341  ///
4342  /// @return
4343  /// Reference to the data.
4344  const TSinh& GetSinh(void) const;
4345 
4346  /// Select the variant.
4347  ///
4348  /// @return
4349  /// Reference to the variant data.
4350  TSinh& SetSinh(void);
4351 
4352 
4353  /// Check if variant Cosh is selected.
4354  ///
4355  /// Cosh type is defined as 'typedef CCosh TCosh'.
4356  /// @return
4357  /// - true, if the variant is selected.
4358  /// - false, otherwise.
4359  bool IsCosh(void) const;
4360 
4361  /// Get the variant data.
4362  ///
4363  /// @return
4364  /// Reference to the data.
4365  const TCosh& GetCosh(void) const;
4366 
4367  /// Select the variant.
4368  ///
4369  /// @return
4370  /// Reference to the variant data.
4371  TCosh& SetCosh(void);
4372 
4373 
4374  /// Check if variant Tanh is selected.
4375  ///
4376  /// Tanh type is defined as 'typedef CTanh TTanh'.
4377  /// @return
4378  /// - true, if the variant is selected.
4379  /// - false, otherwise.
4380  bool IsTanh(void) const;
4381 
4382  /// Get the variant data.
4383  ///
4384  /// @return
4385  /// Reference to the data.
4386  const TTanh& GetTanh(void) const;
4387 
4388  /// Select the variant.
4389  ///
4390  /// @return
4391  /// Reference to the variant data.
4392  TTanh& SetTanh(void);
4393 
4394 
4395  /// Check if variant Sech is selected.
4396  ///
4397  /// Sech type is defined as 'typedef CSech TSech'.
4398  /// @return
4399  /// - true, if the variant is selected.
4400  /// - false, otherwise.
4401  bool IsSech(void) const;
4402 
4403  /// Get the variant data.
4404  ///
4405  /// @return
4406  /// Reference to the data.
4407  const TSech& GetSech(void) const;
4408 
4409  /// Select the variant.
4410  ///
4411  /// @return
4412  /// Reference to the variant data.
4413  TSech& SetSech(void);
4414 
4415 
4416  /// Check if variant Csch is selected.
4417  ///
4418  /// Csch type is defined as 'typedef CCsch TCsch'.
4419  /// @return
4420  /// - true, if the variant is selected.
4421  /// - false, otherwise.
4422  bool IsCsch(void) const;
4423 
4424  /// Get the variant data.
4425  ///
4426  /// @return
4427  /// Reference to the data.
4428  const TCsch& GetCsch(void) const;
4429 
4430  /// Select the variant.
4431  ///
4432  /// @return
4433  /// Reference to the variant data.
4434  TCsch& SetCsch(void);
4435 
4436 
4437  /// Check if variant Coth is selected.
4438  ///
4439  /// Coth type is defined as 'typedef CCoth TCoth'.
4440  /// @return
4441  /// - true, if the variant is selected.
4442  /// - false, otherwise.
4443  bool IsCoth(void) const;
4444 
4445  /// Get the variant data.
4446  ///
4447  /// @return
4448  /// Reference to the data.
4449  const TCoth& GetCoth(void) const;
4450 
4451  /// Select the variant.
4452  ///
4453  /// @return
4454  /// Reference to the variant data.
4455  TCoth& SetCoth(void);
4456 
4457 
4458  /// Check if variant Arcsin is selected.
4459  ///
4460  /// Arcsin type is defined as 'typedef CArcsin TArcsin'.
4461  /// @return
4462  /// - true, if the variant is selected.
4463  /// - false, otherwise.
4464  bool IsArcsin(void) const;
4465 
4466  /// Get the variant data.
4467  ///
4468  /// @return
4469  /// Reference to the data.
4470  const TArcsin& GetArcsin(void) const;
4471 
4472  /// Select the variant.
4473  ///
4474  /// @return
4475  /// Reference to the variant data.
4476  TArcsin& SetArcsin(void);
4477 
4478 
4479  /// Check if variant Arccos is selected.
4480  ///
4481  /// Arccos type is defined as 'typedef CArccos TArccos'.
4482  /// @return
4483  /// - true, if the variant is selected.
4484  /// - false, otherwise.
4485  bool IsArccos(void) const;
4486 
4487  /// Get the variant data.
4488  ///
4489  /// @return
4490  /// Reference to the data.
4491  const TArccos& GetArccos(void) const;
4492 
4493  /// Select the variant.
4494  ///
4495  /// @return
4496  /// Reference to the variant data.
4497  TArccos& SetArccos(void);
4498 
4499 
4500  /// Check if variant Arctan is selected.
4501  ///
4502  /// Arctan type is defined as 'typedef CArctan TArctan'.
4503  /// @return
4504  /// - true, if the variant is selected.
4505  /// - false, otherwise.
4506  bool IsArctan(void) const;
4507 
4508  /// Get the variant data.
4509  ///
4510  /// @return
4511  /// Reference to the data.
4512  const TArctan& GetArctan(void) const;
4513 
4514  /// Select the variant.
4515  ///
4516  /// @return
4517  /// Reference to the variant data.
4518  TArctan& SetArctan(void);
4519 
4520 
4521  /// Check if variant Arccosh is selected.
4522  ///
4523  /// Arccosh type is defined as 'typedef CArccosh TArccosh'.
4524  /// @return
4525  /// - true, if the variant is selected.
4526  /// - false, otherwise.
4527  bool IsArccosh(void) const;
4528 
4529  /// Get the variant data.
4530  ///
4531  /// @return
4532  /// Reference to the data.
4533  const TArccosh& GetArccosh(void) const;
4534 
4535  /// Select the variant.
4536  ///
4537  /// @return
4538  /// Reference to the variant data.
4539  TArccosh& SetArccosh(void);
4540 
4541 
4542  /// Check if variant Arccot is selected.
4543  ///
4544  /// Arccot type is defined as 'typedef CArccot TArccot'.
4545  /// @return
4546  /// - true, if the variant is selected.
4547  /// - false, otherwise.
4548  bool IsArccot(void) const;
4549 
4550  /// Get the variant data.
4551  ///
4552  /// @return
4553  /// Reference to the data.
4554  const TArccot& GetArccot(void) const;
4555 
4556  /// Select the variant.
4557  ///
4558  /// @return
4559  /// Reference to the variant data.
4560  TArccot& SetArccot(void);
4561 
4562 
4563  /// Check if variant Arccoth is selected.
4564  ///
4565  /// Arccoth type is defined as 'typedef CArccoth TArccoth'.
4566  /// @return
4567  /// - true, if the variant is selected.
4568  /// - false, otherwise.
4569  bool IsArccoth(void) const;
4570 
4571  /// Get the variant data.
4572  ///
4573  /// @return
4574  /// Reference to the data.
4575  const TArccoth& GetArccoth(void) const;
4576 
4577  /// Select the variant.
4578  ///
4579  /// @return
4580  /// Reference to the variant data.
4581  TArccoth& SetArccoth(void);
4582 
4583 
4584  /// Check if variant Arccsc is selected.
4585  ///
4586  /// Arccsc type is defined as 'typedef CArccsc TArccsc'.
4587  /// @return
4588  /// - true, if the variant is selected.
4589  /// - false, otherwise.
4590  bool IsArccsc(void) const;
4591 
4592  /// Get the variant data.
4593  ///
4594  /// @return
4595  /// Reference to the data.
4596  const TArccsc& GetArccsc(void) const;
4597 
4598  /// Select the variant.
4599  ///
4600  /// @return
4601  /// Reference to the variant data.
4602  TArccsc& SetArccsc(void);
4603 
4604 
4605  /// Check if variant Arccsch is selected.
4606  ///
4607  /// Arccsch type is defined as 'typedef CArccsch TArccsch'.
4608  /// @return
4609  /// - true, if the variant is selected.
4610  /// - false, otherwise.
4611  bool IsArccsch(void) const;
4612 
4613  /// Get the variant data.
4614  ///
4615  /// @return
4616  /// Reference to the data.
4617  const TArccsch& GetArccsch(void) const;
4618 
4619  /// Select the variant.
4620  ///
4621  /// @return
4622  /// Reference to the variant data.
4623  TArccsch& SetArccsch(void);
4624 
4625 
4626  /// Check if variant Arcsec is selected.
4627  ///
4628  /// Arcsec type is defined as 'typedef CArcsec TArcsec'.
4629  /// @return
4630  /// - true, if the variant is selected.
4631  /// - false, otherwise.
4632  bool IsArcsec(void) const;
4633 
4634  /// Get the variant data.
4635  ///
4636  /// @return
4637  /// Reference to the data.
4638  const TArcsec& GetArcsec(void) const;
4639 
4640  /// Select the variant.
4641  ///
4642  /// @return
4643  /// Reference to the variant data.
4644  TArcsec& SetArcsec(void);
4645 
4646 
4647  /// Check if variant Arcsech is selected.
4648  ///
4649  /// Arcsech type is defined as 'typedef CArcsech TArcsech'.
4650  /// @return
4651  /// - true, if the variant is selected.
4652  /// - false, otherwise.
4653  bool IsArcsech(void) const;
4654 
4655  /// Get the variant data.
4656  ///
4657  /// @return
4658  /// Reference to the data.
4659  const TArcsech& GetArcsech(void) const;
4660 
4661  /// Select the variant.
4662  ///
4663  /// @return
4664  /// Reference to the variant data.
4665  TArcsech& SetArcsech(void);
4666 
4667 
4668  /// Check if variant Arcsinh is selected.
4669  ///
4670  /// Arcsinh type is defined as 'typedef CArcsinh TArcsinh'.
4671  /// @return
4672  /// - true, if the variant is selected.
4673  /// - false, otherwise.
4674  bool IsArcsinh(void) const;
4675 
4676  /// Get the variant data.
4677  ///
4678  /// @return
4679  /// Reference to the data.
4680  const TArcsinh& GetArcsinh(void) const;
4681 
4682  /// Select the variant.
4683  ///
4684  /// @return
4685  /// Reference to the variant data.
4686  TArcsinh& SetArcsinh(void);
4687 
4688 
4689  /// Check if variant Arctanh is selected.
4690  ///
4691  /// Arctanh type is defined as 'typedef CArctanh TArctanh'.
4692  /// @return
4693  /// - true, if the variant is selected.
4694  /// - false, otherwise.
4695  bool IsArctanh(void) const;
4696 
4697  /// Get the variant data.
4698  ///
4699  /// @return
4700  /// Reference to the data.
4701  const TArctanh& GetArctanh(void) const;
4702 
4703  /// Select the variant.
4704  ///
4705  /// @return
4706  /// Reference to the variant data.
4707  TArctanh& SetArctanh(void);
4708 
4709 
4710  private:
4711  // copy constructor and assignment operator
4714  // choice state
4716  // helper methods
4717  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
4718 
4719  static const char* const sm_SelectionNames[];
4720  // data
4721  NCBI_NS_NCBI::CSerialObject *m_object;
4722  };
4723  /////////////////////////////////////////////////////////////////////////////
4724  ///
4725  /// C_Nary_stats_mmlclass --
4726  ///
4727 
4729  {
4731  public:
4732  // constructor
4733  C_Nary_stats_mmlclass(void);
4734  // destructor
4735  ~C_Nary_stats_mmlclass(void);
4736 
4737  // type info
4739 
4740 
4741  /// Choice variants.
4742  enum E_Choice {
4743  e_not_set = 0, ///< No variant selected
4748  e_Mode
4749  };
4750  /// Maximum+1 value of the choice variant enumerator.
4752  e_MaxChoice = 6 ///< == e_Mode+1
4753  };
4754 
4755  /// Reset the whole object
4756  void Reset(void);
4757 
4758  /// Reset the selection (set it to e_not_set).
4759  void ResetSelection(void);
4760 
4761  /// Which variant is currently selected.
4762  ///
4763  /// @return
4764  /// Choice state enumerator.
4765  E_Choice Which(void) const;
4766 
4767  /// Verify selection, throw exception if it differs from the expected.
4768  ///
4769  /// @param index
4770  /// Expected selection.
4771  void CheckSelected(E_Choice index) const;
4772 
4773  /// Throw 'InvalidSelection' exception.
4774  ///
4775  /// @param index
4776  /// Expected selection.
4777  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
4778 
4779  /// Retrieve selection name (for diagnostic purposes).
4780  ///
4781  /// @param index
4782  /// One of possible selection states.
4783  /// @return
4784  /// Name string.
4785  static string SelectionName(E_Choice index);
4786 
4787  /// Select the requested variant if needed.
4788  ///
4789  /// @param index
4790  /// New selection state.
4791  /// @param reset
4792  /// Flag that defines the resetting of the variant data. The data will
4793  /// be reset if either the current selection differs from the new one,
4794  /// or the flag is set to eDoResetVariant.
4796  /// Select the requested variant if needed,
4797  /// allocating CObject variants from memory pool.
4798  void Select(E_Choice index,
4799  EResetVariant reset,
4800  CObjectMemoryPool* pool);
4801 
4802  // types
4803  typedef CMean TMean;
4804  typedef CSdev TSdev;
4806  typedef CMedian TMedian;
4807  typedef CMode TMode;
4808 
4809  // getters
4810  // setters
4811 
4812 
4813  /// Check if variant Mean is selected.
4814  ///
4815  /// Mean type is defined as 'typedef CMean TMean'.
4816  /// @return
4817  /// - true, if the variant is selected.
4818  /// - false, otherwise.
4819  bool IsMean(void) const;
4820 
4821  /// Get the variant data.
4822  ///
4823  /// @return
4824  /// Reference to the data.
4825  const TMean& GetMean(void) const;
4826 
4827  /// Select the variant.
4828  ///
4829  /// @return
4830  /// Reference to the variant data.
4831  TMean& SetMean(void);
4832 
4833 
4834  /// Check if variant Sdev is selected.
4835  ///
4836  /// Sdev type is defined as 'typedef CSdev TSdev'.
4837  /// @return
4838  /// - true, if the variant is selected.
4839  /// - false, otherwise.
4840  bool IsSdev(void) const;
4841 
4842  /// Get the variant data.
4843  ///
4844  /// @return
4845  /// Reference to the data.
4846  const TSdev& GetSdev(void) const;
4847 
4848  /// Select the variant.
4849  ///
4850  /// @return
4851  /// Reference to the variant data.
4852  TSdev& SetSdev(void);
4853 
4854 
4855  /// Check if variant Variance is selected.
4856  ///
4857  /// Variance type is defined as 'typedef CVariance TVariance'.
4858  /// @return
4859  /// - true, if the variant is selected.
4860  /// - false, otherwise.
4861  bool IsVariance(void) const;
4862 
4863  /// Get the variant data.
4864  ///
4865  /// @return
4866  /// Reference to the data.
4867  const TVariance& GetVariance(void) const;
4868 
4869  /// Select the variant.
4870  ///
4871  /// @return
4872  /// Reference to the variant data.
4873  TVariance& SetVariance(void);
4874 
4875 
4876  /// Check if variant Median is selected.
4877  ///
4878  /// Median type is defined as 'typedef CMedian TMedian'.
4879  /// @return
4880  /// - true, if the variant is selected.
4881  /// - false, otherwise.
4882  bool IsMedian(void) const;
4883 
4884  /// Get the variant data.
4885  ///
4886  /// @return
4887  /// Reference to the data.
4888  const TMedian& GetMedian(void) const;
4889 
4890  /// Select the variant.
4891  ///
4892  /// @return
4893  /// Reference to the variant data.
4894  TMedian& SetMedian(void);
4895 
4896 
4897  /// Check if variant Mode is selected.
4898  ///
4899  /// Mode type is defined as 'typedef CMode TMode'.
4900  /// @return
4901  /// - true, if the variant is selected.
4902  /// - false, otherwise.
4903  bool IsMode(void) const;
4904 
4905  /// Get the variant data.
4906  ///
4907  /// @return
4908  /// Reference to the data.
4909  const TMode& GetMode(void) const;
4910 
4911  /// Select the variant.
4912  ///
4913  /// @return
4914  /// Reference to the variant data.
4915  TMode& SetMode(void);
4916 
4917 
4918  private:
4919  // copy constructor and assignment operator
4922  // choice state
4924  // helper methods
4925  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
4926 
4927  static const char* const sm_SelectionNames[];
4928  // data
4929  NCBI_NS_NCBI::CSerialObject *m_object;
4930  };
4931  /////////////////////////////////////////////////////////////////////////////
4932  ///
4933  /// C_Nary_constructor_mmlclass --
4934  ///
4935 
4937  {
4939  public:
4940  // constructor
4942  // destructor
4944 
4945  // type info
4947 
4948 
4949  /// Choice variants.
4950  enum E_Choice {
4951  e_not_set = 0, ///< No variant selected
4954  e_Matrixrow
4955  };
4956  /// Maximum+1 value of the choice variant enumerator.
4958  e_MaxChoice = 4 ///< == e_Matrixrow+1
4959  };
4960 
4961  /// Reset the whole object
4962  void Reset(void);
4963 
4964  /// Reset the selection (set it to e_not_set).
4965  void ResetSelection(void);
4966 
4967  /// Which variant is currently selected.
4968  ///
4969  /// @return
4970  /// Choice state enumerator.
4971  E_Choice Which(void) const;
4972 
4973  /// Verify selection, throw exception if it differs from the expected.
4974  ///
4975  /// @param index
4976  /// Expected selection.
4977  void CheckSelected(E_Choice index) const;
4978 
4979  /// Throw 'InvalidSelection' exception.
4980  ///
4981  /// @param index
4982  /// Expected selection.
4983  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
4984 
4985  /// Retrieve selection name (for diagnostic purposes).
4986  ///
4987  /// @param index
4988  /// One of possible selection states.
4989  /// @return
4990  /// Name string.
4991  static string SelectionName(E_Choice index);
4992 
4993  /// Select the requested variant if needed.
4994  ///
4995  /// @param index
4996  /// New selection state.
4997  /// @param reset
4998  /// Flag that defines the resetting of the variant data. The data will
4999  /// be reset if either the current selection differs from the new one,
5000  /// or the flag is set to eDoResetVariant.
5002  /// Select the requested variant if needed,
5003  /// allocating CObject variants from memory pool.
5004  void Select(E_Choice index,
5005  EResetVariant reset,
5006  CObjectMemoryPool* pool);
5007 
5008  // types
5009  typedef CVector TVector;
5010  typedef CMatrix TMatrix;
5012 
5013  // getters
5014  // setters
5015 
5016 
5017  /// Check if variant Vector is selected.
5018  ///
5019  /// Vector type is defined as 'typedef CVector TVector'.
5020  /// @return
5021  /// - true, if the variant is selected.
5022  /// - false, otherwise.
5023  bool IsVector(void) const;
5024 
5025  /// Get the variant data.
5026  ///
5027  /// @return
5028  /// Reference to the data.
5029  const TVector& GetVector(void) const;
5030 
5031  /// Select the variant.
5032  ///
5033  /// @return
5034  /// Reference to the variant data.
5035  TVector& SetVector(void);
5036  /// Select the variant and set its data.
5037  ///
5038  /// @param value
5039  /// Reference to the data.
5040  void SetVector(TVector& value);
5041 
5042 
5043  /// Check if variant Matrix is selected.
5044  ///
5045  /// Matrix type is defined as 'typedef CMatrix TMatrix'.
5046  /// @return
5047  /// - true, if the variant is selected.
5048  /// - false, otherwise.
5049  bool IsMatrix(void) const;
5050 
5051  /// Get the variant data.
5052  ///
5053  /// @return
5054  /// Reference to the data.
5055  const TMatrix& GetMatrix(void) const;
5056 
5057  /// Select the variant.
5058  ///
5059  /// @return
5060  /// Reference to the variant data.
5061  TMatrix& SetMatrix(void);
5062  /// Select the variant and set its data.
5063  ///
5064  /// @param value
5065  /// Reference to the data.
5066  void SetMatrix(TMatrix& value);
5067 
5068 
5069  /// Check if variant Matrixrow is selected.
5070  ///
5071  /// Matrixrow type is defined as 'typedef CMatrixrow TMatrixrow'.
5072  /// @return
5073  /// - true, if the variant is selected.
5074  /// - false, otherwise.
5075  bool IsMatrixrow(void) const;
5076 
5077  /// Get the variant data.
5078  ///
5079  /// @return
5080  /// Reference to the data.
5081  const TMatrixrow& GetMatrixrow(void) const;
5082 
5083  /// Select the variant.
5084  ///
5085  /// @return
5086  /// Reference to the variant data.
5087  TMatrixrow& SetMatrixrow(void);
5088  /// Select the variant and set its data.
5089  ///
5090  /// @param value
5091  /// Reference to the data.
5092  void SetMatrixrow(TMatrixrow& value);
5093 
5094 
5095  private:
5096  // copy constructor and assignment operator
5099  // choice state
5101  // helper methods
5102  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
5103 
5104  static const char* const sm_SelectionNames[];
5105  // data
5106  NCBI_NS_NCBI::CSerialObject *m_object;
5107  };
5108  /////////////////////////////////////////////////////////////////////////////
5109  ///
5110  /// C_Unary_linalg_mmlclass --
5111  ///
5112 
5114  {
5116  public:
5117  // constructor
5119  // destructor
5121 
5122  // type info
5124 
5125 
5126  /// Choice variants.
5127  enum E_Choice {
5128  e_not_set = 0, ///< No variant selected
5130  e_Transpose
5131  };
5132  /// Maximum+1 value of the choice variant enumerator.
5134  e_MaxChoice = 3 ///< == e_Transpose+1
5135  };
5136 
5137  /// Reset the whole object
5138  void Reset(void);
5139 
5140  /// Reset the selection (set it to e_not_set).
5141  void ResetSelection(void);
5142 
5143  /// Which variant is currently selected.
5144  ///
5145  /// @return
5146  /// Choice state enumerator.
5147  E_Choice Which(void) const;
5148 
5149  /// Verify selection, throw exception if it differs from the expected.
5150  ///
5151  /// @param index
5152  /// Expected selection.
5153  void CheckSelected(E_Choice index) const;
5154 
5155  /// Throw 'InvalidSelection' exception.
5156  ///
5157  /// @param index
5158  /// Expected selection.
5159  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
5160 
5161  /// Retrieve selection name (for diagnostic purposes).
5162  ///
5163  /// @param index
5164  /// One of possible selection states.
5165  /// @return
5166  /// Name string.
5167  static string SelectionName(E_Choice index);
5168 
5169  /// Select the requested variant if needed.
5170  ///
5171  /// @param index
5172  /// New selection state.
5173  /// @param reset
5174  /// Flag that defines the resetting of the variant data. The data will
5175  /// be reset if either the current selection differs from the new one,
5176  /// or the flag is set to eDoResetVariant.
5178  /// Select the requested variant if needed,
5179  /// allocating CObject variants from memory pool.
5180  void Select(E_Choice index,
5181  EResetVariant reset,
5182  CObjectMemoryPool* pool);
5183 
5184  // types
5187 
5188  // getters
5189  // setters
5190 
5191 
5192  /// Check if variant Determinant is selected.
5193  ///
5194  /// Determinant type is defined as 'typedef CDeterminant TDeterminant'.
5195  /// @return
5196  /// - true, if the variant is selected.
5197  /// - false, otherwise.
5198  bool IsDeterminant(void) const;
5199 
5200  /// Get the variant data.
5201  ///
5202  /// @return
5203  /// Reference to the data.
5204  const TDeterminant& GetDeterminant(void) const;
5205 
5206  /// Select the variant.
5207  ///
5208  /// @return
5209  /// Reference to the variant data.
5211 
5212 
5213  /// Check if variant Transpose is selected.
5214  ///
5215  /// Transpose type is defined as 'typedef CTranspose TTranspose'.
5216  /// @return
5217  /// - true, if the variant is selected.
5218  /// - false, otherwise.
5219  bool IsTranspose(void) const;
5220 
5221  /// Get the variant data.
5222  ///
5223  /// @return
5224  /// Reference to the data.
5225  const TTranspose& GetTranspose(void) const;
5226 
5227  /// Select the variant.
5228  ///
5229  /// @return
5230  /// Reference to the variant data.
5231  TTranspose& SetTranspose(void);
5232 
5233 
5234  private:
5235  // copy constructor and assignment operator
5238  // choice state
5240  // helper methods
5241  void DoSelect(E_Choice index, CObjectMemoryPool* pool = 0);
5242 
5243  static const char* const sm_SelectionNames[];
5244  // data
5245  NCBI_NS_NCBI::CSerialObject *m_object;
5246  };
5247  /////////////////////////////////////////////////////////////////////////////
5248  ///
5249  /// C_Nary_linalg_mmlclass --
5250  ///
5251 
5253  {
5255  public:
5256  // constructor
5257  C_Nary_linalg_mmlclass(void);
5258  // destructor
5260 
5261  // type info
5263 
5264  // types
5266 
5267  // member index
5268  enum class E_memberIndex {
5269  e__allMandatory = 0,
5270  e_selector
5271  };
5273 
5274  // getters
5275  // setters
5276 
5277  /// Check if a value has been assigned to Selector data member.
5278  ///
5279  /// Data member Selector is mandatory;
5280  /// its type is defined as 'typedef CSelector TSelector'
5281  /// @return
5282  /// - true, if a value has been assigned.
5283  /// - false, otherwise.
5284  bool IsSetSelector(void) const;
5285 
5286  /// Check if value of Selector member is getatable.
5287  ///
5288  /// @return
5289  /// - false; the data member of type 'NULL' has no value.
5290  bool CanGetSelector(void) const;
5291 
5292  /// Reset Selector data member.
5293  void ResetSelector(void);
5294 
5295  /// Get the Selector member data.
5296  ///
5297  /// @return
5298  /// Reference to the member data.
5299  const TSelector& GetSelector(void) const;
5300 
5301  /// Assign a value to Selector data member.
5302  ///
5303  /// @param value
5304  /// Reference to value.
5305  void SetSelector(TSelector& value);
5306 
5307  /// Assign a value to Selector data member.
5308  ///
5309  /// @return
5310  /// Reference to the data value.
5311  TSelector& SetSelector(void);
5312 
5313  /// Reset the whole object
5314  void Reset(void);
5315 
5316 
5317  private:
5318  // Prohibit copy constructor and assignment operator
5321 
5322  // data
5325  };
5326  /////////////////////////////////////////////////////////////////////////////
5327  ///
5328  /// C_Binary_linalg_mmlclass --
5329  ///
5330 
5332  {
5334  public:
5335  // constructor
5337  // destructor
5339 
5340  // type info
5342 
5343 
5344  /// Choice variants.
5345  enum E_Choice {
5346  e_not_set = 0, ///< No variant selected
5350  };
5351  /// Maximum+1 value of the choice variant enumerator.
5353  e_MaxChoice = 4 ///< == e_Outerproduct+1
5354  };
5355 
5356  /// Reset the whole object
5357  void Reset(void);
5358 
5359  /// Reset the selection (set it to e_not_set).
5360  void ResetSelection(void);
5361 
5362  /// Which variant is currently selected.
5363  ///
5364  /// @return
5365  /// Choice state enumerator.
5366  E_Choice Which(void) const;
5367 
5368  /// Verify selection, throw exception if it differs from the expected.
5369  ///
5370  /// @param index
5371  /// Expected selection.
5372  void CheckSelected(E_Choice index) const;
5373 
5374  /// Throw 'InvalidSelection' exception.
5375  ///
5376  /// @param index
5377  /// Expected selection.
5378  NCBI_NORETURN void ThrowInvalidSelection(E_Choice index) const;
5379 
5380  /// Retrieve selection name (for diagnostic purposes).
5381  ///
5382  /// @param index
5383  /// One of possible selection states.
5384  /// @return
5385  /// Name string.
5386  static string SelectionName(E_Choice index);
5387 
5388  /// Select the requested variant if needed.
5389  ///
5390  /// @param index
5391  /// New selection state.
5392  /// @param reset
5393  /// Flag that defines the resetting of the variant data. The data will
5394  /// be reset if either the current selection differs from the new one,
5395  /// or the flag is set to eDoResetVariant.
5397  /// Select the requested variant if needed,
5398  /// allocating CObject variants from memory pool.