NCBI C++ ToolKit
ContExp_.cpp
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  * File Description:
27  * This code was generated by application DATATOOL
28  * using the following specifications:
29  * 'pubmed_mathml3.xsd'.
30  *
31  * ATTENTION:
32  * Don't edit or commit this file into CVS as this file will
33  * be overridden (by DATATOOL) without warning!
34  * ===========================================================================
35  */
36 
37 // standard includes
38 #include <ncbi_pch.hpp>
39 #include <serial/serialimpl.hpp>
40 
41 // generated includes
183 
184 BEGIN_objects_SCOPE // namespace ncbi::objects::
185 
186 
187 // generated classes
188 
190 {
191  if ( m_choice != e_not_set )
192  ResetSelection();
193 }
194 
196 {
197  switch ( m_choice ) {
198  case e_Reln:
199  case e_Fn:
200  case e_Declare:
201  m_object->RemoveReference();
202  break;
203  default:
204  break;
205  }
207 }
208 
209 void CContExp_Base::C_DeprecatedContExp::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
210 {
211  switch ( index ) {
212  case e_Reln:
213  (m_object = new(pool) ncbi::objects::CReln())->AddReference();
214  break;
215  case e_Fn:
216  (m_object = new(pool) ncbi::objects::CFn())->AddReference();
217  break;
218  case e_Declare:
219  (m_object = new(pool) ncbi::objects::CDeclare())->AddReference();
220  break;
221  default:
222  break;
223  }
224  m_choice = index;
225 }
226 
228  "not set",
229  "reln",
230  "fn",
231  "declare"
232 };
233 
235 {
236  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
237 }
238 
240 {
241  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
242 }
243 
245 {
246  CheckSelected(e_Reln);
247  return *static_cast<const TReln*>(m_object);
248 }
249 
251 {
253  return *static_cast<TReln*>(m_object);
254 }
255 
257 {
258  TReln* ptr = &value;
259  if ( m_choice != e_Reln || m_object != ptr ) {
260  ResetSelection();
261  (m_object = ptr)->AddReference();
262  m_choice = e_Reln;
263  }
264 }
265 
267 {
268  CheckSelected(e_Fn);
269  return *static_cast<const TFn*>(m_object);
270 }
271 
273 {
275  return *static_cast<TFn*>(m_object);
276 }
277 
279 {
280  TFn* ptr = &value;
281  if ( m_choice != e_Fn || m_object != ptr ) {
282  ResetSelection();
283  (m_object = ptr)->AddReference();
284  m_choice = e_Fn;
285  }
286 }
287 
289 {
290  CheckSelected(e_Declare);
291  return *static_cast<const TDeclare*>(m_object);
292 }
293 
295 {
297  return *static_cast<TDeclare*>(m_object);
298 }
299 
301 {
302  TDeclare* ptr = &value;
303  if ( m_choice != e_Declare || m_object != ptr ) {
304  ResetSelection();
305  (m_object = ptr)->AddReference();
306  m_choice = e_Declare;
307  }
308 }
309 
310 // helper methods
311 
312 // type info
314 {
315  SET_INTERNAL_NAME("ContExp", "DeprecatedContExp");
316  SET_CHOICE_MODULE("pubmed_mathml3");
317  ADD_NAMED_REF_CHOICE_VARIANT("reln", m_object, CReln)->SetNsQualified(true);
318  ADD_NAMED_REF_CHOICE_VARIANT("fn", m_object, CFn)->SetNsQualified(true);
319  ADD_NAMED_REF_CHOICE_VARIANT("declare", m_object, CDeclare)->SetNsQualified(true);
320  info->CodeVersion(22400);
321  info->DataSpec(ncbi::EDataSpec::eXSD);
322 }
324 
325 // constructor
328 {
329 }
330 
331 // destructor
333 {
334  Reset();
335 }
336 
337 
339 {
340  if ( !m_Interval ) {
341  m_Interval.Reset(new TInterval());
342  return;
343  }
344  (*m_Interval).Reset();
345 }
346 
348 {
349  m_Interval.Reset(&value);
350 }
351 
353 {
354  ResetInterval();
355 }
356 
358 {
359  SET_INTERNAL_NAME("ContExp.interval", "mmlclass");
360  SET_CLASS_MODULE("pubmed_mathml3");
361  ADD_NAMED_REF_MEMBER("interval", m_Interval, CInterval)->SetNsQualified(true);
362  info->RandomOrder();
363  info->CodeVersion(22400);
364  info->DataSpec(ncbi::EDataSpec::eXSD);
365 }
367 
368 // constructor
370 {
371  memset(m_set_State,0,sizeof(m_set_State));
372  if ( !IsAllocatedInPool() ) {
373  ResetInterval();
374  }
375 }
376 
377 // destructor
379 {
380 }
381 
382 
384 {
385  if ( m_choice != e_not_set )
386  ResetSelection();
387 }
388 
390 {
391  switch ( m_choice ) {
392  case e_Inverse:
393  case e_Ident:
394  case e_Domain:
395  case e_Codomain:
396  case e_Image:
397  case e_Ln:
398  case e_Log:
399  case e_Moment:
400  m_object->RemoveReference();
401  break;
402  default:
403  break;
404  }
406 }
407 
408 void CContExp_Base::C_Unary_functional_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
409 {
410  switch ( index ) {
411  case e_Inverse:
412  (m_object = new(pool) ncbi::objects::CInverse())->AddReference();
413  break;
414  case e_Ident:
415  (m_object = new(pool) ncbi::objects::CIdent())->AddReference();
416  break;
417  case e_Domain:
418  (m_object = new(pool) ncbi::objects::CDomain())->AddReference();
419  break;
420  case e_Codomain:
421  (m_object = new(pool) ncbi::objects::CCodomain())->AddReference();
422  break;
423  case e_Image:
424  (m_object = new(pool) ncbi::objects::CImage())->AddReference();
425  break;
426  case e_Ln:
427  (m_object = new(pool) ncbi::objects::CLn())->AddReference();
428  break;
429  case e_Log:
430  (m_object = new(pool) ncbi::objects::CLog())->AddReference();
431  break;
432  case e_Moment:
433  (m_object = new(pool) ncbi::objects::CMoment())->AddReference();
434  break;
435  default:
436  break;
437  }
438  m_choice = index;
439 }
440 
442  "not set",
443  "inverse",
444  "ident",
445  "domain",
446  "codomain",
447  "image",
448  "ln",
449  "log",
450  "moment"
451 };
452 
454 {
455  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
456 }
457 
459 {
460  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
461 }
462 
464 {
465  CheckSelected(e_Inverse);
466  return *static_cast<const TInverse*>(m_object);
467 }
468 
470 {
473  value.SetInverse();
474  return value;
475 }
476 
478 {
479  CheckSelected(e_Ident);
480  return *static_cast<const TIdent*>(m_object);
481 }
482 
484 {
487  value.SetIdent();
488  return value;
489 }
490 
492 {
493  CheckSelected(e_Domain);
494  return *static_cast<const TDomain*>(m_object);
495 }
496 
498 {
501  value.SetDomain();
502  return value;
503 }
504 
506 {
507  CheckSelected(e_Codomain);
508  return *static_cast<const TCodomain*>(m_object);
509 }
510 
512 {
515  value.SetCodomain();
516  return value;
517 }
518 
520 {
521  CheckSelected(e_Image);
522  return *static_cast<const TImage*>(m_object);
523 }
524 
526 {
529  value.SetImage();
530  return value;
531 }
532 
534 {
535  CheckSelected(e_Ln);
536  return *static_cast<const TLn*>(m_object);
537 }
538 
540 {
543  value.SetLn();
544  return value;
545 }
546 
548 {
549  CheckSelected(e_Log);
550  return *static_cast<const TLog*>(m_object);
551 }
552 
554 {
557  value.SetLog();
558  return value;
559 }
560 
562 {
563  CheckSelected(e_Moment);
564  return *static_cast<const TMoment*>(m_object);
565 }
566 
568 {
571  value.SetMoment();
572  return value;
573 }
574 
575 // helper methods
576 
577 // type info
579 {
580  SET_INTERNAL_NAME("ContExp.unary-functional", "mmlclass");
581  SET_CHOICE_MODULE("pubmed_mathml3");
582  ADD_NAMED_REF_CHOICE_VARIANT("inverse", m_object, CInverse)->SetNsQualified(true);
583  ADD_NAMED_REF_CHOICE_VARIANT("ident", m_object, CIdent)->SetNsQualified(true);
584  ADD_NAMED_REF_CHOICE_VARIANT("domain", m_object, CDomain)->SetNsQualified(true);
585  ADD_NAMED_REF_CHOICE_VARIANT("codomain", m_object, CCodomain)->SetNsQualified(true);
586  ADD_NAMED_REF_CHOICE_VARIANT("image", m_object, CImage)->SetNsQualified(true);
587  ADD_NAMED_REF_CHOICE_VARIANT("ln", m_object, CLn)->SetNsQualified(true);
588  ADD_NAMED_REF_CHOICE_VARIANT("log", m_object, CLog)->SetNsQualified(true);
589  ADD_NAMED_REF_CHOICE_VARIANT("moment", m_object, CMoment)->SetNsQualified(true);
590  info->CodeVersion(22400);
591  info->DataSpec(ncbi::EDataSpec::eXSD);
592 }
594 
595 // constructor
598 {
599 }
600 
601 // destructor
603 {
604  Reset();
605 }
606 
607 
609 {
610  if ( !m_Lambda ) {
611  m_Lambda.Reset(new TLambda());
612  return;
613  }
614  (*m_Lambda).Reset();
615 }
616 
618 {
619  m_Lambda.Reset(&value);
620 }
621 
623 {
624  ResetLambda();
625 }
626 
628 {
629  SET_INTERNAL_NAME("ContExp.lambda", "mmlclass");
630  SET_CLASS_MODULE("pubmed_mathml3");
631  ADD_NAMED_REF_MEMBER("lambda", m_Lambda, CLambda)->SetNsQualified(true);
632  info->RandomOrder();
633  info->CodeVersion(22400);
634  info->DataSpec(ncbi::EDataSpec::eXSD);
635 }
637 
638 // constructor
640 {
641  memset(m_set_State,0,sizeof(m_set_State));
642  if ( !IsAllocatedInPool() ) {
643  ResetLambda();
644  }
645 }
646 
647 // destructor
649 {
650 }
651 
652 
654 {
655  return m_Compose ? m_Compose->IsSetCompose() : false;
656 }
657 
659 {
660  if ( !m_Compose ) {
661  m_Compose.Reset(new TCompose());
662  return;
663  }
664  (*m_Compose).Reset();
665 }
666 
668 {
669  m_Compose.Reset(&value);
670 }
671 
673 {
674  if ( !m_Compose ) {
675  ResetCompose();
676  }
677  m_Compose->SetCompose();
678  return (*m_Compose);
679 }
680 
682 {
683  ResetCompose();
684 }
685 
687 {
688  SET_INTERNAL_NAME("ContExp.nary-functional", "mmlclass");
689  SET_CLASS_MODULE("pubmed_mathml3");
690  ADD_NAMED_REF_MEMBER("compose", m_Compose, CCompose)->SetNsQualified(true);
691  info->RandomOrder();
692  info->CodeVersion(22400);
693  info->DataSpec(ncbi::EDataSpec::eXSD);
694 }
696 
697 // constructor
699 {
700  memset(m_set_State,0,sizeof(m_set_State));
701  if ( !IsAllocatedInPool() ) {
702  ResetCompose();
703  }
704 }
705 
706 // destructor
708 {
709 }
710 
711 
713 {
714  if ( m_choice != e_not_set )
715  ResetSelection();
716 }
717 
719 {
720  switch ( m_choice ) {
721  case e_Quotient:
722  case e_Divide:
723  case e_Minus:
724  case e_Power:
725  case e_Rem:
726  case e_Root:
727  m_object->RemoveReference();
728  break;
729  default:
730  break;
731  }
733 }
734 
735 void CContExp_Base::C_Binary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
736 {
737  switch ( index ) {
738  case e_Quotient:
739  (m_object = new(pool) ncbi::objects::CQuotient())->AddReference();
740  break;
741  case e_Divide:
742  (m_object = new(pool) ncbi::objects::CDivide())->AddReference();
743  break;
744  case e_Minus:
745  (m_object = new(pool) ncbi::objects::CMinus())->AddReference();
746  break;
747  case e_Power:
748  (m_object = new(pool) ncbi::objects::CPower())->AddReference();
749  break;
750  case e_Rem:
751  (m_object = new(pool) ncbi::objects::CRem())->AddReference();
752  break;
753  case e_Root:
754  (m_object = new(pool) ncbi::objects::CRoot())->AddReference();
755  break;
756  default:
757  break;
758  }
759  m_choice = index;
760 }
761 
763  "not set",
764  "quotient",
765  "divide",
766  "minus",
767  "power",
768  "rem",
769  "root"
770 };
771 
773 {
774  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
775 }
776 
778 {
779  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
780 }
781 
783 {
784  CheckSelected(e_Quotient);
785  return *static_cast<const TQuotient*>(m_object);
786 }
787 
789 {
792  value.SetQuotient();
793  return value;
794 }
795 
797 {
798  CheckSelected(e_Divide);
799  return *static_cast<const TDivide*>(m_object);
800 }
801 
803 {
806  value.SetDivide();
807  return value;
808 }
809 
811 {
812  CheckSelected(e_Minus);
813  return *static_cast<const TMinus*>(m_object);
814 }
815 
817 {
820  value.SetMinus();
821  return value;
822 }
823 
825 {
826  CheckSelected(e_Power);
827  return *static_cast<const TPower*>(m_object);
828 }
829 
831 {
834  value.SetPower();
835  return value;
836 }
837 
839 {
840  CheckSelected(e_Rem);
841  return *static_cast<const TRem*>(m_object);
842 }
843 
845 {
848  value.SetRem();
849  return value;
850 }
851 
853 {
854  CheckSelected(e_Root);
855  return *static_cast<const TRoot*>(m_object);
856 }
857 
859 {
862  value.SetRoot();
863  return value;
864 }
865 
866 // helper methods
867 
868 // type info
870 {
871  SET_INTERNAL_NAME("ContExp.binary-arith", "mmlclass");
872  SET_CHOICE_MODULE("pubmed_mathml3");
873  ADD_NAMED_REF_CHOICE_VARIANT("quotient", m_object, CQuotient)->SetNsQualified(true);
874  ADD_NAMED_REF_CHOICE_VARIANT("divide", m_object, CDivide)->SetNsQualified(true);
875  ADD_NAMED_REF_CHOICE_VARIANT("minus", m_object, CMinus)->SetNsQualified(true);
876  ADD_NAMED_REF_CHOICE_VARIANT("power", m_object, CPower)->SetNsQualified(true);
877  ADD_NAMED_REF_CHOICE_VARIANT("rem", m_object, CRem)->SetNsQualified(true);
878  ADD_NAMED_REF_CHOICE_VARIANT("root", m_object, CRoot)->SetNsQualified(true);
879  info->CodeVersion(22400);
880  info->DataSpec(ncbi::EDataSpec::eXSD);
881 }
883 
884 // constructor
887 {
888 }
889 
890 // destructor
892 {
893  Reset();
894 }
895 
896 
898 {
899  if ( m_choice != e_not_set )
900  ResetSelection();
901 }
902 
904 {
905  switch ( m_choice ) {
906  case e_Factorial:
907  case e_Abs:
908  case e_Conjugate:
909  case e_Arg:
910  case e_Real:
911  case e_Imaginary:
912  case e_Floor:
913  case e_Ceiling:
914  case e_Exp:
915  m_object->RemoveReference();
916  break;
917  default:
918  break;
919  }
921 }
922 
923 void CContExp_Base::C_Unary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
924 {
925  switch ( index ) {
926  case e_Factorial:
927  (m_object = new(pool) ncbi::objects::CFactorial())->AddReference();
928  break;
929  case e_Abs:
930  (m_object = new(pool) ncbi::objects::CAbs())->AddReference();
931  break;
932  case e_Conjugate:
933  (m_object = new(pool) ncbi::objects::CConjugate())->AddReference();
934  break;
935  case e_Arg:
936  (m_object = new(pool) ncbi::objects::CArg())->AddReference();
937  break;
938  case e_Real:
939  (m_object = new(pool) ncbi::objects::CReal())->AddReference();
940  break;
941  case e_Imaginary:
942  (m_object = new(pool) ncbi::objects::CImaginary())->AddReference();
943  break;
944  case e_Floor:
945  (m_object = new(pool) ncbi::objects::CFloor())->AddReference();
946  break;
947  case e_Ceiling:
948  (m_object = new(pool) ncbi::objects::CCeiling())->AddReference();
949  break;
950  case e_Exp:
951  (m_object = new(pool) ncbi::objects::CExp())->AddReference();
952  break;
953  default:
954  break;
955  }
956  m_choice = index;
957 }
958 
960  "not set",
961  "factorial",
962  "abs",
963  "conjugate",
964  "arg",
965  "real",
966  "imaginary",
967  "floor",
968  "ceiling",
969  "exp"
970 };
971 
973 {
974  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
975 }
976 
978 {
979  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
980 }
981 
983 {
984  CheckSelected(e_Factorial);
985  return *static_cast<const TFactorial*>(m_object);
986 }
987 
989 {
992  value.SetFactorial();
993  return value;
994 }
995 
997 {
998  CheckSelected(e_Abs);
999  return *static_cast<const TAbs*>(m_object);
1000 }
1001 
1003 {
1006  value.SetAbs();
1007  return value;
1008 }
1009 
1011 {
1012  CheckSelected(e_Conjugate);
1013  return *static_cast<const TConjugate*>(m_object);
1014 }
1015 
1017 {
1020  value.SetConjugate();
1021  return value;
1022 }
1023 
1025 {
1026  CheckSelected(e_Arg);
1027  return *static_cast<const TArg*>(m_object);
1028 }
1029 
1031 {
1034  value.SetArg();
1035  return value;
1036 }
1037 
1039 {
1040  CheckSelected(e_Real);
1041  return *static_cast<const TReal*>(m_object);
1042 }
1043 
1045 {
1048  value.SetReal();
1049  return value;
1050 }
1051 
1053 {
1054  CheckSelected(e_Imaginary);
1055  return *static_cast<const TImaginary*>(m_object);
1056 }
1057 
1059 {
1062  value.SetImaginary();
1063  return value;
1064 }
1065 
1067 {
1068  CheckSelected(e_Floor);
1069  return *static_cast<const TFloor*>(m_object);
1070 }
1071 
1073 {
1076  value.SetFloor();
1077  return value;
1078 }
1079 
1081 {
1082  CheckSelected(e_Ceiling);
1083  return *static_cast<const TCeiling*>(m_object);
1084 }
1085 
1087 {
1090  value.SetCeiling();
1091  return value;
1092 }
1093 
1095 {
1096  CheckSelected(e_Exp);
1097  return *static_cast<const TExp*>(m_object);
1098 }
1099 
1101 {
1104  value.SetExp();
1105  return value;
1106 }
1107 
1108 // helper methods
1109 
1110 // type info
1112 {
1113  SET_INTERNAL_NAME("ContExp.unary-arith", "mmlclass");
1114  SET_CHOICE_MODULE("pubmed_mathml3");
1115  ADD_NAMED_REF_CHOICE_VARIANT("factorial", m_object, CFactorial)->SetNsQualified(true);
1116  ADD_NAMED_REF_CHOICE_VARIANT("abs", m_object, CAbs)->SetNsQualified(true);
1117  ADD_NAMED_REF_CHOICE_VARIANT("conjugate", m_object, CConjugate)->SetNsQualified(true);
1118  ADD_NAMED_REF_CHOICE_VARIANT("arg", m_object, CArg)->SetNsQualified(true);
1119  ADD_NAMED_REF_CHOICE_VARIANT("real", m_object, CReal)->SetNsQualified(true);
1120  ADD_NAMED_REF_CHOICE_VARIANT("imaginary", m_object, CImaginary)->SetNsQualified(true);
1121  ADD_NAMED_REF_CHOICE_VARIANT("floor", m_object, CFloor)->SetNsQualified(true);
1122  ADD_NAMED_REF_CHOICE_VARIANT("ceiling", m_object, CCeiling)->SetNsQualified(true);
1123  ADD_NAMED_REF_CHOICE_VARIANT("exp", m_object, CExp)->SetNsQualified(true);
1124  info->CodeVersion(22400);
1125  info->DataSpec(ncbi::EDataSpec::eXSD);
1126 }
1128 
1129 // constructor
1131  : m_choice(e_not_set)
1132 {
1133 }
1134 
1135 // destructor
1137 {
1138  Reset();
1139 }
1140 
1141 
1143 {
1144  if ( m_choice != e_not_set )
1145  ResetSelection();
1146 }
1147 
1149 {
1150  switch ( m_choice ) {
1151  case e_Max:
1152  case e_Min:
1153  m_object->RemoveReference();
1154  break;
1155  default:
1156  break;
1157  }
1158  m_choice = e_not_set;
1159 }
1160 
1161 void CContExp_Base::C_Nary_minmax_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1162 {
1163  switch ( index ) {
1164  case e_Max:
1165  (m_object = new(pool) ncbi::objects::CMax())->AddReference();
1166  break;
1167  case e_Min:
1168  (m_object = new(pool) ncbi::objects::CMin())->AddReference();
1169  break;
1170  default:
1171  break;
1172  }
1173  m_choice = index;
1174 }
1175 
1177  "not set",
1178  "max",
1179  "min"
1180 };
1181 
1183 {
1184  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1185 }
1186 
1188 {
1189  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1190 }
1191 
1193 {
1195  return *static_cast<const TMax*>(m_object);
1196 }
1197 
1199 {
1202  value.SetMax();
1203  return value;
1204 }
1205 
1207 {
1208  CheckSelected(e_Min);
1209  return *static_cast<const TMin*>(m_object);
1210 }
1211 
1213 {
1216  value.SetMin();
1217  return value;
1218 }
1219 
1220 // helper methods
1221 
1222 // type info
1224 {
1225  SET_INTERNAL_NAME("ContExp.nary-minmax", "mmlclass");
1226  SET_CHOICE_MODULE("pubmed_mathml3");
1227  ADD_NAMED_REF_CHOICE_VARIANT("max", m_object, CMax)->SetNsQualified(true);
1228  ADD_NAMED_REF_CHOICE_VARIANT("min", m_object, CMin)->SetNsQualified(true);
1229  info->CodeVersion(22400);
1230  info->DataSpec(ncbi::EDataSpec::eXSD);
1231 }
1233 
1234 // constructor
1236  : m_choice(e_not_set)
1237 {
1238 }
1239 
1240 // destructor
1242 {
1243  Reset();
1244 }
1245 
1246 
1248 {
1249  if ( m_choice != e_not_set )
1250  ResetSelection();
1251 }
1252 
1254 {
1255  switch ( m_choice ) {
1256  case e_Plus:
1257  case e_Times:
1258  case e_Gcd:
1259  case e_Lcm:
1260  m_object->RemoveReference();
1261  break;
1262  default:
1263  break;
1264  }
1265  m_choice = e_not_set;
1266 }
1267 
1268 void CContExp_Base::C_Nary_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1269 {
1270  switch ( index ) {
1271  case e_Plus:
1272  (m_object = new(pool) ncbi::objects::CPlus())->AddReference();
1273  break;
1274  case e_Times:
1275  (m_object = new(pool) ncbi::objects::CTimes())->AddReference();
1276  break;
1277  case e_Gcd:
1278  (m_object = new(pool) ncbi::objects::CGcd())->AddReference();
1279  break;
1280  case e_Lcm:
1281  (m_object = new(pool) ncbi::objects::CLcm())->AddReference();
1282  break;
1283  default:
1284  break;
1285  }
1286  m_choice = index;
1287 }
1288 
1290  "not set",
1291  "plus",
1292  "times",
1293  "gcd",
1294  "lcm"
1295 };
1296 
1298 {
1299  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1300 }
1301 
1303 {
1304  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1305 }
1306 
1308 {
1309  CheckSelected(e_Plus);
1310  return *static_cast<const TPlus*>(m_object);
1311 }
1312 
1314 {
1317  value.SetPlus();
1318  return value;
1319 }
1320 
1322 {
1323  CheckSelected(e_Times);
1324  return *static_cast<const TTimes*>(m_object);
1325 }
1326 
1328 {
1331  value.SetTimes();
1332  return value;
1333 }
1334 
1336 {
1337  CheckSelected(e_Gcd);
1338  return *static_cast<const TGcd*>(m_object);
1339 }
1340 
1342 {
1345  value.SetGcd();
1346  return value;
1347 }
1348 
1350 {
1351  CheckSelected(e_Lcm);
1352  return *static_cast<const TLcm*>(m_object);
1353 }
1354 
1356 {
1359  value.SetLcm();
1360  return value;
1361 }
1362 
1363 // helper methods
1364 
1365 // type info
1367 {
1368  SET_INTERNAL_NAME("ContExp.nary-arith", "mmlclass");
1369  SET_CHOICE_MODULE("pubmed_mathml3");
1370  ADD_NAMED_REF_CHOICE_VARIANT("plus", m_object, CPlus)->SetNsQualified(true);
1371  ADD_NAMED_REF_CHOICE_VARIANT("times", m_object, CTimes)->SetNsQualified(true);
1372  ADD_NAMED_REF_CHOICE_VARIANT("gcd", m_object, CGcd)->SetNsQualified(true);
1373  ADD_NAMED_REF_CHOICE_VARIANT("lcm", m_object, CLcm)->SetNsQualified(true);
1374  info->CodeVersion(22400);
1375  info->DataSpec(ncbi::EDataSpec::eXSD);
1376 }
1378 
1379 // constructor
1381  : m_choice(e_not_set)
1382 {
1383 }
1384 
1385 // destructor
1387 {
1388  Reset();
1389 }
1390 
1391 
1393 {
1394  if ( m_choice != e_not_set )
1395  ResetSelection();
1396 }
1397 
1399 {
1400  switch ( m_choice ) {
1401  case e_And:
1402  case e_Or:
1403  case e_Xor:
1404  m_object->RemoveReference();
1405  break;
1406  default:
1407  break;
1408  }
1409  m_choice = e_not_set;
1410 }
1411 
1412 void CContExp_Base::C_Nary_logical_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1413 {
1414  switch ( index ) {
1415  case e_And:
1416  (m_object = new(pool) ncbi::objects::CAnd())->AddReference();
1417  break;
1418  case e_Or:
1419  (m_object = new(pool) ncbi::objects::COr())->AddReference();
1420  break;
1421  case e_Xor:
1422  (m_object = new(pool) ncbi::objects::CXor())->AddReference();
1423  break;
1424  default:
1425  break;
1426  }
1427  m_choice = index;
1428 }
1429 
1431  "not set",
1432  "and",
1433  "or",
1434  "xor"
1435 };
1436 
1438 {
1439  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1440 }
1441 
1443 {
1444  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1445 }
1446 
1448 {
1449  CheckSelected(e_And);
1450  return *static_cast<const TAnd*>(m_object);
1451 }
1452 
1454 {
1457  value.SetAnd();
1458  return value;
1459 }
1460 
1462 {
1463  CheckSelected(e_Or);
1464  return *static_cast<const TOr*>(m_object);
1465 }
1466 
1468 {
1471  value.SetOr();
1472  return value;
1473 }
1474 
1476 {
1477  CheckSelected(e_Xor);
1478  return *static_cast<const TXor*>(m_object);
1479 }
1480 
1482 {
1485  value.SetXor();
1486  return value;
1487 }
1488 
1489 // helper methods
1490 
1491 // type info
1493 {
1494  SET_INTERNAL_NAME("ContExp.nary-logical", "mmlclass");
1495  SET_CHOICE_MODULE("pubmed_mathml3");
1496  ADD_NAMED_REF_CHOICE_VARIANT("and", m_object, CAnd)->SetNsQualified(true);
1497  ADD_NAMED_REF_CHOICE_VARIANT("or", m_object, COr)->SetNsQualified(true);
1498  ADD_NAMED_REF_CHOICE_VARIANT("xor", m_object, CXor)->SetNsQualified(true);
1499  info->CodeVersion(22400);
1500  info->DataSpec(ncbi::EDataSpec::eXSD);
1501 }
1503 
1504 // constructor
1506  : m_choice(e_not_set)
1507 {
1508 }
1509 
1510 // destructor
1512 {
1513  Reset();
1514 }
1515 
1516 
1518 {
1519  return m_Not ? m_Not->IsSetNot() : false;
1520 }
1521 
1523 {
1524  if ( !m_Not ) {
1525  m_Not.Reset(new TNot());
1526  return;
1527  }
1528  (*m_Not).Reset();
1529 }
1530 
1532 {
1533  m_Not.Reset(&value);
1534 }
1535 
1537 {
1538  if ( !m_Not ) {
1539  ResetNot();
1540  }
1541  m_Not->SetNot();
1542  return (*m_Not);
1543 }
1544 
1546 {
1547  ResetNot();
1548 }
1549 
1551 {
1552  SET_INTERNAL_NAME("ContExp.unary-logical", "mmlclass");
1553  SET_CLASS_MODULE("pubmed_mathml3");
1554  ADD_NAMED_REF_MEMBER("not", m_Not, CNot)->SetNsQualified(true);
1555  info->RandomOrder();
1556  info->CodeVersion(22400);
1557  info->DataSpec(ncbi::EDataSpec::eXSD);
1558 }
1560 
1561 // constructor
1563 {
1564  memset(m_set_State,0,sizeof(m_set_State));
1565  if ( !IsAllocatedInPool() ) {
1566  ResetNot();
1567  }
1568 }
1569 
1570 // destructor
1572 {
1573 }
1574 
1575 
1577 {
1578  if ( m_choice != e_not_set )
1579  ResetSelection();
1580 }
1581 
1583 {
1584  switch ( m_choice ) {
1585  case e_Implies:
1586  case e_Equivalent:
1587  m_object->RemoveReference();
1588  break;
1589  default:
1590  break;
1591  }
1592  m_choice = e_not_set;
1593 }
1594 
1595 void CContExp_Base::C_Binary_logical_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1596 {
1597  switch ( index ) {
1598  case e_Implies:
1599  (m_object = new(pool) ncbi::objects::CImplies())->AddReference();
1600  break;
1601  case e_Equivalent:
1602  (m_object = new(pool) ncbi::objects::CEquivalent())->AddReference();
1603  break;
1604  default:
1605  break;
1606  }
1607  m_choice = index;
1608 }
1609 
1611  "not set",
1612  "implies",
1613  "equivalent"
1614 };
1615 
1617 {
1618  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1619 }
1620 
1622 {
1623  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1624 }
1625 
1627 {
1628  CheckSelected(e_Implies);
1629  return *static_cast<const TImplies*>(m_object);
1630 }
1631 
1633 {
1636  value.SetImplies();
1637  return value;
1638 }
1639 
1641 {
1642  CheckSelected(e_Equivalent);
1643  return *static_cast<const TEquivalent*>(m_object);
1644 }
1645 
1647 {
1650  value.SetEquivalent();
1651  return value;
1652 }
1653 
1654 // helper methods
1655 
1656 // type info
1658 {
1659  SET_INTERNAL_NAME("ContExp.binary-logical", "mmlclass");
1660  SET_CHOICE_MODULE("pubmed_mathml3");
1661  ADD_NAMED_REF_CHOICE_VARIANT("implies", m_object, CImplies)->SetNsQualified(true);
1662  ADD_NAMED_REF_CHOICE_VARIANT("equivalent", m_object, CEquivalent)->SetNsQualified(true);
1663  info->CodeVersion(22400);
1664  info->DataSpec(ncbi::EDataSpec::eXSD);
1665 }
1667 
1668 // constructor
1670  : m_choice(e_not_set)
1671 {
1672 }
1673 
1674 // destructor
1676 {
1677  Reset();
1678 }
1679 
1680 
1682 {
1683  if ( m_choice != e_not_set )
1684  ResetSelection();
1685 }
1686 
1688 {
1689  switch ( m_choice ) {
1690  case e_Forall:
1691  case e_Exists:
1692  m_object->RemoveReference();
1693  break;
1694  default:
1695  break;
1696  }
1697  m_choice = e_not_set;
1698 }
1699 
1700 void CContExp_Base::C_Quantifier_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1701 {
1702  switch ( index ) {
1703  case e_Forall:
1704  (m_object = new(pool) ncbi::objects::CForall())->AddReference();
1705  break;
1706  case e_Exists:
1707  (m_object = new(pool) ncbi::objects::CExists())->AddReference();
1708  break;
1709  default:
1710  break;
1711  }
1712  m_choice = index;
1713 }
1714 
1716  "not set",
1717  "forall",
1718  "exists"
1719 };
1720 
1722 {
1723  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1724 }
1725 
1727 {
1728  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1729 }
1730 
1732 {
1733  CheckSelected(e_Forall);
1734  return *static_cast<const TForall*>(m_object);
1735 }
1736 
1738 {
1741  value.SetForall();
1742  return value;
1743 }
1744 
1746 {
1747  CheckSelected(e_Exists);
1748  return *static_cast<const TExists*>(m_object);
1749 }
1750 
1752 {
1755  value.SetExists();
1756  return value;
1757 }
1758 
1759 // helper methods
1760 
1761 // type info
1763 {
1764  SET_INTERNAL_NAME("ContExp.quantifier", "mmlclass");
1765  SET_CHOICE_MODULE("pubmed_mathml3");
1766  ADD_NAMED_REF_CHOICE_VARIANT("forall", m_object, CForall)->SetNsQualified(true);
1767  ADD_NAMED_REF_CHOICE_VARIANT("exists", m_object, CExists)->SetNsQualified(true);
1768  info->CodeVersion(22400);
1769  info->DataSpec(ncbi::EDataSpec::eXSD);
1770 }
1772 
1773 // constructor
1775  : m_choice(e_not_set)
1776 {
1777 }
1778 
1779 // destructor
1781 {
1782  Reset();
1783 }
1784 
1785 
1787 {
1788  if ( m_choice != e_not_set )
1789  ResetSelection();
1790 }
1791 
1793 {
1794  switch ( m_choice ) {
1795  case e_Eq:
1796  case e_Gt:
1797  case e_Lt:
1798  case e_Geq:
1799  case e_Leq:
1800  m_object->RemoveReference();
1801  break;
1802  default:
1803  break;
1804  }
1805  m_choice = e_not_set;
1806 }
1807 
1808 void CContExp_Base::C_Nary_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1809 {
1810  switch ( index ) {
1811  case e_Eq:
1812  (m_object = new(pool) ncbi::objects::CEq())->AddReference();
1813  break;
1814  case e_Gt:
1815  (m_object = new(pool) ncbi::objects::CGt())->AddReference();
1816  break;
1817  case e_Lt:
1818  (m_object = new(pool) ncbi::objects::CLt())->AddReference();
1819  break;
1820  case e_Geq:
1821  (m_object = new(pool) ncbi::objects::CGeq())->AddReference();
1822  break;
1823  case e_Leq:
1824  (m_object = new(pool) ncbi::objects::CLeq())->AddReference();
1825  break;
1826  default:
1827  break;
1828  }
1829  m_choice = index;
1830 }
1831 
1833  "not set",
1834  "eq",
1835  "gt",
1836  "lt",
1837  "geq",
1838  "leq"
1839 };
1840 
1842 {
1843  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1844 }
1845 
1847 {
1848  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1849 }
1850 
1852 {
1853  CheckSelected(e_Eq);
1854  return *static_cast<const TEq*>(m_object);
1855 }
1856 
1858 {
1861  value.SetEq();
1862  return value;
1863 }
1864 
1866 {
1867  CheckSelected(e_Gt);
1868  return *static_cast<const TGt*>(m_object);
1869 }
1870 
1872 {
1875  value.SetGt();
1876  return value;
1877 }
1878 
1880 {
1881  CheckSelected(e_Lt);
1882  return *static_cast<const TLt*>(m_object);
1883 }
1884 
1886 {
1889  value.SetLt();
1890  return value;
1891 }
1892 
1894 {
1895  CheckSelected(e_Geq);
1896  return *static_cast<const TGeq*>(m_object);
1897 }
1898 
1900 {
1903  value.SetGeq();
1904  return value;
1905 }
1906 
1908 {
1909  CheckSelected(e_Leq);
1910  return *static_cast<const TLeq*>(m_object);
1911 }
1912 
1914 {
1917  value.SetLeq();
1918  return value;
1919 }
1920 
1921 // helper methods
1922 
1923 // type info
1925 {
1926  SET_INTERNAL_NAME("ContExp.nary-reln", "mmlclass");
1927  SET_CHOICE_MODULE("pubmed_mathml3");
1928  ADD_NAMED_REF_CHOICE_VARIANT("eq", m_object, CEq)->SetNsQualified(true);
1929  ADD_NAMED_REF_CHOICE_VARIANT("gt", m_object, CGt)->SetNsQualified(true);
1930  ADD_NAMED_REF_CHOICE_VARIANT("lt", m_object, CLt)->SetNsQualified(true);
1931  ADD_NAMED_REF_CHOICE_VARIANT("geq", m_object, CGeq)->SetNsQualified(true);
1932  ADD_NAMED_REF_CHOICE_VARIANT("leq", m_object, CLeq)->SetNsQualified(true);
1933  info->CodeVersion(22400);
1934  info->DataSpec(ncbi::EDataSpec::eXSD);
1935 }
1937 
1938 // constructor
1940  : m_choice(e_not_set)
1941 {
1942 }
1943 
1944 // destructor
1946 {
1947  Reset();
1948 }
1949 
1950 
1952 {
1953  if ( m_choice != e_not_set )
1954  ResetSelection();
1955 }
1956 
1958 {
1959  switch ( m_choice ) {
1960  case e_Neq:
1961  case e_Approx:
1962  case e_Factorof:
1963  case e_Tendsto:
1964  m_object->RemoveReference();
1965  break;
1966  default:
1967  break;
1968  }
1969  m_choice = e_not_set;
1970 }
1971 
1972 void CContExp_Base::C_Binary_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
1973 {
1974  switch ( index ) {
1975  case e_Neq:
1976  (m_object = new(pool) ncbi::objects::CNeq())->AddReference();
1977  break;
1978  case e_Approx:
1979  (m_object = new(pool) ncbi::objects::CApprox())->AddReference();
1980  break;
1981  case e_Factorof:
1982  (m_object = new(pool) ncbi::objects::CFactorof())->AddReference();
1983  break;
1984  case e_Tendsto:
1985  (m_object = new(pool) ncbi::objects::CTendsto())->AddReference();
1986  break;
1987  default:
1988  break;
1989  }
1990  m_choice = index;
1991 }
1992 
1994  "not set",
1995  "neq",
1996  "approx",
1997  "factorof",
1998  "tendsto"
1999 };
2000 
2002 {
2003  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2004 }
2005 
2007 {
2008  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2009 }
2010 
2012 {
2013  CheckSelected(e_Neq);
2014  return *static_cast<const TNeq*>(m_object);
2015 }
2016 
2018 {
2021  value.SetNeq();
2022  return value;
2023 }
2024 
2026 {
2027  CheckSelected(e_Approx);
2028  return *static_cast<const TApprox*>(m_object);
2029 }
2030 
2032 {
2035  value.SetApprox();
2036  return value;
2037 }
2038 
2040 {
2041  CheckSelected(e_Factorof);
2042  return *static_cast<const TFactorof*>(m_object);
2043 }
2044 
2046 {
2049  value.SetFactorof();
2050  return value;
2051 }
2052 
2054 {
2055  CheckSelected(e_Tendsto);
2056  return *static_cast<const TTendsto*>(m_object);
2057 }
2058 
2060 {
2063  value.SetTendsto();
2064  return value;
2065 }
2066 
2067 // helper methods
2068 
2069 // type info
2071 {
2072  SET_INTERNAL_NAME("ContExp.binary-reln", "mmlclass");
2073  SET_CHOICE_MODULE("pubmed_mathml3");
2074  ADD_NAMED_REF_CHOICE_VARIANT("neq", m_object, CNeq)->SetNsQualified(true);
2075  ADD_NAMED_REF_CHOICE_VARIANT("approx", m_object, CApprox)->SetNsQualified(true);
2076  ADD_NAMED_REF_CHOICE_VARIANT("factorof", m_object, CFactorof)->SetNsQualified(true);
2077  ADD_NAMED_REF_CHOICE_VARIANT("tendsto", m_object, CTendsto)->SetNsQualified(true);
2078  info->CodeVersion(22400);
2079  info->DataSpec(ncbi::EDataSpec::eXSD);
2080 }
2082 
2083 // constructor
2085  : m_choice(e_not_set)
2086 {
2087 }
2088 
2089 // destructor
2091 {
2092  Reset();
2093 }
2094 
2095 
2097 {
2098  return m_Int ? m_Int->IsSetInt() : false;
2099 }
2100 
2102 {
2103  if ( !m_Int ) {
2104  m_Int.Reset(new TInt());
2105  return;
2106  }
2107  (*m_Int).Reset();
2108 }
2109 
2111 {
2112  m_Int.Reset(&value);
2113 }
2114 
2116 {
2117  if ( !m_Int ) {
2118  ResetInt();
2119  }
2120  m_Int->SetInt();
2121  return (*m_Int);
2122 }
2123 
2125 {
2126  ResetInt();
2127 }
2128 
2130 {
2131  SET_INTERNAL_NAME("ContExp.int", "mmlclass");
2132  SET_CLASS_MODULE("pubmed_mathml3");
2133  ADD_NAMED_REF_MEMBER("int", m_Int, CInt)->SetNsQualified(true);
2134  info->RandomOrder();
2135  info->CodeVersion(22400);
2136  info->DataSpec(ncbi::EDataSpec::eXSD);
2137 }
2139 
2140 // constructor
2142 {
2143  memset(m_set_State,0,sizeof(m_set_State));
2144  if ( !IsAllocatedInPool() ) {
2145  ResetInt();
2146  }
2147 }
2148 
2149 // destructor
2151 {
2152 }
2153 
2154 
2156 {
2157  return m_Diff ? m_Diff->IsSetDiff() : false;
2158 }
2159 
2161 {
2162  if ( !m_Diff ) {
2163  m_Diff.Reset(new TDiff());
2164  return;
2165  }
2166  (*m_Diff).Reset();
2167 }
2168 
2170 {
2171  m_Diff.Reset(&value);
2172 }
2173 
2175 {
2176  if ( !m_Diff ) {
2177  ResetDiff();
2178  }
2179  m_Diff->SetDiff();
2180  return (*m_Diff);
2181 }
2182 
2184 {
2185  ResetDiff();
2186 }
2187 
2189 {
2190  SET_INTERNAL_NAME("ContExp.Differential-Operator", "mmlclass");
2191  SET_CLASS_MODULE("pubmed_mathml3");
2192  ADD_NAMED_REF_MEMBER("diff", m_Diff, CDiff)->SetNsQualified(true);
2193  info->RandomOrder();
2194  info->CodeVersion(22400);
2195  info->DataSpec(ncbi::EDataSpec::eXSD);
2196 }
2198 
2199 // constructor
2201 {
2202  memset(m_set_State,0,sizeof(m_set_State));
2203  if ( !IsAllocatedInPool() ) {
2204  ResetDiff();
2205  }
2206 }
2207 
2208 // destructor
2210 {
2211 }
2212 
2213 
2215 {
2216  return m_Partialdiff ? m_Partialdiff->IsSetPartialdiff() : false;
2217 }
2218 
2220 {
2221  if ( !m_Partialdiff ) {
2222  m_Partialdiff.Reset(new TPartialdiff());
2223  return;
2224  }
2225  (*m_Partialdiff).Reset();
2226 }
2227 
2229 {
2230  m_Partialdiff.Reset(&value);
2231 }
2232 
2234 {
2235  if ( !m_Partialdiff ) {
2236  ResetPartialdiff();
2237  }
2238  m_Partialdiff->SetPartialdiff();
2239  return (*m_Partialdiff);
2240 }
2241 
2243 {
2244  ResetPartialdiff();
2245 }
2246 
2248 {
2249  SET_INTERNAL_NAME("ContExp.partialdiff", "mmlclass");
2250  SET_CLASS_MODULE("pubmed_mathml3");
2251  ADD_NAMED_REF_MEMBER("partialdiff", m_Partialdiff, CPartialdiff)->SetNsQualified(true);
2252  info->RandomOrder();
2253  info->CodeVersion(22400);
2254  info->DataSpec(ncbi::EDataSpec::eXSD);
2255 }
2257 
2258 // constructor
2260 {
2261  memset(m_set_State,0,sizeof(m_set_State));
2262  if ( !IsAllocatedInPool() ) {
2263  ResetPartialdiff();
2264  }
2265 }
2266 
2267 // destructor
2269 {
2270 }
2271 
2272 
2274 {
2275  if ( m_choice != e_not_set )
2276  ResetSelection();
2277 }
2278 
2280 {
2281  switch ( m_choice ) {
2282  case e_Divergence:
2283  case e_Grad:
2284  case e_Curl:
2285  case e_Laplacian:
2286  m_object->RemoveReference();
2287  break;
2288  default:
2289  break;
2290  }
2291  m_choice = e_not_set;
2292 }
2293 
2294 void CContExp_Base::C_Unary_veccalc_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
2295 {
2296  switch ( index ) {
2297  case e_Divergence:
2298  (m_object = new(pool) ncbi::objects::CDivergence())->AddReference();
2299  break;
2300  case e_Grad:
2301  (m_object = new(pool) ncbi::objects::CGrad())->AddReference();
2302  break;
2303  case e_Curl:
2304  (m_object = new(pool) ncbi::objects::CCurl())->AddReference();
2305  break;
2306  case e_Laplacian:
2307  (m_object = new(pool) ncbi::objects::CLaplacian())->AddReference();
2308  break;
2309  default:
2310  break;
2311  }
2312  m_choice = index;
2313 }
2314 
2316  "not set",
2317  "divergence",
2318  "grad",
2319  "curl",
2320  "laplacian"
2321 };
2322 
2324 {
2325  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2326 }
2327 
2329 {
2330  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2331 }
2332 
2334 {
2335  CheckSelected(e_Divergence);
2336  return *static_cast<const TDivergence*>(m_object);
2337 }
2338 
2340 {
2343  value.SetDivergence();
2344  return value;
2345 }
2346 
2348 {
2349  CheckSelected(e_Grad);
2350  return *static_cast<const TGrad*>(m_object);
2351 }
2352 
2354 {
2357  value.SetGrad();
2358  return value;
2359 }
2360 
2362 {
2363  CheckSelected(e_Curl);
2364  return *static_cast<const TCurl*>(m_object);
2365 }
2366 
2368 {
2371  value.SetCurl();
2372  return value;
2373 }
2374 
2376 {
2377  CheckSelected(e_Laplacian);
2378  return *static_cast<const TLaplacian*>(m_object);
2379 }
2380 
2382 {
2385  value.SetLaplacian();
2386  return value;
2387 }
2388 
2389 // helper methods
2390 
2391 // type info
2393 {
2394  SET_INTERNAL_NAME("ContExp.unary-veccalc", "mmlclass");
2395  SET_CHOICE_MODULE("pubmed_mathml3");
2396  ADD_NAMED_REF_CHOICE_VARIANT("divergence", m_object, CDivergence)->SetNsQualified(true);
2397  ADD_NAMED_REF_CHOICE_VARIANT("grad", m_object, CGrad)->SetNsQualified(true);
2398  ADD_NAMED_REF_CHOICE_VARIANT("curl", m_object, CCurl)->SetNsQualified(true);
2399  ADD_NAMED_REF_CHOICE_VARIANT("laplacian", m_object, CLaplacian)->SetNsQualified(true);
2400  info->CodeVersion(22400);
2401  info->DataSpec(ncbi::EDataSpec::eXSD);
2402 }
2404 
2405 // constructor
2407  : m_choice(e_not_set)
2408 {
2409 }
2410 
2411 // destructor
2413 {
2414  Reset();
2415 }
2416 
2417 
2419 {
2420  if ( m_choice != e_not_set )
2421  ResetSelection();
2422 }
2423 
2425 {
2426  switch ( m_choice ) {
2427  case e_Set:
2428  case e_List:
2429  m_object->RemoveReference();
2430  break;
2431  default:
2432  break;
2433  }
2434  m_choice = e_not_set;
2435 }
2436 
2437 void CContExp_Base::C_Nary_setlist_constructor_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
2438 {
2439  switch ( index ) {
2440  case e_Set:
2441  (m_object = new(pool) ncbi::objects::CSet())->AddReference();
2442  break;
2443  case e_List:
2444  (m_object = new(pool) ncbi::objects::CList())->AddReference();
2445  break;
2446  default:
2447  break;
2448  }
2449  m_choice = index;
2450 }
2451 
2453  "not set",
2454  "set",
2455  "list"
2456 };
2457 
2459 {
2460  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2461 }
2462 
2464 {
2465  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2466 }
2467 
2469 {
2470  CheckSelected(e_Set);
2471  return *static_cast<const TSet*>(m_object);
2472 }
2473 
2475 {
2477  return *static_cast<TSet*>(m_object);
2478 }
2479 
2481 {
2482  TSet* ptr = &value;
2483  if ( m_choice != e_Set || m_object != ptr ) {
2484  ResetSelection();
2485  (m_object = ptr)->AddReference();
2486  m_choice = e_Set;
2487  }
2488 }
2489 
2491 {
2492  CheckSelected(e_List);
2493  return *static_cast<const TList*>(m_object);
2494 }
2495 
2497 {
2499  return *static_cast<TList*>(m_object);
2500 }
2501 
2503 {
2504  TList* ptr = &value;
2505  if ( m_choice != e_List || m_object != ptr ) {
2506  ResetSelection();
2507  (m_object = ptr)->AddReference();
2508  m_choice = e_List;
2509  }
2510 }
2511 
2512 // helper methods
2513 
2514 // type info
2516 {
2517  SET_INTERNAL_NAME("ContExp.nary-setlist-constructor", "mmlclass");
2518  SET_CHOICE_MODULE("pubmed_mathml3");
2519  ADD_NAMED_REF_CHOICE_VARIANT("set", m_object, CSet)->SetNsQualified(true);
2520  ADD_NAMED_REF_CHOICE_VARIANT("list", m_object, CList)->SetNsQualified(true);
2521  info->CodeVersion(22400);
2522  info->DataSpec(ncbi::EDataSpec::eXSD);
2523 }
2525 
2526 // constructor
2528  : m_choice(e_not_set)
2529 {
2530 }
2531 
2532 // destructor
2534 {
2535  Reset();
2536 }
2537 
2538 
2540 {
2541  if ( m_choice != e_not_set )
2542  ResetSelection();
2543 }
2544 
2546 {
2547  switch ( m_choice ) {
2548  case e_Union:
2549  case e_Intersect:
2550  case e_Cartesianproduct:
2551  m_object->RemoveReference();
2552  break;
2553  default:
2554  break;
2555  }
2556  m_choice = e_not_set;
2557 }
2558 
2559 void CContExp_Base::C_Nary_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
2560 {
2561  switch ( index ) {
2562  case e_Union:
2563  (m_object = new(pool) ncbi::objects::CUnion())->AddReference();
2564  break;
2565  case e_Intersect:
2566  (m_object = new(pool) ncbi::objects::CIntersect())->AddReference();
2567  break;
2568  case e_Cartesianproduct:
2569  (m_object = new(pool) ncbi::objects::CCartesianproduct())->AddReference();
2570  break;
2571  default:
2572  break;
2573  }
2574  m_choice = index;
2575 }
2576 
2578  "not set",
2579  "union",
2580  "intersect",
2581  "cartesianproduct"
2582 };
2583 
2585 {
2586  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2587 }
2588 
2590 {
2591  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2592 }
2593 
2595 {
2596  CheckSelected(e_Union);
2597  return *static_cast<const TUnion*>(m_object);
2598 }
2599 
2601 {
2604  value.SetUnion();
2605  return value;
2606 }
2607 
2609 {
2610  CheckSelected(e_Intersect);
2611  return *static_cast<const TIntersect*>(m_object);
2612 }
2613 
2615 {
2618  value.SetIntersect();
2619  return value;
2620 }
2621 
2623 {
2624  CheckSelected(e_Cartesianproduct);
2625  return *static_cast<const TCartesianproduct*>(m_object);
2626 }
2627 
2629 {
2630  Select(e_Cartesianproduct, NCBI_NS_NCBI::eDoNotResetVariant);
2632  value.SetCartesianproduct();
2633  return value;
2634 }
2635 
2636 // helper methods
2637 
2638 // type info
2640 {
2641  SET_INTERNAL_NAME("ContExp.nary-set", "mmlclass");
2642  SET_CHOICE_MODULE("pubmed_mathml3");
2643  ADD_NAMED_REF_CHOICE_VARIANT("union", m_object, CUnion)->SetNsQualified(true);
2644  ADD_NAMED_REF_CHOICE_VARIANT("intersect", m_object, CIntersect)->SetNsQualified(true);
2645  ADD_NAMED_REF_CHOICE_VARIANT("cartesianproduct", m_object, CCartesianproduct)->SetNsQualified(true);
2646  info->CodeVersion(22400);
2647  info->DataSpec(ncbi::EDataSpec::eXSD);
2648 }
2650 
2651 // constructor
2653  : m_choice(e_not_set)
2654 {
2655 }
2656 
2657 // destructor
2659 {
2660  Reset();
2661 }
2662 
2663 
2665 {
2666  if ( m_choice != e_not_set )
2667  ResetSelection();
2668 }
2669 
2671 {
2672  switch ( m_choice ) {
2673  case e_In:
2674  case e_Notin:
2675  case e_Notsubset:
2676  case e_Notprsubset:
2677  case e_Setdiff:
2678  m_object->RemoveReference();
2679  break;
2680  default:
2681  break;
2682  }
2683  m_choice = e_not_set;
2684 }
2685 
2686 void CContExp_Base::C_Binary_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
2687 {
2688  switch ( index ) {
2689  case e_In:
2690  (m_object = new(pool) ncbi::objects::CIn())->AddReference();
2691  break;
2692  case e_Notin:
2693  (m_object = new(pool) ncbi::objects::CNotin())->AddReference();
2694  break;
2695  case e_Notsubset:
2696  (m_object = new(pool) ncbi::objects::CNotsubset())->AddReference();
2697  break;
2698  case e_Notprsubset:
2699  (m_object = new(pool) ncbi::objects::CNotprsubset())->AddReference();
2700  break;
2701  case e_Setdiff:
2702  (m_object = new(pool) ncbi::objects::CSetdiff())->AddReference();
2703  break;
2704  default:
2705  break;
2706  }
2707  m_choice = index;
2708 }
2709 
2711  "not set",
2712  "in",
2713  "notin",
2714  "notsubset",
2715  "notprsubset",
2716  "setdiff"
2717 };
2718 
2720 {
2721  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2722 }
2723 
2725 {
2726  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2727 }
2728 
2730 {
2731  CheckSelected(e_In);
2732  return *static_cast<const TIn*>(m_object);
2733 }
2734 
2736 {
2739  value.SetIn();
2740  return value;
2741 }
2742 
2744 {
2745  CheckSelected(e_Notin);
2746  return *static_cast<const TNotin*>(m_object);
2747 }
2748 
2750 {
2753  value.SetNotin();
2754  return value;
2755 }
2756 
2758 {
2759  CheckSelected(e_Notsubset);
2760  return *static_cast<const TNotsubset*>(m_object);
2761 }
2762 
2764 {
2767  value.SetNotsubset();
2768  return value;
2769 }
2770 
2772 {
2773  CheckSelected(e_Notprsubset);
2774  return *static_cast<const TNotprsubset*>(m_object);
2775 }
2776 
2778 {
2779  Select(e_Notprsubset, NCBI_NS_NCBI::eDoNotResetVariant);
2781  value.SetNotprsubset();
2782  return value;
2783 }
2784 
2786 {
2787  CheckSelected(e_Setdiff);
2788  return *static_cast<const TSetdiff*>(m_object);
2789 }
2790 
2792 {
2795  value.SetSetdiff();
2796  return value;
2797 }
2798 
2799 // helper methods
2800 
2801 // type info
2803 {
2804  SET_INTERNAL_NAME("ContExp.binary-set", "mmlclass");
2805  SET_CHOICE_MODULE("pubmed_mathml3");
2806  ADD_NAMED_REF_CHOICE_VARIANT("in", m_object, CIn)->SetNsQualified(true);
2807  ADD_NAMED_REF_CHOICE_VARIANT("notin", m_object, CNotin)->SetNsQualified(true);
2808  ADD_NAMED_REF_CHOICE_VARIANT("notsubset", m_object, CNotsubset)->SetNsQualified(true);
2809  ADD_NAMED_REF_CHOICE_VARIANT("notprsubset", m_object, CNotprsubset)->SetNsQualified(true);
2810  ADD_NAMED_REF_CHOICE_VARIANT("setdiff", m_object, CSetdiff)->SetNsQualified(true);
2811  info->CodeVersion(22400);
2812  info->DataSpec(ncbi::EDataSpec::eXSD);
2813 }
2815 
2816 // constructor
2818  : m_choice(e_not_set)
2819 {
2820 }
2821 
2822 // destructor
2824 {
2825  Reset();
2826 }
2827 
2828 
2830 {
2831  if ( m_choice != e_not_set )
2832  ResetSelection();
2833 }
2834 
2836 {
2837  switch ( m_choice ) {
2838  case e_Subset:
2839  case e_Prsubset:
2840  m_object->RemoveReference();
2841  break;
2842  default:
2843  break;
2844  }
2845  m_choice = e_not_set;
2846 }
2847 
2848 void CContExp_Base::C_Nary_set_reln_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
2849 {
2850  switch ( index ) {
2851  case e_Subset:
2852  (m_object = new(pool) ncbi::objects::CSubset())->AddReference();
2853  break;
2854  case e_Prsubset:
2855  (m_object = new(pool) ncbi::objects::CPrsubset())->AddReference();
2856  break;
2857  default:
2858  break;
2859  }
2860  m_choice = index;
2861 }
2862 
2864  "not set",
2865  "subset",
2866  "prsubset"
2867 };
2868 
2870 {
2871  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2872 }
2873 
2875 {
2876  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2877 }
2878 
2880 {
2881  CheckSelected(e_Subset);
2882  return *static_cast<const TSubset*>(m_object);
2883 }
2884 
2886 {
2889  value.SetSubset();
2890  return value;
2891 }
2892 
2894 {
2895  CheckSelected(e_Prsubset);
2896  return *static_cast<const TPrsubset*>(m_object);
2897 }
2898 
2900 {
2903  value.SetPrsubset();
2904  return value;
2905 }
2906 
2907 // helper methods
2908 
2909 // type info
2911 {
2912  SET_INTERNAL_NAME("ContExp.nary-set-reln", "mmlclass");
2913  SET_CHOICE_MODULE("pubmed_mathml3");
2914  ADD_NAMED_REF_CHOICE_VARIANT("subset", m_object, CSubset)->SetNsQualified(true);
2915  ADD_NAMED_REF_CHOICE_VARIANT("prsubset", m_object, CPrsubset)->SetNsQualified(true);
2916  info->CodeVersion(22400);
2917  info->DataSpec(ncbi::EDataSpec::eXSD);
2918 }
2920 
2921 // constructor
2923  : m_choice(e_not_set)
2924 {
2925 }
2926 
2927 // destructor
2929 {
2930  Reset();
2931 }
2932 
2933 
2935 {
2936  return m_Card ? m_Card->IsSetCard() : false;
2937 }
2938 
2940 {
2941  if ( !m_Card ) {
2942  m_Card.Reset(new TCard());
2943  return;
2944  }
2945  (*m_Card).Reset();
2946 }
2947 
2949 {
2950  m_Card.Reset(&value);
2951 }
2952 
2954 {
2955  if ( !m_Card ) {
2956  ResetCard();
2957  }
2958  m_Card->SetCard();
2959  return (*m_Card);
2960 }
2961 
2963 {
2964  ResetCard();
2965 }
2966 
2968 {
2969  SET_INTERNAL_NAME("ContExp.unary-set", "mmlclass");
2970  SET_CLASS_MODULE("pubmed_mathml3");
2971  ADD_NAMED_REF_MEMBER("card", m_Card, CCard)->SetNsQualified(true);
2972  info->RandomOrder();
2973  info->CodeVersion(22400);
2974  info->DataSpec(ncbi::EDataSpec::eXSD);
2975 }
2977 
2978 // constructor
2980 {
2981  memset(m_set_State,0,sizeof(m_set_State));
2982  if ( !IsAllocatedInPool() ) {
2983  ResetCard();
2984  }
2985 }
2986 
2987 // destructor
2989 {
2990 }
2991 
2992 
2994 {
2995  return m_Sum ? m_Sum->IsSetSum() : false;
2996 }
2997 
2999 {
3000  if ( !m_Sum ) {
3001  m_Sum.Reset(new TSum());
3002  return;
3003  }
3004  (*m_Sum).Reset();
3005 }
3006 
3008 {
3009  m_Sum.Reset(&value);
3010 }
3011 
3013 {
3014  if ( !m_Sum ) {
3015  ResetSum();
3016  }
3017  m_Sum->SetSum();
3018  return (*m_Sum);
3019 }
3020 
3022 {
3023  ResetSum();
3024 }
3025 
3027 {
3028  SET_INTERNAL_NAME("ContExp.sum", "mmlclass");
3029  SET_CLASS_MODULE("pubmed_mathml3");
3030  ADD_NAMED_REF_MEMBER("sum", m_Sum, CSum)->SetNsQualified(true);
3031  info->RandomOrder();
3032  info->CodeVersion(22400);
3033  info->DataSpec(ncbi::EDataSpec::eXSD);
3034 }
3036 
3037 // constructor
3039 {
3040  memset(m_set_State,0,sizeof(m_set_State));
3041  if ( !IsAllocatedInPool() ) {
3042  ResetSum();
3043  }
3044 }
3045 
3046 // destructor
3048 {
3049 }
3050 
3051 
3053 {
3054  return m_Product ? m_Product->IsSetProduct() : false;
3055 }
3056 
3058 {
3059  if ( !m_Product ) {
3060  m_Product.Reset(new TProduct());
3061  return;
3062  }
3063  (*m_Product).Reset();
3064 }
3065 
3067 {
3068  m_Product.Reset(&value);
3069 }
3070 
3072 {
3073  if ( !m_Product ) {
3074  ResetProduct();
3075  }
3076  m_Product->SetProduct();
3077  return (*m_Product);
3078 }
3079 
3081 {
3082  ResetProduct();
3083 }
3084 
3086 {
3087  SET_INTERNAL_NAME("ContExp.product", "mmlclass");
3088  SET_CLASS_MODULE("pubmed_mathml3");
3089  ADD_NAMED_REF_MEMBER("product", m_Product, CProduct)->SetNsQualified(true);
3090  info->RandomOrder();
3091  info->CodeVersion(22400);
3092  info->DataSpec(ncbi::EDataSpec::eXSD);
3093 }
3095 
3096 // constructor
3098 {
3099  memset(m_set_State,0,sizeof(m_set_State));
3100  if ( !IsAllocatedInPool() ) {
3101  ResetProduct();
3102  }
3103 }
3104 
3105 // destructor
3107 {
3108 }
3109 
3110 
3112 {
3113  return m_Limit ? m_Limit->IsSetLimit() : false;
3114 }
3115 
3117 {
3118  if ( !m_Limit ) {
3119  m_Limit.Reset(new TLimit());
3120  return;
3121  }
3122  (*m_Limit).Reset();
3123 }
3124 
3126 {
3127  m_Limit.Reset(&value);
3128 }
3129 
3131 {
3132  if ( !m_Limit ) {
3133  ResetLimit();
3134  }
3135  m_Limit->SetLimit();
3136  return (*m_Limit);
3137 }
3138 
3140 {
3141  ResetLimit();
3142 }
3143 
3145 {
3146  SET_INTERNAL_NAME("ContExp.limit", "mmlclass");
3147  SET_CLASS_MODULE("pubmed_mathml3");
3148  ADD_NAMED_REF_MEMBER("limit", m_Limit, CLimit)->SetNsQualified(true);
3149  info->RandomOrder();
3150  info->CodeVersion(22400);
3151  info->DataSpec(ncbi::EDataSpec::eXSD);
3152 }
3154 
3155 // constructor
3157 {
3158  memset(m_set_State,0,sizeof(m_set_State));
3159  if ( !IsAllocatedInPool() ) {
3160  ResetLimit();
3161  }
3162 }
3163 
3164 // destructor
3166 {
3167 }
3168 
3169 
3171 {
3172  if ( m_choice != e_not_set )
3173  ResetSelection();
3174 }
3175 
3177 {
3178  switch ( m_choice ) {
3179  case e_Sin:
3180  case e_Cos:
3181  case e_Tan:
3182  case e_Sec:
3183  case e_Csc:
3184  case e_Cot:
3185  case e_Sinh:
3186  case e_Cosh:
3187  case e_Tanh:
3188  case e_Sech:
3189  case e_Csch:
3190  case e_Coth:
3191  case e_Arcsin:
3192  case e_Arccos:
3193  case e_Arctan:
3194  case e_Arccosh:
3195  case e_Arccot:
3196  case e_Arccoth:
3197  case e_Arccsc:
3198  case e_Arccsch:
3199  case e_Arcsec:
3200  case e_Arcsech:
3201  case e_Arcsinh:
3202  case e_Arctanh:
3203  m_object->RemoveReference();
3204  break;
3205  default:
3206  break;
3207  }
3208  m_choice = e_not_set;
3209 }
3210 
3211 void CContExp_Base::C_Unary_elementary_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
3212 {
3213  switch ( index ) {
3214  case e_Sin:
3215  (m_object = new(pool) ncbi::objects::CSin())->AddReference();
3216  break;
3217  case e_Cos:
3218  (m_object = new(pool) ncbi::objects::CCos())->AddReference();
3219  break;
3220  case e_Tan:
3221  (m_object = new(pool) ncbi::objects::CTan())->AddReference();
3222  break;
3223  case e_Sec:
3224  (m_object = new(pool) ncbi::objects::CSec())->AddReference();
3225  break;
3226  case e_Csc:
3227  (m_object = new(pool) ncbi::objects::CCsc())->AddReference();
3228  break;
3229  case e_Cot:
3230  (m_object = new(pool) ncbi::objects::CCot())->AddReference();
3231  break;
3232  case e_Sinh:
3233  (m_object = new(pool) ncbi::objects::CSinh())->AddReference();
3234  break;
3235  case e_Cosh:
3236  (m_object = new(pool) ncbi::objects::CCosh())->AddReference();
3237  break;
3238  case e_Tanh:
3239  (m_object = new(pool) ncbi::objects::CTanh())->AddReference();
3240  break;
3241  case e_Sech:
3242  (m_object = new(pool) ncbi::objects::CSech())->AddReference();
3243  break;
3244  case e_Csch:
3245  (m_object = new(pool) ncbi::objects::CCsch())->AddReference();
3246  break;
3247  case e_Coth:
3248  (m_object = new(pool) ncbi::objects::CCoth())->AddReference();
3249  break;
3250  case e_Arcsin:
3251  (m_object = new(pool) ncbi::objects::CArcsin())->AddReference();
3252  break;
3253  case e_Arccos:
3254  (m_object = new(pool) ncbi::objects::CArccos())->AddReference();
3255  break;
3256  case e_Arctan:
3257  (m_object = new(pool) ncbi::objects::CArctan())->AddReference();
3258  break;
3259  case e_Arccosh:
3260  (m_object = new(pool) ncbi::objects::CArccosh())->AddReference();
3261  break;
3262  case e_Arccot:
3263  (m_object = new(pool) ncbi::objects::CArccot())->AddReference();
3264  break;
3265  case e_Arccoth:
3266  (m_object = new(pool) ncbi::objects::CArccoth())->AddReference();
3267  break;
3268  case e_Arccsc:
3269  (m_object = new(pool) ncbi::objects::CArccsc())->AddReference();
3270  break;
3271  case e_Arccsch:
3272  (m_object = new(pool) ncbi::objects::CArccsch())->AddReference();
3273  break;
3274  case e_Arcsec:
3275  (m_object = new(pool) ncbi::objects::CArcsec())->AddReference();
3276  break;
3277  case e_Arcsech:
3278  (m_object = new(pool) ncbi::objects::CArcsech())->AddReference();
3279  break;
3280  case e_Arcsinh:
3281  (m_object = new(pool) ncbi::objects::CArcsinh())->AddReference();
3282  break;
3283  case e_Arctanh:
3284  (m_object = new(pool) ncbi::objects::CArctanh())->AddReference();
3285  break;
3286  default:
3287  break;
3288  }
3289  m_choice = index;
3290 }
3291 
3293  "not set",
3294  "sin",
3295  "cos",
3296  "tan",
3297  "sec",
3298  "csc",
3299  "cot",
3300  "sinh",
3301  "cosh",
3302  "tanh",
3303  "sech",
3304  "csch",
3305  "coth",
3306  "arcsin",
3307  "arccos",
3308  "arctan",
3309  "arccosh",
3310  "arccot",
3311  "arccoth",
3312  "arccsc",
3313  "arccsch",
3314  "arcsec",
3315  "arcsech",
3316  "arcsinh",
3317  "arctanh"
3318 };
3319 
3321 {
3322  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3323 }
3324 
3326 {
3327  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3328 }
3329 
3331 {
3332  CheckSelected(e_Sin);
3333  return *static_cast<const TSin*>(m_object);
3334 }
3335 
3337 {
3340  value.SetSin();
3341  return value;
3342 }
3343 
3345 {
3346  CheckSelected(e_Cos);
3347  return *static_cast<const TCos*>(m_object);
3348 }
3349 
3351 {
3354  value.SetCos();
3355  return value;
3356 }
3357 
3359 {
3360  CheckSelected(e_Tan);
3361  return *static_cast<const TTan*>(m_object);
3362 }
3363 
3365 {
3368  value.SetTan();
3369  return value;
3370 }
3371 
3373 {
3374  CheckSelected(e_Sec);
3375  return *static_cast<const TSec*>(m_object);
3376 }
3377 
3379 {
3382  value.SetSec();
3383  return value;
3384 }
3385 
3387 {
3388  CheckSelected(e_Csc);
3389  return *static_cast<const TCsc*>(m_object);
3390 }
3391 
3393 {
3396  value.SetCsc();
3397  return value;
3398 }
3399 
3401 {
3402  CheckSelected(e_Cot);
3403  return *static_cast<const TCot*>(m_object);
3404 }
3405 
3407 {
3410  value.SetCot();
3411  return value;
3412 }
3413 
3415 {
3416  CheckSelected(e_Sinh);
3417  return *static_cast<const TSinh*>(m_object);
3418 }
3419 
3421 {
3424  value.SetSinh();
3425  return value;
3426 }
3427 
3429 {
3430  CheckSelected(e_Cosh);
3431  return *static_cast<const TCosh*>(m_object);
3432 }
3433 
3435 {
3438  value.SetCosh();
3439  return value;
3440 }
3441 
3443 {
3444  CheckSelected(e_Tanh);
3445  return *static_cast<const TTanh*>(m_object);
3446 }
3447 
3449 {
3452  value.SetTanh();
3453  return value;
3454 }
3455 
3457 {
3458  CheckSelected(e_Sech);
3459  return *static_cast<const TSech*>(m_object);
3460 }
3461 
3463 {
3466  value.SetSech();
3467  return value;
3468 }
3469 
3471 {
3472  CheckSelected(e_Csch);
3473  return *static_cast<const TCsch*>(m_object);
3474 }
3475 
3477 {
3480  value.SetCsch();
3481  return value;
3482 }
3483 
3485 {
3486  CheckSelected(e_Coth);
3487  return *static_cast<const TCoth*>(m_object);
3488 }
3489 
3491 {
3494  value.SetCoth();
3495  return value;
3496 }
3497 
3499 {
3500  CheckSelected(e_Arcsin);
3501  return *static_cast<const TArcsin*>(m_object);
3502 }
3503 
3505 {
3508  value.SetArcsin();
3509  return value;
3510 }
3511 
3513 {
3514  CheckSelected(e_Arccos);
3515  return *static_cast<const TArccos*>(m_object);
3516 }
3517 
3519 {
3522  value.SetArccos();
3523  return value;
3524 }
3525 
3527 {
3528  CheckSelected(e_Arctan);
3529  return *static_cast<const TArctan*>(m_object);
3530 }
3531 
3533 {
3536  value.SetArctan();
3537  return value;
3538 }
3539 
3541 {
3542  CheckSelected(e_Arccosh);
3543  return *static_cast<const TArccosh*>(m_object);
3544 }
3545 
3547 {
3550  value.SetArccosh();
3551  return value;
3552 }
3553 
3555 {
3556  CheckSelected(e_Arccot);
3557  return *static_cast<const TArccot*>(m_object);
3558 }
3559 
3561 {
3564  value.SetArccot();
3565  return value;
3566 }
3567 
3569 {
3570  CheckSelected(e_Arccoth);
3571  return *static_cast<const TArccoth*>(m_object);
3572 }
3573 
3575 {
3578  value.SetArccoth();
3579  return value;
3580 }
3581 
3583 {
3584  CheckSelected(e_Arccsc);
3585  return *static_cast<const TArccsc*>(m_object);
3586 }
3587 
3589 {
3592  value.SetArccsc();
3593  return value;
3594 }
3595 
3597 {
3598  CheckSelected(e_Arccsch);
3599  return *static_cast<const TArccsch*>(m_object);
3600 }
3601 
3603 {
3606  value.SetArccsch();
3607  return value;
3608 }
3609 
3611 {
3612  CheckSelected(e_Arcsec);
3613  return *static_cast<const TArcsec*>(m_object);
3614 }
3615 
3617 {
3620  value.SetArcsec();
3621  return value;
3622 }
3623 
3625 {
3626  CheckSelected(e_Arcsech);
3627  return *static_cast<const TArcsech*>(m_object);
3628 }
3629 
3631 {
3634  value.SetArcsech();
3635  return value;
3636 }
3637 
3639 {
3640  CheckSelected(e_Arcsinh);
3641  return *static_cast<const TArcsinh*>(m_object);
3642 }
3643 
3645 {
3648  value.SetArcsinh();
3649  return value;
3650 }
3651 
3653 {
3654  CheckSelected(e_Arctanh);
3655  return *static_cast<const TArctanh*>(m_object);
3656 }
3657 
3659 {
3662  value.SetArctanh();
3663  return value;
3664 }
3665 
3666 // helper methods
3667 
3668 // type info
3670 {
3671  SET_INTERNAL_NAME("ContExp.unary-elementary", "mmlclass");
3672  SET_CHOICE_MODULE("pubmed_mathml3");
3673  ADD_NAMED_REF_CHOICE_VARIANT("sin", m_object, CSin)->SetNsQualified(true);
3674  ADD_NAMED_REF_CHOICE_VARIANT("cos", m_object, CCos)->SetNsQualified(true);
3675  ADD_NAMED_REF_CHOICE_VARIANT("tan", m_object, CTan)->SetNsQualified(true);
3676  ADD_NAMED_REF_CHOICE_VARIANT("sec", m_object, CSec)->SetNsQualified(true);
3677  ADD_NAMED_REF_CHOICE_VARIANT("csc", m_object, CCsc)->SetNsQualified(true);
3678  ADD_NAMED_REF_CHOICE_VARIANT("cot", m_object, CCot)->SetNsQualified(true);
3679  ADD_NAMED_REF_CHOICE_VARIANT("sinh", m_object, CSinh)->SetNsQualified(true);
3680  ADD_NAMED_REF_CHOICE_VARIANT("cosh", m_object, CCosh)->SetNsQualified(true);
3681  ADD_NAMED_REF_CHOICE_VARIANT("tanh", m_object, CTanh)->SetNsQualified(true);
3682  ADD_NAMED_REF_CHOICE_VARIANT("sech", m_object, CSech)->SetNsQualified(true);
3683  ADD_NAMED_REF_CHOICE_VARIANT("csch", m_object, CCsch)->SetNsQualified(true);
3684  ADD_NAMED_REF_CHOICE_VARIANT("coth", m_object, CCoth)->SetNsQualified(true);
3685  ADD_NAMED_REF_CHOICE_VARIANT("arcsin", m_object, CArcsin)->SetNsQualified(true);
3686  ADD_NAMED_REF_CHOICE_VARIANT("arccos", m_object, CArccos)->SetNsQualified(true);
3687  ADD_NAMED_REF_CHOICE_VARIANT("arctan", m_object, CArctan)->SetNsQualified(true);
3688  ADD_NAMED_REF_CHOICE_VARIANT("arccosh", m_object, CArccosh)->SetNsQualified(true);
3689  ADD_NAMED_REF_CHOICE_VARIANT("arccot", m_object, CArccot)->SetNsQualified(true);
3690  ADD_NAMED_REF_CHOICE_VARIANT("arccoth", m_object, CArccoth)->SetNsQualified(true);
3691  ADD_NAMED_REF_CHOICE_VARIANT("arccsc", m_object, CArccsc)->SetNsQualified(true);
3692  ADD_NAMED_REF_CHOICE_VARIANT("arccsch", m_object, CArccsch)->SetNsQualified(true);
3693  ADD_NAMED_REF_CHOICE_VARIANT("arcsec", m_object, CArcsec)->SetNsQualified(true);
3694  ADD_NAMED_REF_CHOICE_VARIANT("arcsech", m_object, CArcsech)->SetNsQualified(true);
3695  ADD_NAMED_REF_CHOICE_VARIANT("arcsinh", m_object, CArcsinh)->SetNsQualified(true);
3696  ADD_NAMED_REF_CHOICE_VARIANT("arctanh", m_object, CArctanh)->SetNsQualified(true);
3697  info->CodeVersion(22400);
3698  info->DataSpec(ncbi::EDataSpec::eXSD);
3699 }
3701 
3702 // constructor
3704  : m_choice(e_not_set)
3705 {
3706 }
3707 
3708 // destructor
3710 {
3711  Reset();
3712 }
3713 
3714 
3716 {
3717  if ( m_choice != e_not_set )
3718  ResetSelection();
3719 }
3720 
3722 {
3723  switch ( m_choice ) {
3724  case e_Mean:
3725  case e_Sdev:
3726  case e_Variance:
3727  case e_Median:
3728  case e_Mode:
3729  m_object->RemoveReference();
3730  break;
3731  default:
3732  break;
3733  }
3734  m_choice = e_not_set;
3735 }
3736 
3737 void CContExp_Base::C_Nary_stats_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
3738 {
3739  switch ( index ) {
3740  case e_Mean:
3741  (m_object = new(pool) ncbi::objects::CMean())->AddReference();
3742  break;
3743  case e_Sdev:
3744  (m_object = new(pool) ncbi::objects::CSdev())->AddReference();
3745  break;
3746  case e_Variance:
3747  (m_object = new(pool) ncbi::objects::CVariance())->AddReference();
3748  break;
3749  case e_Median:
3750  (m_object = new(pool) ncbi::objects::CMedian())->AddReference();
3751  break;
3752  case e_Mode:
3753  (m_object = new(pool) ncbi::objects::CMode())->AddReference();
3754  break;
3755  default:
3756  break;
3757  }
3758  m_choice = index;
3759 }
3760 
3762  "not set",
3763  "mean",
3764  "sdev",
3765  "variance",
3766  "median",
3767  "mode"
3768 };
3769 
3771 {
3772  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3773 }
3774 
3776 {
3777  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3778 }
3779 
3781 {
3782  CheckSelected(e_Mean);
3783  return *static_cast<const TMean*>(m_object);
3784 }
3785 
3787 {
3790  value.SetMean();
3791  return value;
3792 }
3793 
3795 {
3796  CheckSelected(e_Sdev);
3797  return *static_cast<const TSdev*>(m_object);
3798 }
3799 
3801 {
3804  value.SetSdev();
3805  return value;
3806 }
3807 
3809 {
3810  CheckSelected(e_Variance);
3811  return *static_cast<const TVariance*>(m_object);
3812 }
3813 
3815 {
3818  value.SetVariance();
3819  return value;
3820 }
3821 
3823 {
3824  CheckSelected(e_Median);
3825  return *static_cast<const TMedian*>(m_object);
3826 }
3827 
3829 {
3832  value.SetMedian();
3833  return value;
3834 }
3835 
3837 {
3838  CheckSelected(e_Mode);
3839  return *static_cast<const TMode*>(m_object);
3840 }
3841 
3843 {
3846  value.SetMode();
3847  return value;
3848 }
3849 
3850 // helper methods
3851 
3852 // type info
3854 {
3855  SET_INTERNAL_NAME("ContExp.nary-stats", "mmlclass");
3856  SET_CHOICE_MODULE("pubmed_mathml3");
3857  ADD_NAMED_REF_CHOICE_VARIANT("mean", m_object, CMean)->SetNsQualified(true);
3858  ADD_NAMED_REF_CHOICE_VARIANT("sdev", m_object, CSdev)->SetNsQualified(true);
3859  ADD_NAMED_REF_CHOICE_VARIANT("variance", m_object, CVariance)->SetNsQualified(true);
3860  ADD_NAMED_REF_CHOICE_VARIANT("median", m_object, CMedian)->SetNsQualified(true);
3861  ADD_NAMED_REF_CHOICE_VARIANT("mode", m_object, CMode)->SetNsQualified(true);
3862  info->CodeVersion(22400);
3863  info->DataSpec(ncbi::EDataSpec::eXSD);
3864 }
3866 
3867 // constructor
3869  : m_choice(e_not_set)
3870 {
3871 }
3872 
3873 // destructor
3875 {
3876  Reset();
3877 }
3878 
3879 
3881 {
3882  if ( m_choice != e_not_set )
3883  ResetSelection();
3884 }
3885 
3887 {
3888  switch ( m_choice ) {
3889  case e_Vector:
3890  case e_Matrix:
3891  case e_Matrixrow:
3892  m_object->RemoveReference();
3893  break;
3894  default:
3895  break;
3896  }
3897  m_choice = e_not_set;
3898 }
3899 
3900 void CContExp_Base::C_Nary_constructor_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
3901 {
3902  switch ( index ) {
3903  case e_Vector:
3904  (m_object = new(pool) ncbi::objects::CVector())->AddReference();
3905  break;
3906  case e_Matrix:
3907  (m_object = new(pool) ncbi::objects::CMatrix())->AddReference();
3908  break;
3909  case e_Matrixrow:
3910  (m_object = new(pool) ncbi::objects::CMatrixrow())->AddReference();
3911  break;
3912  default:
3913  break;
3914  }
3915  m_choice = index;
3916 }
3917 
3919  "not set",
3920  "vector",
3921  "matrix",
3922  "matrixrow"
3923 };
3924 
3926 {
3927  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3928 }
3929 
3931 {
3932  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3933 }
3934 
3936 {
3937  CheckSelected(e_Vector);
3938  return *static_cast<const TVector*>(m_object);
3939 }
3940 
3942 {
3944  return *static_cast<TVector*>(m_object);
3945 }
3946 
3948 {
3949  TVector* ptr = &value;
3950  if ( m_choice != e_Vector || m_object != ptr ) {
3951  ResetSelection();
3952  (m_object = ptr)->AddReference();
3953  m_choice = e_Vector;
3954  }
3955 }
3956 
3958 {
3959  CheckSelected(e_Matrix);
3960  return *static_cast<const TMatrix*>(m_object);
3961 }
3962 
3964 {
3966  return *static_cast<TMatrix*>(m_object);
3967 }
3968 
3970 {
3971  TMatrix* ptr = &value;
3972  if ( m_choice != e_Matrix || m_object != ptr ) {
3973  ResetSelection();
3974  (m_object = ptr)->AddReference();
3975  m_choice = e_Matrix;
3976  }
3977 }
3978 
3980 {
3981  CheckSelected(e_Matrixrow);
3982  return *static_cast<const TMatrixrow*>(m_object);
3983 }
3984 
3986 {
3988  return *static_cast<TMatrixrow*>(m_object);
3989 }
3990 
3992 {
3993  TMatrixrow* ptr = &value;
3994  if ( m_choice != e_Matrixrow || m_object != ptr ) {
3995  ResetSelection();
3996  (m_object = ptr)->AddReference();
3997  m_choice = e_Matrixrow;
3998  }
3999 }
4000 
4001 // helper methods
4002 
4003 // type info
4005 {
4006  SET_INTERNAL_NAME("ContExp.nary-constructor", "mmlclass");
4007  SET_CHOICE_MODULE("pubmed_mathml3");
4008  ADD_NAMED_REF_CHOICE_VARIANT("vector", m_object, CVector)->SetNsQualified(true);
4009  ADD_NAMED_REF_CHOICE_VARIANT("matrix", m_object, CMatrix)->SetNsQualified(true);
4010  ADD_NAMED_REF_CHOICE_VARIANT("matrixrow", m_object, CMatrixrow)->SetNsQualified(true);
4011  info->CodeVersion(22400);
4012  info->DataSpec(ncbi::EDataSpec::eXSD);
4013 }
4015 
4016 // constructor
4018  : m_choice(e_not_set)
4019 {
4020 }
4021 
4022 // destructor
4024 {
4025  Reset();
4026 }
4027 
4028 
4030 {
4031  if ( m_choice != e_not_set )
4032  ResetSelection();
4033 }
4034 
4036 {
4037  switch ( m_choice ) {
4038  case e_Determinant:
4039  case e_Transpose:
4040  m_object->RemoveReference();
4041  break;
4042  default:
4043  break;
4044  }
4045  m_choice = e_not_set;
4046 }
4047 
4048 void CContExp_Base::C_Unary_linalg_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
4049 {
4050  switch ( index ) {
4051  case e_Determinant:
4052  (m_object = new(pool) ncbi::objects::CDeterminant())->AddReference();
4053  break;
4054  case e_Transpose:
4055  (m_object = new(pool) ncbi::objects::CTranspose())->AddReference();
4056  break;
4057  default:
4058  break;
4059  }
4060  m_choice = index;
4061 }
4062 
4064  "not set",
4065  "determinant",
4066  "transpose"
4067 };
4068 
4070 {
4071  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4072 }
4073 
4075 {
4076  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4077 }
4078 
4080 {
4081  CheckSelected(e_Determinant);
4082  return *static_cast<const TDeterminant*>(m_object);
4083 }
4084 
4086 {
4087  Select(e_Determinant, NCBI_NS_NCBI::eDoNotResetVariant);
4089  value.SetDeterminant();
4090  return value;
4091 }
4092 
4094 {
4095  CheckSelected(e_Transpose);
4096  return *static_cast<const TTranspose*>(m_object);
4097 }
4098 
4100 {
4103  value.SetTranspose();
4104  return value;
4105 }
4106 
4107 // helper methods
4108 
4109 // type info
4111 {
4112  SET_INTERNAL_NAME("ContExp.unary-linalg", "mmlclass");
4113  SET_CHOICE_MODULE("pubmed_mathml3");
4114  ADD_NAMED_REF_CHOICE_VARIANT("determinant", m_object, CDeterminant)->SetNsQualified(true);
4115  ADD_NAMED_REF_CHOICE_VARIANT("transpose", m_object, CTranspose)->SetNsQualified(true);
4116  info->CodeVersion(22400);
4117  info->DataSpec(ncbi::EDataSpec::eXSD);
4118 }
4120 
4121 // constructor
4123  : m_choice(e_not_set)
4124 {
4125 }
4126 
4127 // destructor
4129 {
4130  Reset();
4131 }
4132 
4133 
4135 {
4136  return m_Selector ? m_Selector->IsSetSelector() : false;
4137 }
4138 
4140 {
4141  if ( !m_Selector ) {
4142  m_Selector.Reset(new TSelector());
4143  return;
4144  }
4145  (*m_Selector).Reset();
4146 }
4147 
4149 {
4150  m_Selector.Reset(&value);
4151 }
4152 
4154 {
4155  if ( !m_Selector ) {
4156  ResetSelector();
4157  }
4158  m_Selector->SetSelector();
4159  return (*m_Selector);
4160 }
4161 
4163 {
4164  ResetSelector();
4165 }
4166 
4168 {
4169  SET_INTERNAL_NAME("ContExp.nary-linalg", "mmlclass");
4170  SET_CLASS_MODULE("pubmed_mathml3");
4171  ADD_NAMED_REF_MEMBER("selector", m_Selector, CSelector)->SetNsQualified(true);
4172  info->RandomOrder();
4173  info->CodeVersion(22400);
4174  info->DataSpec(ncbi::EDataSpec::eXSD);
4175 }
4177 
4178 // constructor
4180 {
4181  memset(m_set_State,0,sizeof(m_set_State));
4182  if ( !IsAllocatedInPool() ) {
4183  ResetSelector();
4184  }
4185 }
4186 
4187 // destructor
4189 {
4190 }
4191 
4192 
4194 {
4195  if ( m_choice != e_not_set )
4196  ResetSelection();
4197 }
4198 
4200 {
4201  switch ( m_choice ) {
4202  case e_Vectorproduct:
4203  case e_Scalarproduct:
4204  case e_Outerproduct:
4205  m_object->RemoveReference();
4206  break;
4207  default:
4208  break;
4209  }
4210  m_choice = e_not_set;
4211 }
4212 
4213 void CContExp_Base::C_Binary_linalg_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
4214 {
4215  switch ( index ) {
4216  case e_Vectorproduct:
4217  (m_object = new(pool) ncbi::objects::CVectorproduct())->AddReference();
4218  break;
4219  case e_Scalarproduct:
4220  (m_object = new(pool) ncbi::objects::CScalarproduct())->AddReference();
4221  break;
4222  case e_Outerproduct:
4223  (m_object = new(pool) ncbi::objects::COuterproduct())->AddReference();
4224  break;
4225  default:
4226  break;
4227  }
4228  m_choice = index;
4229 }
4230 
4232  "not set",
4233  "vectorproduct",
4234  "scalarproduct",
4235  "outerproduct"
4236 };
4237 
4239 {
4240  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4241 }
4242 
4244 {
4245  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4246 }
4247 
4249 {
4250  CheckSelected(e_Vectorproduct);
4251  return *static_cast<const TVectorproduct*>(m_object);
4252 }
4253 
4255 {
4256  Select(e_Vectorproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4258  value.SetVectorproduct();
4259  return value;
4260 }
4261 
4263 {
4264  CheckSelected(e_Scalarproduct);
4265  return *static_cast<const TScalarproduct*>(m_object);
4266 }
4267 
4269 {
4270  Select(e_Scalarproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4272  value.SetScalarproduct();
4273  return value;
4274 }
4275 
4277 {
4278  CheckSelected(e_Outerproduct);
4279  return *static_cast<const TOuterproduct*>(m_object);
4280 }
4281 
4283 {
4284  Select(e_Outerproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4286  value.SetOuterproduct();
4287  return value;
4288 }
4289 
4290 // helper methods
4291 
4292 // type info
4294 {
4295  SET_INTERNAL_NAME("ContExp.binary-linalg", "mmlclass");
4296  SET_CHOICE_MODULE("pubmed_mathml3");
4297  ADD_NAMED_REF_CHOICE_VARIANT("vectorproduct", m_object, CVectorproduct)->SetNsQualified(true);
4298  ADD_NAMED_REF_CHOICE_VARIANT("scalarproduct", m_object, CScalarproduct)->SetNsQualified(true);
4299  ADD_NAMED_REF_CHOICE_VARIANT("outerproduct", m_object, COuterproduct)->SetNsQualified(true);
4300  info->CodeVersion(22400);
4301  info->DataSpec(ncbi::EDataSpec::eXSD);
4302 }
4304 
4305 // constructor
4307  : m_choice(e_not_set)
4308 {
4309 }
4310 
4311 // destructor
4313 {
4314  Reset();
4315 }
4316 
4317 
4319 {
4320  if ( m_choice != e_not_set )
4321  ResetSelection();
4322 }
4323 
4325 {
4326  switch ( m_choice ) {
4327  case e_Integers:
4328  case e_Reals:
4329  case e_Rationals:
4330  case e_Naturalnumbers:
4331  case e_Complexes:
4332  case e_Primes:
4333  case e_Emptyset:
4334  m_object->RemoveReference();
4335  break;
4336  default:
4337  break;
4338  }
4339  m_choice = e_not_set;
4340 }
4341 
4342 void CContExp_Base::C_Constant_set_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
4343 {
4344  switch ( index ) {
4345  case e_Integers:
4346  (m_object = new(pool) ncbi::objects::CIntegers())->AddReference();
4347  break;
4348  case e_Reals:
4349  (m_object = new(pool) ncbi::objects::CReals())->AddReference();
4350  break;
4351  case e_Rationals:
4352  (m_object = new(pool) ncbi::objects::CRationals())->AddReference();
4353  break;
4354  case e_Naturalnumbers:
4355  (m_object = new(pool) ncbi::objects::CNaturalnumbers())->AddReference();
4356  break;
4357  case e_Complexes:
4358  (m_object = new(pool) ncbi::objects::CComplexes())->AddReference();
4359  break;
4360  case e_Primes:
4361  (m_object = new(pool) ncbi::objects::CPrimes())->AddReference();
4362  break;
4363  case e_Emptyset:
4364  (m_object = new(pool) ncbi::objects::CEmptyset())->AddReference();
4365  break;
4366  default:
4367  break;
4368  }
4369  m_choice = index;
4370 }
4371 
4373  "not set",
4374  "integers",
4375  "reals",
4376  "rationals",
4377  "naturalnumbers",
4378  "complexes",
4379  "primes",
4380  "emptyset"
4381 };
4382 
4384 {
4385  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4386 }
4387 
4389 {
4390  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4391 }
4392 
4394 {
4395  CheckSelected(e_Integers);
4396  return *static_cast<const TIntegers*>(m_object);
4397 }
4398 
4400 {
4403  value.SetIntegers();
4404  return value;
4405 }
4406 
4408 {
4409  CheckSelected(e_Reals);
4410  return *static_cast<const TReals*>(m_object);
4411 }
4412 
4414 {
4417  value.SetReals();
4418  return value;
4419 }
4420 
4422 {
4423  CheckSelected(e_Rationals);
4424  return *static_cast<const TRationals*>(m_object);
4425 }
4426 
4428 {
4431  value.SetRationals();
4432  return value;
4433 }
4434 
4436 {
4437  CheckSelected(e_Naturalnumbers);
4438  return *static_cast<const TNaturalnumbers*>(m_object);
4439 }
4440 
4442 {
4443  Select(e_Naturalnumbers, NCBI_NS_NCBI::eDoNotResetVariant);
4445  value.SetNaturalnumbers();
4446  return value;
4447 }
4448 
4450 {
4451  CheckSelected(e_Complexes);
4452  return *static_cast<const TComplexes*>(m_object);
4453 }
4454 
4456 {
4459  value.SetComplexes();
4460  return value;
4461 }
4462 
4464 {
4465  CheckSelected(e_Primes);
4466  return *static_cast<const TPrimes*>(m_object);
4467 }
4468 
4470 {
4473  value.SetPrimes();
4474  return value;
4475 }
4476 
4478 {
4479  CheckSelected(e_Emptyset);
4480  return *static_cast<const TEmptyset*>(m_object);
4481 }
4482 
4484 {
4487  value.SetEmptyset();
4488  return value;
4489 }
4490 
4491 // helper methods
4492 
4493 // type info
4495 {
4496  SET_INTERNAL_NAME("ContExp.constant-set", "mmlclass");
4497  SET_CHOICE_MODULE("pubmed_mathml3");
4498  ADD_NAMED_REF_CHOICE_VARIANT("integers", m_object, CIntegers)->SetNsQualified(true);
4499  ADD_NAMED_REF_CHOICE_VARIANT("reals", m_object, CReals)->SetNsQualified(true);
4500  ADD_NAMED_REF_CHOICE_VARIANT("rationals", m_object, CRationals)->SetNsQualified(true);
4501  ADD_NAMED_REF_CHOICE_VARIANT("naturalnumbers", m_object, CNaturalnumbers)->SetNsQualified(true);
4502  ADD_NAMED_REF_CHOICE_VARIANT("complexes", m_object, CComplexes)->SetNsQualified(true);
4503  ADD_NAMED_REF_CHOICE_VARIANT("primes", m_object, CPrimes)->SetNsQualified(true);
4504  ADD_NAMED_REF_CHOICE_VARIANT("emptyset", m_object, CEmptyset)->SetNsQualified(true);
4505  info->CodeVersion(22400);
4506  info->DataSpec(ncbi::EDataSpec::eXSD);
4507 }
4509 
4510 // constructor
4512  : m_choice(e_not_set)
4513 {
4514 }
4515 
4516 // destructor
4518 {
4519  Reset();
4520 }
4521 
4522 
4524 {
4525  if ( m_choice != e_not_set )
4526  ResetSelection();
4527 }
4528 
4530 {
4531  switch ( m_choice ) {
4532  case e_Exponentiale:
4533  case e_Imaginaryi:
4534  case e_Notanumber:
4535  case e_True:
4536  case e_False:
4537  case e_Pi:
4538  case e_Eulergamma:
4539  case e_Infinity:
4540  m_object->RemoveReference();
4541  break;
4542  default:
4543  break;
4544  }
4545  m_choice = e_not_set;
4546 }
4547 
4548 void CContExp_Base::C_Constant_arith_mmlclass::DoSelect(E_Choice index, NCBI_NS_NCBI::CObjectMemoryPool* pool)
4549 {
4550  switch ( index ) {
4551  case e_Exponentiale:
4552  (m_object = new(pool) ncbi::objects::CExponentiale())->AddReference();
4553  break;
4554  case e_Imaginaryi:
4555  (m_object = new(pool) ncbi::objects::CImaginaryi())->AddReference();
4556  break;
4557  case e_Notanumber:
4558  (m_object = new(pool) ncbi::objects::CNotanumber())->AddReference();
4559  break;
4560  case e_True:
4561  (m_object = new(pool) ncbi::objects::CTrue())->AddReference();
4562  break;
4563  case e_False:
4564  (m_object = new(pool) ncbi::objects::CFalse())->AddReference();
4565  break;
4566  case e_Pi:
4567  (m_object = new(pool) ncbi::objects::CPi())->AddReference();
4568  break;
4569  case e_Eulergamma:
4570  (m_object = new(pool) ncbi::objects::CEulergamma())->AddReference();
4571  break;
4572  case e_Infinity:
4573  (m_object = new(pool) ncbi::objects::CInfinity())->AddReference();
4574  break;
4575  default:
4576  break;
4577  }
4578  m_choice = index;
4579 }
4580 
4582  "not set",
4583  "exponentiale",
4584  "imaginaryi",
4585  "notanumber",
4586  "true",
4587  "false",
4588  "pi",
4589  "eulergamma",
4590  "infinity"
4591 };
4592 
4594 {
4595  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4596 }
4597 
4599 {
4600  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4601 }
4602 
4604 {
4605  CheckSelected(e_Exponentiale);
4606  return *static_cast<const TExponentiale*>(m_object);
4607 }
4608 
4610 {
4611  Select(e_Exponentiale, NCBI_NS_NCBI::eDoNotResetVariant);
4613  value.SetExponentiale();
4614  return value;
4615 }
4616 
4618 {
4619  CheckSelected(e_Imaginaryi);
4620  return *static_cast<const TImaginaryi*>(m_object);
4621 }
4622 
4624 {
4627  value.SetImaginaryi();
4628  return value;
4629 }
4630 
4632 {
4633  CheckSelected(e_Notanumber);
4634  return *static_cast<const TNotanumber*>(m_object);
4635 }
4636 
4638 {
4641  value.SetNotanumber();
4642  return value;
4643 }
4644 
4646 {
4647  CheckSelected(e_True);
4648  return *static_cast<const TTrue*>(m_object);
4649 }
4650 
4652 {
4655  value.SetTrue();
4656  return value;
4657 }
4658 
4660 {
4661  CheckSelected(e_False);
4662  return *static_cast<const TFalse*>(m_object);
4663 }
4664 
4666 {
4669  value.SetFalse();
4670  return value;
4671 }
4672 
4674 {
4675  CheckSelected(e_Pi);
4676  return *static_cast<const TPi*>(m_object);
4677 }
4678 
4680 {
4683  value.SetPi();
4684  return value;
4685 }
4686 
4688 {
4689  CheckSelected(e_Eulergamma);
4690  return *static_cast<const TEulergamma*>(m_object);
4691 }
4692 
4694 {
4697  value.SetEulergamma();
4698  return value;
4699 }
4700 
4702 {
4703  CheckSelected(e_Infinity);
4704  return *static_cast<const TInfinity*>(m_object);
4705 }
4706 
4708 {
4711  value.SetInfinity();
4712  return value;
4713 }
4714 
4715 // helper methods
4716 
4717 // type info
4719 {
4720  SET_INTERNAL_NAME("ContExp.constant-arith", "mmlclass");
4721  SET_CHOICE_MODULE("pubmed_mathml3");
4722  ADD_NAMED_REF_CHOICE_VARIANT("exponentiale", m_object, CExponentiale)->SetNsQualified(true);
4723  ADD_NAMED_REF_CHOICE_VARIANT("imaginaryi", m_object, CImaginaryi)->SetNsQualified(true);
4724  ADD_NAMED_REF_CHOICE_VARIANT("notanumber", m_object, CNotanumber)->SetNsQualified(true);
4725  ADD_NAMED_REF_CHOICE_VARIANT("true", m_object, CTrue)->SetNsQualified(true);
4726  ADD_NAMED_REF_CHOICE_VARIANT("false", m_object, CFalse)->SetNsQualified(true);
4727  ADD_NAMED_REF_CHOICE_VARIANT("pi", m_object, CPi)->SetNsQualified(true);
4728  ADD_NAMED_REF_CHOICE_VARIANT("eulergamma", m_object, CEulergamma)->SetNsQualified(true);
4729  ADD_NAMED_REF_CHOICE_VARIANT("infinity", m_object, CInfinity)->SetNsQualified(true);
4730  info->CodeVersion(22400);
4731  info->DataSpec(ncbi::EDataSpec::eXSD);
4732 }
4734 
4735 // constructor
4737  : m_choice(e_not_set)
4738 {
4739 }
4740 
4741 // destructor
4743 {
4744  Reset();
4745 }
4746 
4747 
4749 {
4750  if ( m_choice != e_not_set )
4751  ResetSelection();
4752 }
4753 
4755 {
4756  switch ( m_choice ) {
4757  case e_Piecewise:
4758  case e_DeprecatedContExp:
4759  case e_Interval_mmlclass:
4761  case e_Lambda_mmlclass:
4766  case e_Nary_arith_mmlclass:
4770  case e_Quantifier_mmlclass:
4771  case e_Nary_reln_mmlclass:
4773  case e_Int_mmlclass:
4778  case e_Nary_set_mmlclass:
4779  case e_Binary_set_mmlclass:
4781  case e_Unary_set_mmlclass:
4782  case e_Sum_mmlclass:
4783  case e_Product_mmlclass:
4784  case e_Limit_mmlclass:
4786  case e_Nary_stats_mmlclass:
4793  case e_Semantics:
4794  case e_Cn:
4795  case e_Ci:
4796  case e_Csymbol:
4797  case e_Apply:
4798  case e_Bind:
4799  case e_Share:
4800  case e_Cerror:
4801  case e_Cbytes:
4802  case e_Cs:
4803  m_object->RemoveReference();
4804  break;
4805  default:
4806  break;
4807  }
4808  m_choice = e_not_set;
4809 }
4810