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