NCBI C++ ToolKit
Bind_content_.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
191 
192 BEGIN_objects_SCOPE // namespace ncbi::objects::
193 
194 
195 // generated classes
196 
198 {
199  if ( m_choice != e_not_set )
200  ResetSelection();
201 }
202 
204 {
205  switch ( m_choice ) {
206  case e_Reln:
207  case e_Fn:
208  case e_Declare:
209  m_object->RemoveReference();
210  break;
211  default:
212  break;
213  }
215 }
216 
218 {
219  switch ( index ) {
220  case e_Reln:
221  (m_object = new(pool) ncbi::objects::CReln())->AddReference();
222  break;
223  case e_Fn:
224  (m_object = new(pool) ncbi::objects::CFn())->AddReference();
225  break;
226  case e_Declare:
227  (m_object = new(pool) ncbi::objects::CDeclare())->AddReference();
228  break;
229  default:
230  break;
231  }
232  m_choice = index;
233 }
234 
236  "not set",
237  "reln",
238  "fn",
239  "declare"
240 };
241 
243 {
244  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
245 }
246 
248 {
249  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
250 }
251 
253 {
254  CheckSelected(e_Reln);
255  return *static_cast<const TReln*>(m_object);
256 }
257 
259 {
261  return *static_cast<TReln*>(m_object);
262 }
263 
265 {
266  TReln* ptr = &value;
267  if ( m_choice != e_Reln || m_object != ptr ) {
268  ResetSelection();
269  (m_object = ptr)->AddReference();
270  m_choice = e_Reln;
271  }
272 }
273 
275 {
276  CheckSelected(e_Fn);
277  return *static_cast<const TFn*>(m_object);
278 }
279 
281 {
283  return *static_cast<TFn*>(m_object);
284 }
285 
287 {
288  TFn* ptr = &value;
289  if ( m_choice != e_Fn || m_object != ptr ) {
290  ResetSelection();
291  (m_object = ptr)->AddReference();
292  m_choice = e_Fn;
293  }
294 }
295 
297 {
298  CheckSelected(e_Declare);
299  return *static_cast<const TDeclare*>(m_object);
300 }
301 
303 {
305  return *static_cast<TDeclare*>(m_object);
306 }
307 
309 {
310  TDeclare* ptr = &value;
311  if ( m_choice != e_Declare || m_object != ptr ) {
312  ResetSelection();
313  (m_object = ptr)->AddReference();
314  m_choice = e_Declare;
315  }
316 }
317 
318 // helper methods
319 
320 // type info
322 {
323  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E", "DeprecatedContExp");
324  SET_CHOICE_MODULE("pubmed_mathml3");
325  ADD_NAMED_REF_CHOICE_VARIANT("reln", m_object, CReln)->SetNsQualified(true);
326  ADD_NAMED_REF_CHOICE_VARIANT("fn", m_object, CFn)->SetNsQualified(true);
327  ADD_NAMED_REF_CHOICE_VARIANT("declare", m_object, CDeclare)->SetNsQualified(true);
328  info->CodeVersion(22301);
329  info->DataSpec(ncbi::EDataSpec::eXSD);
330 }
332 
333 // constructor
336 {
337 }
338 
339 // destructor
341 {
342  Reset();
343 }
344 
345 
347 {
348  if ( !m_Interval ) {
349  m_Interval.Reset(new TInterval());
350  return;
351  }
352  (*m_Interval).Reset();
353 }
354 
356 {
357  m_Interval.Reset(&value);
358 }
359 
361 {
362  ResetInterval();
363 }
364 
366 {
367  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.interval", "mmlclass");
368  SET_CLASS_MODULE("pubmed_mathml3");
369  ADD_NAMED_REF_MEMBER("interval", m_Interval, CInterval)->SetNsQualified(true);
370  info->RandomOrder();
371  info->CodeVersion(22301);
372  info->DataSpec(ncbi::EDataSpec::eXSD);
373 }
375 
376 // constructor
378 {
379  memset(m_set_State,0,sizeof(m_set_State));
380  if ( !IsAllocatedInPool() ) {
381  ResetInterval();
382  }
383 }
384 
385 // destructor
387 {
388 }
389 
390 
392 {
393  if ( m_choice != e_not_set )
394  ResetSelection();
395 }
396 
398 {
399  switch ( m_choice ) {
400  case e_Inverse:
401  case e_Ident:
402  case e_Domain:
403  case e_Codomain:
404  case e_Image:
405  case e_Ln:
406  case e_Log:
407  case e_Moment:
408  m_object->RemoveReference();
409  break;
410  default:
411  break;
412  }
414 }
415 
417 {
418  switch ( index ) {
419  case e_Inverse:
420  (m_object = new(pool) ncbi::objects::CInverse())->AddReference();
421  break;
422  case e_Ident:
423  (m_object = new(pool) ncbi::objects::CIdent())->AddReference();
424  break;
425  case e_Domain:
426  (m_object = new(pool) ncbi::objects::CDomain())->AddReference();
427  break;
428  case e_Codomain:
429  (m_object = new(pool) ncbi::objects::CCodomain())->AddReference();
430  break;
431  case e_Image:
432  (m_object = new(pool) ncbi::objects::CImage())->AddReference();
433  break;
434  case e_Ln:
435  (m_object = new(pool) ncbi::objects::CLn())->AddReference();
436  break;
437  case e_Log:
438  (m_object = new(pool) ncbi::objects::CLog())->AddReference();
439  break;
440  case e_Moment:
441  (m_object = new(pool) ncbi::objects::CMoment())->AddReference();
442  break;
443  default:
444  break;
445  }
446  m_choice = index;
447 }
448 
450  "not set",
451  "inverse",
452  "ident",
453  "domain",
454  "codomain",
455  "image",
456  "ln",
457  "log",
458  "moment"
459 };
460 
462 {
463  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
464 }
465 
467 {
468  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
469 }
470 
472 {
473  CheckSelected(e_Inverse);
474  return *static_cast<const TInverse*>(m_object);
475 }
476 
478 {
481  value.SetInverse();
482  return value;
483 }
484 
486 {
487  CheckSelected(e_Ident);
488  return *static_cast<const TIdent*>(m_object);
489 }
490 
492 {
495  value.SetIdent();
496  return value;
497 }
498 
500 {
501  CheckSelected(e_Domain);
502  return *static_cast<const TDomain*>(m_object);
503 }
504 
506 {
509  value.SetDomain();
510  return value;
511 }
512 
514 {
515  CheckSelected(e_Codomain);
516  return *static_cast<const TCodomain*>(m_object);
517 }
518 
520 {
523  value.SetCodomain();
524  return value;
525 }
526 
528 {
529  CheckSelected(e_Image);
530  return *static_cast<const TImage*>(m_object);
531 }
532 
534 {
537  value.SetImage();
538  return value;
539 }
540 
542 {
543  CheckSelected(e_Ln);
544  return *static_cast<const TLn*>(m_object);
545 }
546 
548 {
551  value.SetLn();
552  return value;
553 }
554 
556 {
557  CheckSelected(e_Log);
558  return *static_cast<const TLog*>(m_object);
559 }
560 
562 {
565  value.SetLog();
566  return value;
567 }
568 
570 {
571  CheckSelected(e_Moment);
572  return *static_cast<const TMoment*>(m_object);
573 }
574 
576 {
579  value.SetMoment();
580  return value;
581 }
582 
583 // helper methods
584 
585 // type info
587 {
588  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-functional", "mmlclass");
589  SET_CHOICE_MODULE("pubmed_mathml3");
590  ADD_NAMED_REF_CHOICE_VARIANT("inverse", m_object, CInverse)->SetNsQualified(true);
591  ADD_NAMED_REF_CHOICE_VARIANT("ident", m_object, CIdent)->SetNsQualified(true);
592  ADD_NAMED_REF_CHOICE_VARIANT("domain", m_object, CDomain)->SetNsQualified(true);
593  ADD_NAMED_REF_CHOICE_VARIANT("codomain", m_object, CCodomain)->SetNsQualified(true);
594  ADD_NAMED_REF_CHOICE_VARIANT("image", m_object, CImage)->SetNsQualified(true);
595  ADD_NAMED_REF_CHOICE_VARIANT("ln", m_object, CLn)->SetNsQualified(true);
596  ADD_NAMED_REF_CHOICE_VARIANT("log", m_object, CLog)->SetNsQualified(true);
597  ADD_NAMED_REF_CHOICE_VARIANT("moment", m_object, CMoment)->SetNsQualified(true);
598  info->CodeVersion(22301);
599  info->DataSpec(ncbi::EDataSpec::eXSD);
600 }
602 
603 // constructor
606 {
607 }
608 
609 // destructor
611 {
612  Reset();
613 }
614 
615 
617 {
618  if ( !m_Lambda ) {
619  m_Lambda.Reset(new TLambda());
620  return;
621  }
622  (*m_Lambda).Reset();
623 }
624 
626 {
627  m_Lambda.Reset(&value);
628 }
629 
631 {
632  ResetLambda();
633 }
634 
636 {
637  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.lambda", "mmlclass");
638  SET_CLASS_MODULE("pubmed_mathml3");
639  ADD_NAMED_REF_MEMBER("lambda", m_Lambda, CLambda)->SetNsQualified(true);
640  info->RandomOrder();
641  info->CodeVersion(22301);
642  info->DataSpec(ncbi::EDataSpec::eXSD);
643 }
645 
646 // constructor
648 {
649  memset(m_set_State,0,sizeof(m_set_State));
650  if ( !IsAllocatedInPool() ) {
651  ResetLambda();
652  }
653 }
654 
655 // destructor
657 {
658 }
659 
660 
662 {
663  return m_Compose ? m_Compose->IsSetCompose() : false;
664 }
665 
667 {
668  if ( !m_Compose ) {
669  m_Compose.Reset(new TCompose());
670  return;
671  }
672  (*m_Compose).Reset();
673 }
674 
676 {
677  m_Compose.Reset(&value);
678 }
679 
681 {
682  if ( !m_Compose ) {
683  ResetCompose();
684  }
685  m_Compose->SetCompose();
686  return (*m_Compose);
687 }
688 
690 {
691  ResetCompose();
692 }
693 
695 {
696  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-functional", "mmlclass");
697  SET_CLASS_MODULE("pubmed_mathml3");
698  ADD_NAMED_REF_MEMBER("compose", m_Compose, CCompose)->SetNsQualified(true);
699  info->RandomOrder();
700  info->CodeVersion(22301);
701  info->DataSpec(ncbi::EDataSpec::eXSD);
702 }
704 
705 // constructor
707 {
708  memset(m_set_State,0,sizeof(m_set_State));
709  if ( !IsAllocatedInPool() ) {
710  ResetCompose();
711  }
712 }
713 
714 // destructor
716 {
717 }
718 
719 
721 {
722  if ( m_choice != e_not_set )
723  ResetSelection();
724 }
725 
727 {
728  switch ( m_choice ) {
729  case e_Quotient:
730  case e_Divide:
731  case e_Minus:
732  case e_Power:
733  case e_Rem:
734  case e_Root:
735  m_object->RemoveReference();
736  break;
737  default:
738  break;
739  }
741 }
742 
744 {
745  switch ( index ) {
746  case e_Quotient:
747  (m_object = new(pool) ncbi::objects::CQuotient())->AddReference();
748  break;
749  case e_Divide:
750  (m_object = new(pool) ncbi::objects::CDivide())->AddReference();
751  break;
752  case e_Minus:
753  (m_object = new(pool) ncbi::objects::CMinus())->AddReference();
754  break;
755  case e_Power:
756  (m_object = new(pool) ncbi::objects::CPower())->AddReference();
757  break;
758  case e_Rem:
759  (m_object = new(pool) ncbi::objects::CRem())->AddReference();
760  break;
761  case e_Root:
762  (m_object = new(pool) ncbi::objects::CRoot())->AddReference();
763  break;
764  default:
765  break;
766  }
767  m_choice = index;
768 }
769 
771  "not set",
772  "quotient",
773  "divide",
774  "minus",
775  "power",
776  "rem",
777  "root"
778 };
779 
781 {
782  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
783 }
784 
786 {
787  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
788 }
789 
791 {
792  CheckSelected(e_Quotient);
793  return *static_cast<const TQuotient*>(m_object);
794 }
795 
797 {
800  value.SetQuotient();
801  return value;
802 }
803 
805 {
806  CheckSelected(e_Divide);
807  return *static_cast<const TDivide*>(m_object);
808 }
809 
811 {
814  value.SetDivide();
815  return value;
816 }
817 
819 {
820  CheckSelected(e_Minus);
821  return *static_cast<const TMinus*>(m_object);
822 }
823 
825 {
828  value.SetMinus();
829  return value;
830 }
831 
833 {
834  CheckSelected(e_Power);
835  return *static_cast<const TPower*>(m_object);
836 }
837 
839 {
842  value.SetPower();
843  return value;
844 }
845 
847 {
848  CheckSelected(e_Rem);
849  return *static_cast<const TRem*>(m_object);
850 }
851 
853 {
856  value.SetRem();
857  return value;
858 }
859 
861 {
862  CheckSelected(e_Root);
863  return *static_cast<const TRoot*>(m_object);
864 }
865 
867 {
870  value.SetRoot();
871  return value;
872 }
873 
874 // helper methods
875 
876 // type info
878 {
879  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.binary-arith", "mmlclass");
880  SET_CHOICE_MODULE("pubmed_mathml3");
881  ADD_NAMED_REF_CHOICE_VARIANT("quotient", m_object, CQuotient)->SetNsQualified(true);
882  ADD_NAMED_REF_CHOICE_VARIANT("divide", m_object, CDivide)->SetNsQualified(true);
883  ADD_NAMED_REF_CHOICE_VARIANT("minus", m_object, CMinus)->SetNsQualified(true);
884  ADD_NAMED_REF_CHOICE_VARIANT("power", m_object, CPower)->SetNsQualified(true);
885  ADD_NAMED_REF_CHOICE_VARIANT("rem", m_object, CRem)->SetNsQualified(true);
886  ADD_NAMED_REF_CHOICE_VARIANT("root", m_object, CRoot)->SetNsQualified(true);
887  info->CodeVersion(22301);
888  info->DataSpec(ncbi::EDataSpec::eXSD);
889 }
891 
892 // constructor
895 {
896 }
897 
898 // destructor
900 {
901  Reset();
902 }
903 
904 
906 {
907  if ( m_choice != e_not_set )
908  ResetSelection();
909 }
910 
912 {
913  switch ( m_choice ) {
914  case e_Factorial:
915  case e_Abs:
916  case e_Conjugate:
917  case e_Arg:
918  case e_Real:
919  case e_Imaginary:
920  case e_Floor:
921  case e_Ceiling:
922  case e_Exp:
923  m_object->RemoveReference();
924  break;
925  default:
926  break;
927  }
929 }
930 
932 {
933  switch ( index ) {
934  case e_Factorial:
935  (m_object = new(pool) ncbi::objects::CFactorial())->AddReference();
936  break;
937  case e_Abs:
938  (m_object = new(pool) ncbi::objects::CAbs())->AddReference();
939  break;
940  case e_Conjugate:
941  (m_object = new(pool) ncbi::objects::CConjugate())->AddReference();
942  break;
943  case e_Arg:
944  (m_object = new(pool) ncbi::objects::CArg())->AddReference();
945  break;
946  case e_Real:
947  (m_object = new(pool) ncbi::objects::CReal())->AddReference();
948  break;
949  case e_Imaginary:
950  (m_object = new(pool) ncbi::objects::CImaginary())->AddReference();
951  break;
952  case e_Floor:
953  (m_object = new(pool) ncbi::objects::CFloor())->AddReference();
954  break;
955  case e_Ceiling:
956  (m_object = new(pool) ncbi::objects::CCeiling())->AddReference();
957  break;
958  case e_Exp:
959  (m_object = new(pool) ncbi::objects::CExp())->AddReference();
960  break;
961  default:
962  break;
963  }
964  m_choice = index;
965 }
966 
968  "not set",
969  "factorial",
970  "abs",
971  "conjugate",
972  "arg",
973  "real",
974  "imaginary",
975  "floor",
976  "ceiling",
977  "exp"
978 };
979 
981 {
982  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
983 }
984 
986 {
987  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
988 }
989 
991 {
992  CheckSelected(e_Factorial);
993  return *static_cast<const TFactorial*>(m_object);
994 }
995 
997 {
1000  value.SetFactorial();
1001  return value;
1002 }
1003 
1005 {
1006  CheckSelected(e_Abs);
1007  return *static_cast<const TAbs*>(m_object);
1008 }
1009 
1011 {
1014  value.SetAbs();
1015  return value;
1016 }
1017 
1019 {
1020  CheckSelected(e_Conjugate);
1021  return *static_cast<const TConjugate*>(m_object);
1022 }
1023 
1025 {
1028  value.SetConjugate();
1029  return value;
1030 }
1031 
1033 {
1034  CheckSelected(e_Arg);
1035  return *static_cast<const TArg*>(m_object);
1036 }
1037 
1039 {
1042  value.SetArg();
1043  return value;
1044 }
1045 
1047 {
1048  CheckSelected(e_Real);
1049  return *static_cast<const TReal*>(m_object);
1050 }
1051 
1053 {
1056  value.SetReal();
1057  return value;
1058 }
1059 
1061 {
1062  CheckSelected(e_Imaginary);
1063  return *static_cast<const TImaginary*>(m_object);
1064 }
1065 
1067 {
1070  value.SetImaginary();
1071  return value;
1072 }
1073 
1075 {
1076  CheckSelected(e_Floor);
1077  return *static_cast<const TFloor*>(m_object);
1078 }
1079 
1081 {
1084  value.SetFloor();
1085  return value;
1086 }
1087 
1089 {
1090  CheckSelected(e_Ceiling);
1091  return *static_cast<const TCeiling*>(m_object);
1092 }
1093 
1095 {
1098  value.SetCeiling();
1099  return value;
1100 }
1101 
1103 {
1104  CheckSelected(e_Exp);
1105  return *static_cast<const TExp*>(m_object);
1106 }
1107 
1109 {
1112  value.SetExp();
1113  return value;
1114 }
1115 
1116 // helper methods
1117 
1118 // type info
1120 {
1121  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-arith", "mmlclass");
1122  SET_CHOICE_MODULE("pubmed_mathml3");
1123  ADD_NAMED_REF_CHOICE_VARIANT("factorial", m_object, CFactorial)->SetNsQualified(true);
1124  ADD_NAMED_REF_CHOICE_VARIANT("abs", m_object, CAbs)->SetNsQualified(true);
1125  ADD_NAMED_REF_CHOICE_VARIANT("conjugate", m_object, CConjugate)->SetNsQualified(true);
1126  ADD_NAMED_REF_CHOICE_VARIANT("arg", m_object, CArg)->SetNsQualified(true);
1127  ADD_NAMED_REF_CHOICE_VARIANT("real", m_object, CReal)->SetNsQualified(true);
1128  ADD_NAMED_REF_CHOICE_VARIANT("imaginary", m_object, CImaginary)->SetNsQualified(true);
1129  ADD_NAMED_REF_CHOICE_VARIANT("floor", m_object, CFloor)->SetNsQualified(true);
1130  ADD_NAMED_REF_CHOICE_VARIANT("ceiling", m_object, CCeiling)->SetNsQualified(true);
1131  ADD_NAMED_REF_CHOICE_VARIANT("exp", m_object, CExp)->SetNsQualified(true);
1132  info->CodeVersion(22301);
1133  info->DataSpec(ncbi::EDataSpec::eXSD);
1134 }
1136 
1137 // constructor
1139  : m_choice(e_not_set)
1140 {
1141 }
1142 
1143 // destructor
1145 {
1146  Reset();
1147 }
1148 
1149 
1151 {
1152  if ( m_choice != e_not_set )
1153  ResetSelection();
1154 }
1155 
1157 {
1158  switch ( m_choice ) {
1159  case e_Max:
1160  case e_Min:
1161  m_object->RemoveReference();
1162  break;
1163  default:
1164  break;
1165  }
1166  m_choice = e_not_set;
1167 }
1168 
1170 {
1171  switch ( index ) {
1172  case e_Max:
1173  (m_object = new(pool) ncbi::objects::CMax())->AddReference();
1174  break;
1175  case e_Min:
1176  (m_object = new(pool) ncbi::objects::CMin())->AddReference();
1177  break;
1178  default:
1179  break;
1180  }
1181  m_choice = index;
1182 }
1183 
1185  "not set",
1186  "max",
1187  "min"
1188 };
1189 
1191 {
1192  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1193 }
1194 
1196 {
1197  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1198 }
1199 
1201 {
1203  return *static_cast<const TMax*>(m_object);
1204 }
1205 
1207 {
1210  value.SetMax();
1211  return value;
1212 }
1213 
1215 {
1216  CheckSelected(e_Min);
1217  return *static_cast<const TMin*>(m_object);
1218 }
1219 
1221 {
1224  value.SetMin();
1225  return value;
1226 }
1227 
1228 // helper methods
1229 
1230 // type info
1232 {
1233  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-minmax", "mmlclass");
1234  SET_CHOICE_MODULE("pubmed_mathml3");
1235  ADD_NAMED_REF_CHOICE_VARIANT("max", m_object, CMax)->SetNsQualified(true);
1236  ADD_NAMED_REF_CHOICE_VARIANT("min", m_object, CMin)->SetNsQualified(true);
1237  info->CodeVersion(22301);
1238  info->DataSpec(ncbi::EDataSpec::eXSD);
1239 }
1241 
1242 // constructor
1244  : m_choice(e_not_set)
1245 {
1246 }
1247 
1248 // destructor
1250 {
1251  Reset();
1252 }
1253 
1254 
1256 {
1257  if ( m_choice != e_not_set )
1258  ResetSelection();
1259 }
1260 
1262 {
1263  switch ( m_choice ) {
1264  case e_Plus:
1265  case e_Times:
1266  case e_Gcd:
1267  case e_Lcm:
1268  m_object->RemoveReference();
1269  break;
1270  default:
1271  break;
1272  }
1273  m_choice = e_not_set;
1274 }
1275 
1277 {
1278  switch ( index ) {
1279  case e_Plus:
1280  (m_object = new(pool) ncbi::objects::CPlus())->AddReference();
1281  break;
1282  case e_Times:
1283  (m_object = new(pool) ncbi::objects::CTimes())->AddReference();
1284  break;
1285  case e_Gcd:
1286  (m_object = new(pool) ncbi::objects::CGcd())->AddReference();
1287  break;
1288  case e_Lcm:
1289  (m_object = new(pool) ncbi::objects::CLcm())->AddReference();
1290  break;
1291  default:
1292  break;
1293  }
1294  m_choice = index;
1295 }
1296 
1298  "not set",
1299  "plus",
1300  "times",
1301  "gcd",
1302  "lcm"
1303 };
1304 
1306 {
1307  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1308 }
1309 
1311 {
1312  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1313 }
1314 
1316 {
1317  CheckSelected(e_Plus);
1318  return *static_cast<const TPlus*>(m_object);
1319 }
1320 
1322 {
1325  value.SetPlus();
1326  return value;
1327 }
1328 
1330 {
1331  CheckSelected(e_Times);
1332  return *static_cast<const TTimes*>(m_object);
1333 }
1334 
1336 {
1339  value.SetTimes();
1340  return value;
1341 }
1342 
1344 {
1345  CheckSelected(e_Gcd);
1346  return *static_cast<const TGcd*>(m_object);
1347 }
1348 
1350 {
1353  value.SetGcd();
1354  return value;
1355 }
1356 
1358 {
1359  CheckSelected(e_Lcm);
1360  return *static_cast<const TLcm*>(m_object);
1361 }
1362 
1364 {
1367  value.SetLcm();
1368  return value;
1369 }
1370 
1371 // helper methods
1372 
1373 // type info
1375 {
1376  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-arith", "mmlclass");
1377  SET_CHOICE_MODULE("pubmed_mathml3");
1378  ADD_NAMED_REF_CHOICE_VARIANT("plus", m_object, CPlus)->SetNsQualified(true);
1379  ADD_NAMED_REF_CHOICE_VARIANT("times", m_object, CTimes)->SetNsQualified(true);
1380  ADD_NAMED_REF_CHOICE_VARIANT("gcd", m_object, CGcd)->SetNsQualified(true);
1381  ADD_NAMED_REF_CHOICE_VARIANT("lcm", m_object, CLcm)->SetNsQualified(true);
1382  info->CodeVersion(22301);
1383  info->DataSpec(ncbi::EDataSpec::eXSD);
1384 }
1386 
1387 // constructor
1389  : m_choice(e_not_set)
1390 {
1391 }
1392 
1393 // destructor
1395 {
1396  Reset();
1397 }
1398 
1399 
1401 {
1402  if ( m_choice != e_not_set )
1403  ResetSelection();
1404 }
1405 
1407 {
1408  switch ( m_choice ) {
1409  case e_And:
1410  case e_Or:
1411  case e_Xor:
1412  m_object->RemoveReference();
1413  break;
1414  default:
1415  break;
1416  }
1417  m_choice = e_not_set;
1418 }
1419 
1421 {
1422  switch ( index ) {
1423  case e_And:
1424  (m_object = new(pool) ncbi::objects::CAnd())->AddReference();
1425  break;
1426  case e_Or:
1427  (m_object = new(pool) ncbi::objects::COr())->AddReference();
1428  break;
1429  case e_Xor:
1430  (m_object = new(pool) ncbi::objects::CXor())->AddReference();
1431  break;
1432  default:
1433  break;
1434  }
1435  m_choice = index;
1436 }
1437 
1439  "not set",
1440  "and",
1441  "or",
1442  "xor"
1443 };
1444 
1446 {
1447  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1448 }
1449 
1451 {
1452  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1453 }
1454 
1456 {
1457  CheckSelected(e_And);
1458  return *static_cast<const TAnd*>(m_object);
1459 }
1460 
1462 {
1465  value.SetAnd();
1466  return value;
1467 }
1468 
1470 {
1471  CheckSelected(e_Or);
1472  return *static_cast<const TOr*>(m_object);
1473 }
1474 
1476 {
1479  value.SetOr();
1480  return value;
1481 }
1482 
1484 {
1485  CheckSelected(e_Xor);
1486  return *static_cast<const TXor*>(m_object);
1487 }
1488 
1490 {
1493  value.SetXor();
1494  return value;
1495 }
1496 
1497 // helper methods
1498 
1499 // type info
1501 {
1502  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-logical", "mmlclass");
1503  SET_CHOICE_MODULE("pubmed_mathml3");
1504  ADD_NAMED_REF_CHOICE_VARIANT("and", m_object, CAnd)->SetNsQualified(true);
1505  ADD_NAMED_REF_CHOICE_VARIANT("or", m_object, COr)->SetNsQualified(true);
1506  ADD_NAMED_REF_CHOICE_VARIANT("xor", m_object, CXor)->SetNsQualified(true);
1507  info->CodeVersion(22301);
1508  info->DataSpec(ncbi::EDataSpec::eXSD);
1509 }
1511 
1512 // constructor
1514  : m_choice(e_not_set)
1515 {
1516 }
1517 
1518 // destructor
1520 {
1521  Reset();
1522 }
1523 
1524 
1526 {
1527  return m_Not ? m_Not->IsSetNot() : false;
1528 }
1529 
1531 {
1532  if ( !m_Not ) {
1533  m_Not.Reset(new TNot());
1534  return;
1535  }
1536  (*m_Not).Reset();
1537 }
1538 
1540 {
1541  m_Not.Reset(&value);
1542 }
1543 
1545 {
1546  if ( !m_Not ) {
1547  ResetNot();
1548  }
1549  m_Not->SetNot();
1550  return (*m_Not);
1551 }
1552 
1554 {
1555  ResetNot();
1556 }
1557 
1559 {
1560  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-logical", "mmlclass");
1561  SET_CLASS_MODULE("pubmed_mathml3");
1562  ADD_NAMED_REF_MEMBER("not", m_Not, CNot)->SetNsQualified(true);
1563  info->RandomOrder();
1564  info->CodeVersion(22301);
1565  info->DataSpec(ncbi::EDataSpec::eXSD);
1566 }
1568 
1569 // constructor
1571 {
1572  memset(m_set_State,0,sizeof(m_set_State));
1573  if ( !IsAllocatedInPool() ) {
1574  ResetNot();
1575  }
1576 }
1577 
1578 // destructor
1580 {
1581 }
1582 
1583 
1585 {
1586  if ( m_choice != e_not_set )
1587  ResetSelection();
1588 }
1589 
1591 {
1592  switch ( m_choice ) {
1593  case e_Implies:
1594  case e_Equivalent:
1595  m_object->RemoveReference();
1596  break;
1597  default:
1598  break;
1599  }
1600  m_choice = e_not_set;
1601 }
1602 
1604 {
1605  switch ( index ) {
1606  case e_Implies:
1607  (m_object = new(pool) ncbi::objects::CImplies())->AddReference();
1608  break;
1609  case e_Equivalent:
1610  (m_object = new(pool) ncbi::objects::CEquivalent())->AddReference();
1611  break;
1612  default:
1613  break;
1614  }
1615  m_choice = index;
1616 }
1617 
1619  "not set",
1620  "implies",
1621  "equivalent"
1622 };
1623 
1625 {
1626  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1627 }
1628 
1630 {
1631  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1632 }
1633 
1635 {
1636  CheckSelected(e_Implies);
1637  return *static_cast<const TImplies*>(m_object);
1638 }
1639 
1641 {
1644  value.SetImplies();
1645  return value;
1646 }
1647 
1649 {
1650  CheckSelected(e_Equivalent);
1651  return *static_cast<const TEquivalent*>(m_object);
1652 }
1653 
1655 {
1658  value.SetEquivalent();
1659  return value;
1660 }
1661 
1662 // helper methods
1663 
1664 // type info
1666 {
1667  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.binary-logical", "mmlclass");
1668  SET_CHOICE_MODULE("pubmed_mathml3");
1669  ADD_NAMED_REF_CHOICE_VARIANT("implies", m_object, CImplies)->SetNsQualified(true);
1670  ADD_NAMED_REF_CHOICE_VARIANT("equivalent", m_object, CEquivalent)->SetNsQualified(true);
1671  info->CodeVersion(22301);
1672  info->DataSpec(ncbi::EDataSpec::eXSD);
1673 }
1675 
1676 // constructor
1678  : m_choice(e_not_set)
1679 {
1680 }
1681 
1682 // destructor
1684 {
1685  Reset();
1686 }
1687 
1688 
1690 {
1691  if ( m_choice != e_not_set )
1692  ResetSelection();
1693 }
1694 
1696 {
1697  switch ( m_choice ) {
1698  case e_Forall:
1699  case e_Exists:
1700  m_object->RemoveReference();
1701  break;
1702  default:
1703  break;
1704  }
1705  m_choice = e_not_set;
1706 }
1707 
1709 {
1710  switch ( index ) {
1711  case e_Forall:
1712  (m_object = new(pool) ncbi::objects::CForall())->AddReference();
1713  break;
1714  case e_Exists:
1715  (m_object = new(pool) ncbi::objects::CExists())->AddReference();
1716  break;
1717  default:
1718  break;
1719  }
1720  m_choice = index;
1721 }
1722 
1724  "not set",
1725  "forall",
1726  "exists"
1727 };
1728 
1730 {
1731  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1732 }
1733 
1735 {
1736  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1737 }
1738 
1740 {
1741  CheckSelected(e_Forall);
1742  return *static_cast<const TForall*>(m_object);
1743 }
1744 
1746 {
1749  value.SetForall();
1750  return value;
1751 }
1752 
1754 {
1755  CheckSelected(e_Exists);
1756  return *static_cast<const TExists*>(m_object);
1757 }
1758 
1760 {
1763  value.SetExists();
1764  return value;
1765 }
1766 
1767 // helper methods
1768 
1769 // type info
1771 {
1772  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.quantifier", "mmlclass");
1773  SET_CHOICE_MODULE("pubmed_mathml3");
1774  ADD_NAMED_REF_CHOICE_VARIANT("forall", m_object, CForall)->SetNsQualified(true);
1775  ADD_NAMED_REF_CHOICE_VARIANT("exists", m_object, CExists)->SetNsQualified(true);
1776  info->CodeVersion(22301);
1777  info->DataSpec(ncbi::EDataSpec::eXSD);
1778 }
1780 
1781 // constructor
1783  : m_choice(e_not_set)
1784 {
1785 }
1786 
1787 // destructor
1789 {
1790  Reset();
1791 }
1792 
1793 
1795 {
1796  if ( m_choice != e_not_set )
1797  ResetSelection();
1798 }
1799 
1801 {
1802  switch ( m_choice ) {
1803  case e_Eq:
1804  case e_Gt:
1805  case e_Lt:
1806  case e_Geq:
1807  case e_Leq:
1808  m_object->RemoveReference();
1809  break;
1810  default:
1811  break;
1812  }
1813  m_choice = e_not_set;
1814 }
1815 
1817 {
1818  switch ( index ) {
1819  case e_Eq:
1820  (m_object = new(pool) ncbi::objects::CEq())->AddReference();
1821  break;
1822  case e_Gt:
1823  (m_object = new(pool) ncbi::objects::CGt())->AddReference();
1824  break;
1825  case e_Lt:
1826  (m_object = new(pool) ncbi::objects::CLt())->AddReference();
1827  break;
1828  case e_Geq:
1829  (m_object = new(pool) ncbi::objects::CGeq())->AddReference();
1830  break;
1831  case e_Leq:
1832  (m_object = new(pool) ncbi::objects::CLeq())->AddReference();
1833  break;
1834  default:
1835  break;
1836  }
1837  m_choice = index;
1838 }
1839 
1841  "not set",
1842  "eq",
1843  "gt",
1844  "lt",
1845  "geq",
1846  "leq"
1847 };
1848 
1850 {
1851  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1852 }
1853 
1855 {
1856  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
1857 }
1858 
1860 {
1861  CheckSelected(e_Eq);
1862  return *static_cast<const TEq*>(m_object);
1863 }
1864 
1866 {
1869  value.SetEq();
1870  return value;
1871 }
1872 
1874 {
1875  CheckSelected(e_Gt);
1876  return *static_cast<const TGt*>(m_object);
1877 }
1878 
1880 {
1883  value.SetGt();
1884  return value;
1885 }
1886 
1888 {
1889  CheckSelected(e_Lt);
1890  return *static_cast<const TLt*>(m_object);
1891 }
1892 
1894 {
1897  value.SetLt();
1898  return value;
1899 }
1900 
1902 {
1903  CheckSelected(e_Geq);
1904  return *static_cast<const TGeq*>(m_object);
1905 }
1906 
1908 {
1911  value.SetGeq();
1912  return value;
1913 }
1914 
1916 {
1917  CheckSelected(e_Leq);
1918  return *static_cast<const TLeq*>(m_object);
1919 }
1920 
1922 {
1925  value.SetLeq();
1926  return value;
1927 }
1928 
1929 // helper methods
1930 
1931 // type info
1933 {
1934  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-reln", "mmlclass");
1935  SET_CHOICE_MODULE("pubmed_mathml3");
1936  ADD_NAMED_REF_CHOICE_VARIANT("eq", m_object, CEq)->SetNsQualified(true);
1937  ADD_NAMED_REF_CHOICE_VARIANT("gt", m_object, CGt)->SetNsQualified(true);
1938  ADD_NAMED_REF_CHOICE_VARIANT("lt", m_object, CLt)->SetNsQualified(true);
1939  ADD_NAMED_REF_CHOICE_VARIANT("geq", m_object, CGeq)->SetNsQualified(true);
1940  ADD_NAMED_REF_CHOICE_VARIANT("leq", m_object, CLeq)->SetNsQualified(true);
1941  info->CodeVersion(22301);
1942  info->DataSpec(ncbi::EDataSpec::eXSD);
1943 }
1945 
1946 // constructor
1948  : m_choice(e_not_set)
1949 {
1950 }
1951 
1952 // destructor
1954 {
1955  Reset();
1956 }
1957 
1958 
1960 {
1961  if ( m_choice != e_not_set )
1962  ResetSelection();
1963 }
1964 
1966 {
1967  switch ( m_choice ) {
1968  case e_Neq:
1969  case e_Approx:
1970  case e_Factorof:
1971  case e_Tendsto:
1972  m_object->RemoveReference();
1973  break;
1974  default:
1975  break;
1976  }
1977  m_choice = e_not_set;
1978 }
1979 
1981 {
1982  switch ( index ) {
1983  case e_Neq:
1984  (m_object = new(pool) ncbi::objects::CNeq())->AddReference();
1985  break;
1986  case e_Approx:
1987  (m_object = new(pool) ncbi::objects::CApprox())->AddReference();
1988  break;
1989  case e_Factorof:
1990  (m_object = new(pool) ncbi::objects::CFactorof())->AddReference();
1991  break;
1992  case e_Tendsto:
1993  (m_object = new(pool) ncbi::objects::CTendsto())->AddReference();
1994  break;
1995  default:
1996  break;
1997  }
1998  m_choice = index;
1999 }
2000 
2002  "not set",
2003  "neq",
2004  "approx",
2005  "factorof",
2006  "tendsto"
2007 };
2008 
2010 {
2011  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2012 }
2013 
2015 {
2016  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2017 }
2018 
2020 {
2021  CheckSelected(e_Neq);
2022  return *static_cast<const TNeq*>(m_object);
2023 }
2024 
2026 {
2029  value.SetNeq();
2030  return value;
2031 }
2032 
2034 {
2035  CheckSelected(e_Approx);
2036  return *static_cast<const TApprox*>(m_object);
2037 }
2038 
2040 {
2043  value.SetApprox();
2044  return value;
2045 }
2046 
2048 {
2049  CheckSelected(e_Factorof);
2050  return *static_cast<const TFactorof*>(m_object);
2051 }
2052 
2054 {
2057  value.SetFactorof();
2058  return value;
2059 }
2060 
2062 {
2063  CheckSelected(e_Tendsto);
2064  return *static_cast<const TTendsto*>(m_object);
2065 }
2066 
2068 {
2071  value.SetTendsto();
2072  return value;
2073 }
2074 
2075 // helper methods
2076 
2077 // type info
2079 {
2080  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.binary-reln", "mmlclass");
2081  SET_CHOICE_MODULE("pubmed_mathml3");
2082  ADD_NAMED_REF_CHOICE_VARIANT("neq", m_object, CNeq)->SetNsQualified(true);
2083  ADD_NAMED_REF_CHOICE_VARIANT("approx", m_object, CApprox)->SetNsQualified(true);
2084  ADD_NAMED_REF_CHOICE_VARIANT("factorof", m_object, CFactorof)->SetNsQualified(true);
2085  ADD_NAMED_REF_CHOICE_VARIANT("tendsto", m_object, CTendsto)->SetNsQualified(true);
2086  info->CodeVersion(22301);
2087  info->DataSpec(ncbi::EDataSpec::eXSD);
2088 }
2090 
2091 // constructor
2093  : m_choice(e_not_set)
2094 {
2095 }
2096 
2097 // destructor
2099 {
2100  Reset();
2101 }
2102 
2103 
2105 {
2106  return m_Int ? m_Int->IsSetInt() : false;
2107 }
2108 
2110 {
2111  if ( !m_Int ) {
2112  m_Int.Reset(new TInt());
2113  return;
2114  }
2115  (*m_Int).Reset();
2116 }
2117 
2119 {
2120  m_Int.Reset(&value);
2121 }
2122 
2124 {
2125  if ( !m_Int ) {
2126  ResetInt();
2127  }
2128  m_Int->SetInt();
2129  return (*m_Int);
2130 }
2131 
2133 {
2134  ResetInt();
2135 }
2136 
2138 {
2139  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.int", "mmlclass");
2140  SET_CLASS_MODULE("pubmed_mathml3");
2141  ADD_NAMED_REF_MEMBER("int", m_Int, CInt)->SetNsQualified(true);
2142  info->RandomOrder();
2143  info->CodeVersion(22301);
2144  info->DataSpec(ncbi::EDataSpec::eXSD);
2145 }
2147 
2148 // constructor
2150 {
2151  memset(m_set_State,0,sizeof(m_set_State));
2152  if ( !IsAllocatedInPool() ) {
2153  ResetInt();
2154  }
2155 }
2156 
2157 // destructor
2159 {
2160 }
2161 
2162 
2164 {
2165  return m_Diff ? m_Diff->IsSetDiff() : false;
2166 }
2167 
2169 {
2170  if ( !m_Diff ) {
2171  m_Diff.Reset(new TDiff());
2172  return;
2173  }
2174  (*m_Diff).Reset();
2175 }
2176 
2178 {
2179  m_Diff.Reset(&value);
2180 }
2181 
2183 {
2184  if ( !m_Diff ) {
2185  ResetDiff();
2186  }
2187  m_Diff->SetDiff();
2188  return (*m_Diff);
2189 }
2190 
2192 {
2193  ResetDiff();
2194 }
2195 
2197 {
2198  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.Differential-Operator", "mmlclass");
2199  SET_CLASS_MODULE("pubmed_mathml3");
2200  ADD_NAMED_REF_MEMBER("diff", m_Diff, CDiff)->SetNsQualified(true);
2201  info->RandomOrder();
2202  info->CodeVersion(22301);
2203  info->DataSpec(ncbi::EDataSpec::eXSD);
2204 }
2206 
2207 // constructor
2209 {
2210  memset(m_set_State,0,sizeof(m_set_State));
2211  if ( !IsAllocatedInPool() ) {
2212  ResetDiff();
2213  }
2214 }
2215 
2216 // destructor
2218 {
2219 }
2220 
2221 
2223 {
2224  return m_Partialdiff ? m_Partialdiff->IsSetPartialdiff() : false;
2225 }
2226 
2228 {
2229  if ( !m_Partialdiff ) {
2230  m_Partialdiff.Reset(new TPartialdiff());
2231  return;
2232  }
2233  (*m_Partialdiff).Reset();
2234 }
2235 
2237 {
2238  m_Partialdiff.Reset(&value);
2239 }
2240 
2242 {
2243  if ( !m_Partialdiff ) {
2244  ResetPartialdiff();
2245  }
2246  m_Partialdiff->SetPartialdiff();
2247  return (*m_Partialdiff);
2248 }
2249 
2251 {
2252  ResetPartialdiff();
2253 }
2254 
2256 {
2257  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.partialdiff", "mmlclass");
2258  SET_CLASS_MODULE("pubmed_mathml3");
2259  ADD_NAMED_REF_MEMBER("partialdiff", m_Partialdiff, CPartialdiff)->SetNsQualified(true);
2260  info->RandomOrder();
2261  info->CodeVersion(22301);
2262  info->DataSpec(ncbi::EDataSpec::eXSD);
2263 }
2265 
2266 // constructor
2268 {
2269  memset(m_set_State,0,sizeof(m_set_State));
2270  if ( !IsAllocatedInPool() ) {
2271  ResetPartialdiff();
2272  }
2273 }
2274 
2275 // destructor
2277 {
2278 }
2279 
2280 
2282 {
2283  if ( m_choice != e_not_set )
2284  ResetSelection();
2285 }
2286 
2288 {
2289  switch ( m_choice ) {
2290  case e_Divergence:
2291  case e_Grad:
2292  case e_Curl:
2293  case e_Laplacian:
2294  m_object->RemoveReference();
2295  break;
2296  default:
2297  break;
2298  }
2299  m_choice = e_not_set;
2300 }
2301 
2303 {
2304  switch ( index ) {
2305  case e_Divergence:
2306  (m_object = new(pool) ncbi::objects::CDivergence())->AddReference();
2307  break;
2308  case e_Grad:
2309  (m_object = new(pool) ncbi::objects::CGrad())->AddReference();
2310  break;
2311  case e_Curl:
2312  (m_object = new(pool) ncbi::objects::CCurl())->AddReference();
2313  break;
2314  case e_Laplacian:
2315  (m_object = new(pool) ncbi::objects::CLaplacian())->AddReference();
2316  break;
2317  default:
2318  break;
2319  }
2320  m_choice = index;
2321 }
2322 
2324  "not set",
2325  "divergence",
2326  "grad",
2327  "curl",
2328  "laplacian"
2329 };
2330 
2332 {
2333  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2334 }
2335 
2337 {
2338  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2339 }
2340 
2342 {
2343  CheckSelected(e_Divergence);
2344  return *static_cast<const TDivergence*>(m_object);
2345 }
2346 
2348 {
2351  value.SetDivergence();
2352  return value;
2353 }
2354 
2356 {
2357  CheckSelected(e_Grad);
2358  return *static_cast<const TGrad*>(m_object);
2359 }
2360 
2362 {
2365  value.SetGrad();
2366  return value;
2367 }
2368 
2370 {
2371  CheckSelected(e_Curl);
2372  return *static_cast<const TCurl*>(m_object);
2373 }
2374 
2376 {
2379  value.SetCurl();
2380  return value;
2381 }
2382 
2384 {
2385  CheckSelected(e_Laplacian);
2386  return *static_cast<const TLaplacian*>(m_object);
2387 }
2388 
2390 {
2393  value.SetLaplacian();
2394  return value;
2395 }
2396 
2397 // helper methods
2398 
2399 // type info
2401 {
2402  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-veccalc", "mmlclass");
2403  SET_CHOICE_MODULE("pubmed_mathml3");
2404  ADD_NAMED_REF_CHOICE_VARIANT("divergence", m_object, CDivergence)->SetNsQualified(true);
2405  ADD_NAMED_REF_CHOICE_VARIANT("grad", m_object, CGrad)->SetNsQualified(true);
2406  ADD_NAMED_REF_CHOICE_VARIANT("curl", m_object, CCurl)->SetNsQualified(true);
2407  ADD_NAMED_REF_CHOICE_VARIANT("laplacian", m_object, CLaplacian)->SetNsQualified(true);
2408  info->CodeVersion(22301);
2409  info->DataSpec(ncbi::EDataSpec::eXSD);
2410 }
2412 
2413 // constructor
2415  : m_choice(e_not_set)
2416 {
2417 }
2418 
2419 // destructor
2421 {
2422  Reset();
2423 }
2424 
2425 
2427 {
2428  if ( m_choice != e_not_set )
2429  ResetSelection();
2430 }
2431 
2433 {
2434  switch ( m_choice ) {
2435  case e_Set:
2436  case e_List:
2437  m_object->RemoveReference();
2438  break;
2439  default:
2440  break;
2441  }
2442  m_choice = e_not_set;
2443 }
2444 
2446 {
2447  switch ( index ) {
2448  case e_Set:
2449  (m_object = new(pool) ncbi::objects::CSet())->AddReference();
2450  break;
2451  case e_List:
2452  (m_object = new(pool) ncbi::objects::CList())->AddReference();
2453  break;
2454  default:
2455  break;
2456  }
2457  m_choice = index;
2458 }
2459 
2461  "not set",
2462  "set",
2463  "list"
2464 };
2465 
2467 {
2468  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2469 }
2470 
2472 {
2473  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2474 }
2475 
2477 {
2478  CheckSelected(e_Set);
2479  return *static_cast<const TSet*>(m_object);
2480 }
2481 
2483 {
2485  return *static_cast<TSet*>(m_object);
2486 }
2487 
2489 {
2490  TSet* ptr = &value;
2491  if ( m_choice != e_Set || m_object != ptr ) {
2492  ResetSelection();
2493  (m_object = ptr)->AddReference();
2494  m_choice = e_Set;
2495  }
2496 }
2497 
2499 {
2500  CheckSelected(e_List);
2501  return *static_cast<const TList*>(m_object);
2502 }
2503 
2505 {
2507  return *static_cast<TList*>(m_object);
2508 }
2509 
2511 {
2512  TList* ptr = &value;
2513  if ( m_choice != e_List || m_object != ptr ) {
2514  ResetSelection();
2515  (m_object = ptr)->AddReference();
2516  m_choice = e_List;
2517  }
2518 }
2519 
2520 // helper methods
2521 
2522 // type info
2524 {
2525  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-setlist-constructor", "mmlclass");
2526  SET_CHOICE_MODULE("pubmed_mathml3");
2527  ADD_NAMED_REF_CHOICE_VARIANT("set", m_object, CSet)->SetNsQualified(true);
2528  ADD_NAMED_REF_CHOICE_VARIANT("list", m_object, CList)->SetNsQualified(true);
2529  info->CodeVersion(22301);
2530  info->DataSpec(ncbi::EDataSpec::eXSD);
2531 }
2533 
2534 // constructor
2536  : m_choice(e_not_set)
2537 {
2538 }
2539 
2540 // destructor
2542 {
2543  Reset();
2544 }
2545 
2546 
2548 {
2549  if ( m_choice != e_not_set )
2550  ResetSelection();
2551 }
2552 
2554 {
2555  switch ( m_choice ) {
2556  case e_Union:
2557  case e_Intersect:
2558  case e_Cartesianproduct:
2559  m_object->RemoveReference();
2560  break;
2561  default:
2562  break;
2563  }
2564  m_choice = e_not_set;
2565 }
2566 
2568 {
2569  switch ( index ) {
2570  case e_Union:
2571  (m_object = new(pool) ncbi::objects::CUnion())->AddReference();
2572  break;
2573  case e_Intersect:
2574  (m_object = new(pool) ncbi::objects::CIntersect())->AddReference();
2575  break;
2576  case e_Cartesianproduct:
2577  (m_object = new(pool) ncbi::objects::CCartesianproduct())->AddReference();
2578  break;
2579  default:
2580  break;
2581  }
2582  m_choice = index;
2583 }
2584 
2586  "not set",
2587  "union",
2588  "intersect",
2589  "cartesianproduct"
2590 };
2591 
2593 {
2594  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2595 }
2596 
2598 {
2599  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2600 }
2601 
2603 {
2604  CheckSelected(e_Union);
2605  return *static_cast<const TUnion*>(m_object);
2606 }
2607 
2609 {
2612  value.SetUnion();
2613  return value;
2614 }
2615 
2617 {
2618  CheckSelected(e_Intersect);
2619  return *static_cast<const TIntersect*>(m_object);
2620 }
2621 
2623 {
2626  value.SetIntersect();
2627  return value;
2628 }
2629 
2631 {
2632  CheckSelected(e_Cartesianproduct);
2633  return *static_cast<const TCartesianproduct*>(m_object);
2634 }
2635 
2637 {
2638  Select(e_Cartesianproduct, NCBI_NS_NCBI::eDoNotResetVariant);
2640  value.SetCartesianproduct();
2641  return value;
2642 }
2643 
2644 // helper methods
2645 
2646 // type info
2648 {
2649  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-set", "mmlclass");
2650  SET_CHOICE_MODULE("pubmed_mathml3");
2651  ADD_NAMED_REF_CHOICE_VARIANT("union", m_object, CUnion)->SetNsQualified(true);
2652  ADD_NAMED_REF_CHOICE_VARIANT("intersect", m_object, CIntersect)->SetNsQualified(true);
2653  ADD_NAMED_REF_CHOICE_VARIANT("cartesianproduct", m_object, CCartesianproduct)->SetNsQualified(true);
2654  info->CodeVersion(22301);
2655  info->DataSpec(ncbi::EDataSpec::eXSD);
2656 }
2658 
2659 // constructor
2661  : m_choice(e_not_set)
2662 {
2663 }
2664 
2665 // destructor
2667 {
2668  Reset();
2669 }
2670 
2671 
2673 {
2674  if ( m_choice != e_not_set )
2675  ResetSelection();
2676 }
2677 
2679 {
2680  switch ( m_choice ) {
2681  case e_In:
2682  case e_Notin:
2683  case e_Notsubset:
2684  case e_Notprsubset:
2685  case e_Setdiff:
2686  m_object->RemoveReference();
2687  break;
2688  default:
2689  break;
2690  }
2691  m_choice = e_not_set;
2692 }
2693 
2695 {
2696  switch ( index ) {
2697  case e_In:
2698  (m_object = new(pool) ncbi::objects::CIn())->AddReference();
2699  break;
2700  case e_Notin:
2701  (m_object = new(pool) ncbi::objects::CNotin())->AddReference();
2702  break;
2703  case e_Notsubset:
2704  (m_object = new(pool) ncbi::objects::CNotsubset())->AddReference();
2705  break;
2706  case e_Notprsubset:
2707  (m_object = new(pool) ncbi::objects::CNotprsubset())->AddReference();
2708  break;
2709  case e_Setdiff:
2710  (m_object = new(pool) ncbi::objects::CSetdiff())->AddReference();
2711  break;
2712  default:
2713  break;
2714  }
2715  m_choice = index;
2716 }
2717 
2719  "not set",
2720  "in",
2721  "notin",
2722  "notsubset",
2723  "notprsubset",
2724  "setdiff"
2725 };
2726 
2728 {
2729  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2730 }
2731 
2733 {
2734  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2735 }
2736 
2738 {
2739  CheckSelected(e_In);
2740  return *static_cast<const TIn*>(m_object);
2741 }
2742 
2744 {
2747  value.SetIn();
2748  return value;
2749 }
2750 
2752 {
2753  CheckSelected(e_Notin);
2754  return *static_cast<const TNotin*>(m_object);
2755 }
2756 
2758 {
2761  value.SetNotin();
2762  return value;
2763 }
2764 
2766 {
2767  CheckSelected(e_Notsubset);
2768  return *static_cast<const TNotsubset*>(m_object);
2769 }
2770 
2772 {
2775  value.SetNotsubset();
2776  return value;
2777 }
2778 
2780 {
2781  CheckSelected(e_Notprsubset);
2782  return *static_cast<const TNotprsubset*>(m_object);
2783 }
2784 
2786 {
2787  Select(e_Notprsubset, NCBI_NS_NCBI::eDoNotResetVariant);
2789  value.SetNotprsubset();
2790  return value;
2791 }
2792 
2794 {
2795  CheckSelected(e_Setdiff);
2796  return *static_cast<const TSetdiff*>(m_object);
2797 }
2798 
2800 {
2803  value.SetSetdiff();
2804  return value;
2805 }
2806 
2807 // helper methods
2808 
2809 // type info
2811 {
2812  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.binary-set", "mmlclass");
2813  SET_CHOICE_MODULE("pubmed_mathml3");
2814  ADD_NAMED_REF_CHOICE_VARIANT("in", m_object, CIn)->SetNsQualified(true);
2815  ADD_NAMED_REF_CHOICE_VARIANT("notin", m_object, CNotin)->SetNsQualified(true);
2816  ADD_NAMED_REF_CHOICE_VARIANT("notsubset", m_object, CNotsubset)->SetNsQualified(true);
2817  ADD_NAMED_REF_CHOICE_VARIANT("notprsubset", m_object, CNotprsubset)->SetNsQualified(true);
2818  ADD_NAMED_REF_CHOICE_VARIANT("setdiff", m_object, CSetdiff)->SetNsQualified(true);
2819  info->CodeVersion(22301);
2820  info->DataSpec(ncbi::EDataSpec::eXSD);
2821 }
2823 
2824 // constructor
2826  : m_choice(e_not_set)
2827 {
2828 }
2829 
2830 // destructor
2832 {
2833  Reset();
2834 }
2835 
2836 
2838 {
2839  if ( m_choice != e_not_set )
2840  ResetSelection();
2841 }
2842 
2844 {
2845  switch ( m_choice ) {
2846  case e_Subset:
2847  case e_Prsubset:
2848  m_object->RemoveReference();
2849  break;
2850  default:
2851  break;
2852  }
2853  m_choice = e_not_set;
2854 }
2855 
2857 {
2858  switch ( index ) {
2859  case e_Subset:
2860  (m_object = new(pool) ncbi::objects::CSubset())->AddReference();
2861  break;
2862  case e_Prsubset:
2863  (m_object = new(pool) ncbi::objects::CPrsubset())->AddReference();
2864  break;
2865  default:
2866  break;
2867  }
2868  m_choice = index;
2869 }
2870 
2872  "not set",
2873  "subset",
2874  "prsubset"
2875 };
2876 
2878 {
2879  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2880 }
2881 
2883 {
2884  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
2885 }
2886 
2888 {
2889  CheckSelected(e_Subset);
2890  return *static_cast<const TSubset*>(m_object);
2891 }
2892 
2894 {
2897  value.SetSubset();
2898  return value;
2899 }
2900 
2902 {
2903  CheckSelected(e_Prsubset);
2904  return *static_cast<const TPrsubset*>(m_object);
2905 }
2906 
2908 {
2911  value.SetPrsubset();
2912  return value;
2913 }
2914 
2915 // helper methods
2916 
2917 // type info
2919 {
2920  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-set-reln", "mmlclass");
2921  SET_CHOICE_MODULE("pubmed_mathml3");
2922  ADD_NAMED_REF_CHOICE_VARIANT("subset", m_object, CSubset)->SetNsQualified(true);
2923  ADD_NAMED_REF_CHOICE_VARIANT("prsubset", m_object, CPrsubset)->SetNsQualified(true);
2924  info->CodeVersion(22301);
2925  info->DataSpec(ncbi::EDataSpec::eXSD);
2926 }
2928 
2929 // constructor
2931  : m_choice(e_not_set)
2932 {
2933 }
2934 
2935 // destructor
2937 {
2938  Reset();
2939 }
2940 
2941 
2943 {
2944  return m_Card ? m_Card->IsSetCard() : false;
2945 }
2946 
2948 {
2949  if ( !m_Card ) {
2950  m_Card.Reset(new TCard());
2951  return;
2952  }
2953  (*m_Card).Reset();
2954 }
2955 
2957 {
2958  m_Card.Reset(&value);
2959 }
2960 
2962 {
2963  if ( !m_Card ) {
2964  ResetCard();
2965  }
2966  m_Card->SetCard();
2967  return (*m_Card);
2968 }
2969 
2971 {
2972  ResetCard();
2973 }
2974 
2976 {
2977  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-set", "mmlclass");
2978  SET_CLASS_MODULE("pubmed_mathml3");
2979  ADD_NAMED_REF_MEMBER("card", m_Card, CCard)->SetNsQualified(true);
2980  info->RandomOrder();
2981  info->CodeVersion(22301);
2982  info->DataSpec(ncbi::EDataSpec::eXSD);
2983 }
2985 
2986 // constructor
2988 {
2989  memset(m_set_State,0,sizeof(m_set_State));
2990  if ( !IsAllocatedInPool() ) {
2991  ResetCard();
2992  }
2993 }
2994 
2995 // destructor
2997 {
2998 }
2999 
3000 
3002 {
3003  return m_Sum ? m_Sum->IsSetSum() : false;
3004 }
3005 
3007 {
3008  if ( !m_Sum ) {
3009  m_Sum.Reset(new TSum());
3010  return;
3011  }
3012  (*m_Sum).Reset();
3013 }
3014 
3016 {
3017  m_Sum.Reset(&value);
3018 }
3019 
3021 {
3022  if ( !m_Sum ) {
3023  ResetSum();
3024  }
3025  m_Sum->SetSum();
3026  return (*m_Sum);
3027 }
3028 
3030 {
3031  ResetSum();
3032 }
3033 
3035 {
3036  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.sum", "mmlclass");
3037  SET_CLASS_MODULE("pubmed_mathml3");
3038  ADD_NAMED_REF_MEMBER("sum", m_Sum, CSum)->SetNsQualified(true);
3039  info->RandomOrder();
3040  info->CodeVersion(22301);
3041  info->DataSpec(ncbi::EDataSpec::eXSD);
3042 }
3044 
3045 // constructor
3047 {
3048  memset(m_set_State,0,sizeof(m_set_State));
3049  if ( !IsAllocatedInPool() ) {
3050  ResetSum();
3051  }
3052 }
3053 
3054 // destructor
3056 {
3057 }
3058 
3059 
3061 {
3062  return m_Product ? m_Product->IsSetProduct() : false;
3063 }
3064 
3066 {
3067  if ( !m_Product ) {
3068  m_Product.Reset(new TProduct());
3069  return;
3070  }
3071  (*m_Product).Reset();
3072 }
3073 
3075 {
3076  m_Product.Reset(&value);
3077 }
3078 
3080 {
3081  if ( !m_Product ) {
3082  ResetProduct();
3083  }
3084  m_Product->SetProduct();
3085  return (*m_Product);
3086 }
3087 
3089 {
3090  ResetProduct();
3091 }
3092 
3094 {
3095  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.product", "mmlclass");
3096  SET_CLASS_MODULE("pubmed_mathml3");
3097  ADD_NAMED_REF_MEMBER("product", m_Product, CProduct)->SetNsQualified(true);
3098  info->RandomOrder();
3099  info->CodeVersion(22301);
3100  info->DataSpec(ncbi::EDataSpec::eXSD);
3101 }
3103 
3104 // constructor
3106 {
3107  memset(m_set_State,0,sizeof(m_set_State));
3108  if ( !IsAllocatedInPool() ) {
3109  ResetProduct();
3110  }
3111 }
3112 
3113 // destructor
3115 {
3116 }
3117 
3118 
3120 {
3121  return m_Limit ? m_Limit->IsSetLimit() : false;
3122 }
3123 
3125 {
3126  if ( !m_Limit ) {
3127  m_Limit.Reset(new TLimit());
3128  return;
3129  }
3130  (*m_Limit).Reset();
3131 }
3132 
3134 {
3135  m_Limit.Reset(&value);
3136 }
3137 
3139 {
3140  if ( !m_Limit ) {
3141  ResetLimit();
3142  }
3143  m_Limit->SetLimit();
3144  return (*m_Limit);
3145 }
3146 
3148 {
3149  ResetLimit();
3150 }
3151 
3153 {
3154  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.limit", "mmlclass");
3155  SET_CLASS_MODULE("pubmed_mathml3");
3156  ADD_NAMED_REF_MEMBER("limit", m_Limit, CLimit)->SetNsQualified(true);
3157  info->RandomOrder();
3158  info->CodeVersion(22301);
3159  info->DataSpec(ncbi::EDataSpec::eXSD);
3160 }
3162 
3163 // constructor
3165 {
3166  memset(m_set_State,0,sizeof(m_set_State));
3167  if ( !IsAllocatedInPool() ) {
3168  ResetLimit();
3169  }
3170 }
3171 
3172 // destructor
3174 {
3175 }
3176 
3177 
3179 {
3180  if ( m_choice != e_not_set )
3181  ResetSelection();
3182 }
3183 
3185 {
3186  switch ( m_choice ) {
3187  case e_Sin:
3188  case e_Cos:
3189  case e_Tan:
3190  case e_Sec:
3191  case e_Csc:
3192  case e_Cot:
3193  case e_Sinh:
3194  case e_Cosh:
3195  case e_Tanh:
3196  case e_Sech:
3197  case e_Csch:
3198  case e_Coth:
3199  case e_Arcsin:
3200  case e_Arccos:
3201  case e_Arctan:
3202  case e_Arccosh:
3203  case e_Arccot:
3204  case e_Arccoth:
3205  case e_Arccsc:
3206  case e_Arccsch:
3207  case e_Arcsec:
3208  case e_Arcsech:
3209  case e_Arcsinh:
3210  case e_Arctanh:
3211  m_object->RemoveReference();
3212  break;
3213  default:
3214  break;
3215  }
3216  m_choice = e_not_set;
3217 }
3218 
3220 {
3221  switch ( index ) {
3222  case e_Sin:
3223  (m_object = new(pool) ncbi::objects::CSin())->AddReference();
3224  break;
3225  case e_Cos:
3226  (m_object = new(pool) ncbi::objects::CCos())->AddReference();
3227  break;
3228  case e_Tan:
3229  (m_object = new(pool) ncbi::objects::CTan())->AddReference();
3230  break;
3231  case e_Sec:
3232  (m_object = new(pool) ncbi::objects::CSec())->AddReference();
3233  break;
3234  case e_Csc:
3235  (m_object = new(pool) ncbi::objects::CCsc())->AddReference();
3236  break;
3237  case e_Cot:
3238  (m_object = new(pool) ncbi::objects::CCot())->AddReference();
3239  break;
3240  case e_Sinh:
3241  (m_object = new(pool) ncbi::objects::CSinh())->AddReference();
3242  break;
3243  case e_Cosh:
3244  (m_object = new(pool) ncbi::objects::CCosh())->AddReference();
3245  break;
3246  case e_Tanh:
3247  (m_object = new(pool) ncbi::objects::CTanh())->AddReference();
3248  break;
3249  case e_Sech:
3250  (m_object = new(pool) ncbi::objects::CSech())->AddReference();
3251  break;
3252  case e_Csch:
3253  (m_object = new(pool) ncbi::objects::CCsch())->AddReference();
3254  break;
3255  case e_Coth:
3256  (m_object = new(pool) ncbi::objects::CCoth())->AddReference();
3257  break;
3258  case e_Arcsin:
3259  (m_object = new(pool) ncbi::objects::CArcsin())->AddReference();
3260  break;
3261  case e_Arccos:
3262  (m_object = new(pool) ncbi::objects::CArccos())->AddReference();
3263  break;
3264  case e_Arctan:
3265  (m_object = new(pool) ncbi::objects::CArctan())->AddReference();
3266  break;
3267  case e_Arccosh:
3268  (m_object = new(pool) ncbi::objects::CArccosh())->AddReference();
3269  break;
3270  case e_Arccot:
3271  (m_object = new(pool) ncbi::objects::CArccot())->AddReference();
3272  break;
3273  case e_Arccoth:
3274  (m_object = new(pool) ncbi::objects::CArccoth())->AddReference();
3275  break;
3276  case e_Arccsc:
3277  (m_object = new(pool) ncbi::objects::CArccsc())->AddReference();
3278  break;
3279  case e_Arccsch:
3280  (m_object = new(pool) ncbi::objects::CArccsch())->AddReference();
3281  break;
3282  case e_Arcsec:
3283  (m_object = new(pool) ncbi::objects::CArcsec())->AddReference();
3284  break;
3285  case e_Arcsech:
3286  (m_object = new(pool) ncbi::objects::CArcsech())->AddReference();
3287  break;
3288  case e_Arcsinh:
3289  (m_object = new(pool) ncbi::objects::CArcsinh())->AddReference();
3290  break;
3291  case e_Arctanh:
3292  (m_object = new(pool) ncbi::objects::CArctanh())->AddReference();
3293  break;
3294  default:
3295  break;
3296  }
3297  m_choice = index;
3298 }
3299 
3301  "not set",
3302  "sin",
3303  "cos",
3304  "tan",
3305  "sec",
3306  "csc",
3307  "cot",
3308  "sinh",
3309  "cosh",
3310  "tanh",
3311  "sech",
3312  "csch",
3313  "coth",
3314  "arcsin",
3315  "arccos",
3316  "arctan",
3317  "arccosh",
3318  "arccot",
3319  "arccoth",
3320  "arccsc",
3321  "arccsch",
3322  "arcsec",
3323  "arcsech",
3324  "arcsinh",
3325  "arctanh"
3326 };
3327 
3329 {
3330  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3331 }
3332 
3334 {
3335  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3336 }
3337 
3339 {
3340  CheckSelected(e_Sin);
3341  return *static_cast<const TSin*>(m_object);
3342 }
3343 
3345 {
3348  value.SetSin();
3349  return value;
3350 }
3351 
3353 {
3354  CheckSelected(e_Cos);
3355  return *static_cast<const TCos*>(m_object);
3356 }
3357 
3359 {
3362  value.SetCos();
3363  return value;
3364 }
3365 
3367 {
3368  CheckSelected(e_Tan);
3369  return *static_cast<const TTan*>(m_object);
3370 }
3371 
3373 {
3376  value.SetTan();
3377  return value;
3378 }
3379 
3381 {
3382  CheckSelected(e_Sec);
3383  return *static_cast<const TSec*>(m_object);
3384 }
3385 
3387 {
3390  value.SetSec();
3391  return value;
3392 }
3393 
3395 {
3396  CheckSelected(e_Csc);
3397  return *static_cast<const TCsc*>(m_object);
3398 }
3399 
3401 {
3404  value.SetCsc();
3405  return value;
3406 }
3407 
3409 {
3410  CheckSelected(e_Cot);
3411  return *static_cast<const TCot*>(m_object);
3412 }
3413 
3415 {
3418  value.SetCot();
3419  return value;
3420 }
3421 
3423 {
3424  CheckSelected(e_Sinh);
3425  return *static_cast<const TSinh*>(m_object);
3426 }
3427 
3429 {
3432  value.SetSinh();
3433  return value;
3434 }
3435 
3437 {
3438  CheckSelected(e_Cosh);
3439  return *static_cast<const TCosh*>(m_object);
3440 }
3441 
3443 {
3446  value.SetCosh();
3447  return value;
3448 }
3449 
3451 {
3452  CheckSelected(e_Tanh);
3453  return *static_cast<const TTanh*>(m_object);
3454 }
3455 
3457 {
3460  value.SetTanh();
3461  return value;
3462 }
3463 
3465 {
3466  CheckSelected(e_Sech);
3467  return *static_cast<const TSech*>(m_object);
3468 }
3469 
3471 {
3474  value.SetSech();
3475  return value;
3476 }
3477 
3479 {
3480  CheckSelected(e_Csch);
3481  return *static_cast<const TCsch*>(m_object);
3482 }
3483 
3485 {
3488  value.SetCsch();
3489  return value;
3490 }
3491 
3493 {
3494  CheckSelected(e_Coth);
3495  return *static_cast<const TCoth*>(m_object);
3496 }
3497 
3499 {
3502  value.SetCoth();
3503  return value;
3504 }
3505 
3507 {
3508  CheckSelected(e_Arcsin);
3509  return *static_cast<const TArcsin*>(m_object);
3510 }
3511 
3513 {
3516  value.SetArcsin();
3517  return value;
3518 }
3519 
3521 {
3522  CheckSelected(e_Arccos);
3523  return *static_cast<const TArccos*>(m_object);
3524 }
3525 
3527 {
3530  value.SetArccos();
3531  return value;
3532 }
3533 
3535 {
3536  CheckSelected(e_Arctan);
3537  return *static_cast<const TArctan*>(m_object);
3538 }
3539 
3541 {
3544  value.SetArctan();
3545  return value;
3546 }
3547 
3549 {
3550  CheckSelected(e_Arccosh);
3551  return *static_cast<const TArccosh*>(m_object);
3552 }
3553 
3555 {
3558  value.SetArccosh();
3559  return value;
3560 }
3561 
3563 {
3564  CheckSelected(e_Arccot);
3565  return *static_cast<const TArccot*>(m_object);
3566 }
3567 
3569 {
3572  value.SetArccot();
3573  return value;
3574 }
3575 
3577 {
3578  CheckSelected(e_Arccoth);
3579  return *static_cast<const TArccoth*>(m_object);
3580 }
3581 
3583 {
3586  value.SetArccoth();
3587  return value;
3588 }
3589 
3591 {
3592  CheckSelected(e_Arccsc);
3593  return *static_cast<const TArccsc*>(m_object);
3594 }
3595 
3597 {
3600  value.SetArccsc();
3601  return value;
3602 }
3603 
3605 {
3606  CheckSelected(e_Arccsch);
3607  return *static_cast<const TArccsch*>(m_object);
3608 }
3609 
3611 {
3614  value.SetArccsch();
3615  return value;
3616 }
3617 
3619 {
3620  CheckSelected(e_Arcsec);
3621  return *static_cast<const TArcsec*>(m_object);
3622 }
3623 
3625 {
3628  value.SetArcsec();
3629  return value;
3630 }
3631 
3633 {
3634  CheckSelected(e_Arcsech);
3635  return *static_cast<const TArcsech*>(m_object);
3636 }
3637 
3639 {
3642  value.SetArcsech();
3643  return value;
3644 }
3645 
3647 {
3648  CheckSelected(e_Arcsinh);
3649  return *static_cast<const TArcsinh*>(m_object);
3650 }
3651 
3653 {
3656  value.SetArcsinh();
3657  return value;
3658 }
3659 
3661 {
3662  CheckSelected(e_Arctanh);
3663  return *static_cast<const TArctanh*>(m_object);
3664 }
3665 
3667 {
3670  value.SetArctanh();
3671  return value;
3672 }
3673 
3674 // helper methods
3675 
3676 // type info
3678 {
3679  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-elementary", "mmlclass");
3680  SET_CHOICE_MODULE("pubmed_mathml3");
3681  ADD_NAMED_REF_CHOICE_VARIANT("sin", m_object, CSin)->SetNsQualified(true);
3682  ADD_NAMED_REF_CHOICE_VARIANT("cos", m_object, CCos)->SetNsQualified(true);
3683  ADD_NAMED_REF_CHOICE_VARIANT("tan", m_object, CTan)->SetNsQualified(true);
3684  ADD_NAMED_REF_CHOICE_VARIANT("sec", m_object, CSec)->SetNsQualified(true);
3685  ADD_NAMED_REF_CHOICE_VARIANT("csc", m_object, CCsc)->SetNsQualified(true);
3686  ADD_NAMED_REF_CHOICE_VARIANT("cot", m_object, CCot)->SetNsQualified(true);
3687  ADD_NAMED_REF_CHOICE_VARIANT("sinh", m_object, CSinh)->SetNsQualified(true);
3688  ADD_NAMED_REF_CHOICE_VARIANT("cosh", m_object, CCosh)->SetNsQualified(true);
3689  ADD_NAMED_REF_CHOICE_VARIANT("tanh", m_object, CTanh)->SetNsQualified(true);
3690  ADD_NAMED_REF_CHOICE_VARIANT("sech", m_object, CSech)->SetNsQualified(true);
3691  ADD_NAMED_REF_CHOICE_VARIANT("csch", m_object, CCsch)->SetNsQualified(true);
3692  ADD_NAMED_REF_CHOICE_VARIANT("coth", m_object, CCoth)->SetNsQualified(true);
3693  ADD_NAMED_REF_CHOICE_VARIANT("arcsin", m_object, CArcsin)->SetNsQualified(true);
3694  ADD_NAMED_REF_CHOICE_VARIANT("arccos", m_object, CArccos)->SetNsQualified(true);
3695  ADD_NAMED_REF_CHOICE_VARIANT("arctan", m_object, CArctan)->SetNsQualified(true);
3696  ADD_NAMED_REF_CHOICE_VARIANT("arccosh", m_object, CArccosh)->SetNsQualified(true);
3697  ADD_NAMED_REF_CHOICE_VARIANT("arccot", m_object, CArccot)->SetNsQualified(true);
3698  ADD_NAMED_REF_CHOICE_VARIANT("arccoth", m_object, CArccoth)->SetNsQualified(true);
3699  ADD_NAMED_REF_CHOICE_VARIANT("arccsc", m_object, CArccsc)->SetNsQualified(true);
3700  ADD_NAMED_REF_CHOICE_VARIANT("arccsch", m_object, CArccsch)->SetNsQualified(true);
3701  ADD_NAMED_REF_CHOICE_VARIANT("arcsec", m_object, CArcsec)->SetNsQualified(true);
3702  ADD_NAMED_REF_CHOICE_VARIANT("arcsech", m_object, CArcsech)->SetNsQualified(true);
3703  ADD_NAMED_REF_CHOICE_VARIANT("arcsinh", m_object, CArcsinh)->SetNsQualified(true);
3704  ADD_NAMED_REF_CHOICE_VARIANT("arctanh", m_object, CArctanh)->SetNsQualified(true);
3705  info->CodeVersion(22301);
3706  info->DataSpec(ncbi::EDataSpec::eXSD);
3707 }
3709 
3710 // constructor
3712  : m_choice(e_not_set)
3713 {
3714 }
3715 
3716 // destructor
3718 {
3719  Reset();
3720 }
3721 
3722 
3724 {
3725  if ( m_choice != e_not_set )
3726  ResetSelection();
3727 }
3728 
3730 {
3731  switch ( m_choice ) {
3732  case e_Mean:
3733  case e_Sdev:
3734  case e_Variance:
3735  case e_Median:
3736  case e_Mode:
3737  m_object->RemoveReference();
3738  break;
3739  default:
3740  break;
3741  }
3742  m_choice = e_not_set;
3743 }
3744 
3746 {
3747  switch ( index ) {
3748  case e_Mean:
3749  (m_object = new(pool) ncbi::objects::CMean())->AddReference();
3750  break;
3751  case e_Sdev:
3752  (m_object = new(pool) ncbi::objects::CSdev())->AddReference();
3753  break;
3754  case e_Variance:
3755  (m_object = new(pool) ncbi::objects::CVariance())->AddReference();
3756  break;
3757  case e_Median:
3758  (m_object = new(pool) ncbi::objects::CMedian())->AddReference();
3759  break;
3760  case e_Mode:
3761  (m_object = new(pool) ncbi::objects::CMode())->AddReference();
3762  break;
3763  default:
3764  break;
3765  }
3766  m_choice = index;
3767 }
3768 
3770  "not set",
3771  "mean",
3772  "sdev",
3773  "variance",
3774  "median",
3775  "mode"
3776 };
3777 
3779 {
3780  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3781 }
3782 
3784 {
3785  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3786 }
3787 
3789 {
3790  CheckSelected(e_Mean);
3791  return *static_cast<const TMean*>(m_object);
3792 }
3793 
3795 {
3798  value.SetMean();
3799  return value;
3800 }
3801 
3803 {
3804  CheckSelected(e_Sdev);
3805  return *static_cast<const TSdev*>(m_object);
3806 }
3807 
3809 {
3812  value.SetSdev();
3813  return value;
3814 }
3815 
3817 {
3818  CheckSelected(e_Variance);
3819  return *static_cast<const TVariance*>(m_object);
3820 }
3821 
3823 {
3826  value.SetVariance();
3827  return value;
3828 }
3829 
3831 {
3832  CheckSelected(e_Median);
3833  return *static_cast<const TMedian*>(m_object);
3834 }
3835 
3837 {
3840  value.SetMedian();
3841  return value;
3842 }
3843 
3845 {
3846  CheckSelected(e_Mode);
3847  return *static_cast<const TMode*>(m_object);
3848 }
3849 
3851 {
3854  value.SetMode();
3855  return value;
3856 }
3857 
3858 // helper methods
3859 
3860 // type info
3862 {
3863  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-stats", "mmlclass");
3864  SET_CHOICE_MODULE("pubmed_mathml3");
3865  ADD_NAMED_REF_CHOICE_VARIANT("mean", m_object, CMean)->SetNsQualified(true);
3866  ADD_NAMED_REF_CHOICE_VARIANT("sdev", m_object, CSdev)->SetNsQualified(true);
3867  ADD_NAMED_REF_CHOICE_VARIANT("variance", m_object, CVariance)->SetNsQualified(true);
3868  ADD_NAMED_REF_CHOICE_VARIANT("median", m_object, CMedian)->SetNsQualified(true);
3869  ADD_NAMED_REF_CHOICE_VARIANT("mode", m_object, CMode)->SetNsQualified(true);
3870  info->CodeVersion(22301);
3871  info->DataSpec(ncbi::EDataSpec::eXSD);
3872 }
3874 
3875 // constructor
3877  : m_choice(e_not_set)
3878 {
3879 }
3880 
3881 // destructor
3883 {
3884  Reset();
3885 }
3886 
3887 
3889 {
3890  if ( m_choice != e_not_set )
3891  ResetSelection();
3892 }
3893 
3895 {
3896  switch ( m_choice ) {
3897  case e_Vector:
3898  case e_Matrix:
3899  case e_Matrixrow:
3900  m_object->RemoveReference();
3901  break;
3902  default:
3903  break;
3904  }
3905  m_choice = e_not_set;
3906 }
3907 
3909 {
3910  switch ( index ) {
3911  case e_Vector:
3912  (m_object = new(pool) ncbi::objects::CVector())->AddReference();
3913  break;
3914  case e_Matrix:
3915  (m_object = new(pool) ncbi::objects::CMatrix())->AddReference();
3916  break;
3917  case e_Matrixrow:
3918  (m_object = new(pool) ncbi::objects::CMatrixrow())->AddReference();
3919  break;
3920  default:
3921  break;
3922  }
3923  m_choice = index;
3924 }
3925 
3927  "not set",
3928  "vector",
3929  "matrix",
3930  "matrixrow"
3931 };
3932 
3934 {
3935  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3936 }
3937 
3939 {
3940  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
3941 }
3942 
3944 {
3945  CheckSelected(e_Vector);
3946  return *static_cast<const TVector*>(m_object);
3947 }
3948 
3950 {
3952  return *static_cast<TVector*>(m_object);
3953 }
3954 
3956 {
3957  TVector* ptr = &value;
3958  if ( m_choice != e_Vector || m_object != ptr ) {
3959  ResetSelection();
3960  (m_object = ptr)->AddReference();
3961  m_choice = e_Vector;
3962  }
3963 }
3964 
3966 {
3967  CheckSelected(e_Matrix);
3968  return *static_cast<const TMatrix*>(m_object);
3969 }
3970 
3972 {
3974  return *static_cast<TMatrix*>(m_object);
3975 }
3976 
3978 {
3979  TMatrix* ptr = &value;
3980  if ( m_choice != e_Matrix || m_object != ptr ) {
3981  ResetSelection();
3982  (m_object = ptr)->AddReference();
3983  m_choice = e_Matrix;
3984  }
3985 }
3986 
3988 {
3989  CheckSelected(e_Matrixrow);
3990  return *static_cast<const TMatrixrow*>(m_object);
3991 }
3992 
3994 {
3996  return *static_cast<TMatrixrow*>(m_object);
3997 }
3998 
4000 {
4001  TMatrixrow* ptr = &value;
4002  if ( m_choice != e_Matrixrow || m_object != ptr ) {
4003  ResetSelection();
4004  (m_object = ptr)->AddReference();
4005  m_choice = e_Matrixrow;
4006  }
4007 }
4008 
4009 // helper methods
4010 
4011 // type info
4013 {
4014  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-constructor", "mmlclass");
4015  SET_CHOICE_MODULE("pubmed_mathml3");
4016  ADD_NAMED_REF_CHOICE_VARIANT("vector", m_object, CVector)->SetNsQualified(true);
4017  ADD_NAMED_REF_CHOICE_VARIANT("matrix", m_object, CMatrix)->SetNsQualified(true);
4018  ADD_NAMED_REF_CHOICE_VARIANT("matrixrow", m_object, CMatrixrow)->SetNsQualified(true);
4019  info->CodeVersion(22301);
4020  info->DataSpec(ncbi::EDataSpec::eXSD);
4021 }
4023 
4024 // constructor
4026  : m_choice(e_not_set)
4027 {
4028 }
4029 
4030 // destructor
4032 {
4033  Reset();
4034 }
4035 
4036 
4038 {
4039  if ( m_choice != e_not_set )
4040  ResetSelection();
4041 }
4042 
4044 {
4045  switch ( m_choice ) {
4046  case e_Determinant:
4047  case e_Transpose:
4048  m_object->RemoveReference();
4049  break;
4050  default:
4051  break;
4052  }
4053  m_choice = e_not_set;
4054 }
4055 
4057 {
4058  switch ( index ) {
4059  case e_Determinant:
4060  (m_object = new(pool) ncbi::objects::CDeterminant())->AddReference();
4061  break;
4062  case e_Transpose:
4063  (m_object = new(pool) ncbi::objects::CTranspose())->AddReference();
4064  break;
4065  default:
4066  break;
4067  }
4068  m_choice = index;
4069 }
4070 
4072  "not set",
4073  "determinant",
4074  "transpose"
4075 };
4076 
4078 {
4079  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4080 }
4081 
4083 {
4084  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4085 }
4086 
4088 {
4089  CheckSelected(e_Determinant);
4090  return *static_cast<const TDeterminant*>(m_object);
4091 }
4092 
4094 {
4095  Select(e_Determinant, NCBI_NS_NCBI::eDoNotResetVariant);
4097  value.SetDeterminant();
4098  return value;
4099 }
4100 
4102 {
4103  CheckSelected(e_Transpose);
4104  return *static_cast<const TTranspose*>(m_object);
4105 }
4106 
4108 {
4111  value.SetTranspose();
4112  return value;
4113 }
4114 
4115 // helper methods
4116 
4117 // type info
4119 {
4120  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.unary-linalg", "mmlclass");
4121  SET_CHOICE_MODULE("pubmed_mathml3");
4122  ADD_NAMED_REF_CHOICE_VARIANT("determinant", m_object, CDeterminant)->SetNsQualified(true);
4123  ADD_NAMED_REF_CHOICE_VARIANT("transpose", m_object, CTranspose)->SetNsQualified(true);
4124  info->CodeVersion(22301);
4125  info->DataSpec(ncbi::EDataSpec::eXSD);
4126 }
4128 
4129 // constructor
4131  : m_choice(e_not_set)
4132 {
4133 }
4134 
4135 // destructor
4137 {
4138  Reset();
4139 }
4140 
4141 
4143 {
4144  return m_Selector ? m_Selector->IsSetSelector() : false;
4145 }
4146 
4148 {
4149  if ( !m_Selector ) {
4150  m_Selector.Reset(new TSelector());
4151  return;
4152  }
4153  (*m_Selector).Reset();
4154 }
4155 
4157 {
4158  m_Selector.Reset(&value);
4159 }
4160 
4162 {
4163  if ( !m_Selector ) {
4164  ResetSelector();
4165  }
4166  m_Selector->SetSelector();
4167  return (*m_Selector);
4168 }
4169 
4171 {
4172  ResetSelector();
4173 }
4174 
4176 {
4177  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.nary-linalg", "mmlclass");
4178  SET_CLASS_MODULE("pubmed_mathml3");
4179  ADD_NAMED_REF_MEMBER("selector", m_Selector, CSelector)->SetNsQualified(true);
4180  info->RandomOrder();
4181  info->CodeVersion(22301);
4182  info->DataSpec(ncbi::EDataSpec::eXSD);
4183 }
4185 
4186 // constructor
4188 {
4189  memset(m_set_State,0,sizeof(m_set_State));
4190  if ( !IsAllocatedInPool() ) {
4191  ResetSelector();
4192  }
4193 }
4194 
4195 // destructor
4197 {
4198 }
4199 
4200 
4202 {
4203  if ( m_choice != e_not_set )
4204  ResetSelection();
4205 }
4206 
4208 {
4209  switch ( m_choice ) {
4210  case e_Vectorproduct:
4211  case e_Scalarproduct:
4212  case e_Outerproduct:
4213  m_object->RemoveReference();
4214  break;
4215  default:
4216  break;
4217  }
4218  m_choice = e_not_set;
4219 }
4220 
4222 {
4223  switch ( index ) {
4224  case e_Vectorproduct:
4225  (m_object = new(pool) ncbi::objects::CVectorproduct())->AddReference();
4226  break;
4227  case e_Scalarproduct:
4228  (m_object = new(pool) ncbi::objects::CScalarproduct())->AddReference();
4229  break;
4230  case e_Outerproduct:
4231  (m_object = new(pool) ncbi::objects::COuterproduct())->AddReference();
4232  break;
4233  default:
4234  break;
4235  }
4236  m_choice = index;
4237 }
4238 
4240  "not set",
4241  "vectorproduct",
4242  "scalarproduct",
4243  "outerproduct"
4244 };
4245 
4247 {
4248  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4249 }
4250 
4252 {
4253  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4254 }
4255 
4257 {
4258  CheckSelected(e_Vectorproduct);
4259  return *static_cast<const TVectorproduct*>(m_object);
4260 }
4261 
4263 {
4264  Select(e_Vectorproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4266  value.SetVectorproduct();
4267  return value;
4268 }
4269 
4271 {
4272  CheckSelected(e_Scalarproduct);
4273  return *static_cast<const TScalarproduct*>(m_object);
4274 }
4275 
4277 {
4278  Select(e_Scalarproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4280  value.SetScalarproduct();
4281  return value;
4282 }
4283 
4285 {
4286  CheckSelected(e_Outerproduct);
4287  return *static_cast<const TOuterproduct*>(m_object);
4288 }
4289 
4291 {
4292  Select(e_Outerproduct, NCBI_NS_NCBI::eDoNotResetVariant);
4294  value.SetOuterproduct();
4295  return value;
4296 }
4297 
4298 // helper methods
4299 
4300 // type info
4302 {
4303  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.binary-linalg", "mmlclass");
4304  SET_CHOICE_MODULE("pubmed_mathml3");
4305  ADD_NAMED_REF_CHOICE_VARIANT("vectorproduct", m_object, CVectorproduct)->SetNsQualified(true);
4306  ADD_NAMED_REF_CHOICE_VARIANT("scalarproduct", m_object, CScalarproduct)->SetNsQualified(true);
4307  ADD_NAMED_REF_CHOICE_VARIANT("outerproduct", m_object, COuterproduct)->SetNsQualified(true);
4308  info->CodeVersion(22301);
4309  info->DataSpec(ncbi::EDataSpec::eXSD);
4310 }
4312 
4313 // constructor
4315  : m_choice(e_not_set)
4316 {
4317 }
4318 
4319 // destructor
4321 {
4322  Reset();
4323 }
4324 
4325 
4327 {
4328  if ( m_choice != e_not_set )
4329  ResetSelection();
4330 }
4331 
4333 {
4334  switch ( m_choice ) {
4335  case e_Integers:
4336  case e_Reals:
4337  case e_Rationals:
4338  case e_Naturalnumbers:
4339  case e_Complexes:
4340  case e_Primes:
4341  case e_Emptyset:
4342  m_object->RemoveReference();
4343  break;
4344  default:
4345  break;
4346  }
4347  m_choice = e_not_set;
4348 }
4349 
4351 {
4352  switch ( index ) {
4353  case e_Integers:
4354  (m_object = new(pool) ncbi::objects::CIntegers())->AddReference();
4355  break;
4356  case e_Reals:
4357  (m_object = new(pool) ncbi::objects::CReals())->AddReference();
4358  break;
4359  case e_Rationals:
4360  (m_object = new(pool) ncbi::objects::CRationals())->AddReference();
4361  break;
4362  case e_Naturalnumbers:
4363  (m_object = new(pool) ncbi::objects::CNaturalnumbers())->AddReference();
4364  break;
4365  case e_Complexes:
4366  (m_object = new(pool) ncbi::objects::CComplexes())->AddReference();
4367  break;
4368  case e_Primes:
4369  (m_object = new(pool) ncbi::objects::CPrimes())->AddReference();
4370  break;
4371  case e_Emptyset:
4372  (m_object = new(pool) ncbi::objects::CEmptyset())->AddReference();
4373  break;
4374  default:
4375  break;
4376  }
4377  m_choice = index;
4378 }
4379 
4381  "not set",
4382  "integers",
4383  "reals",
4384  "rationals",
4385  "naturalnumbers",
4386  "complexes",
4387  "primes",
4388  "emptyset"
4389 };
4390 
4392 {
4393  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4394 }
4395 
4397 {
4398  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4399 }
4400 
4402 {
4403  CheckSelected(e_Integers);
4404  return *static_cast<const TIntegers*>(m_object);
4405 }
4406 
4408 {
4411  value.SetIntegers();
4412  return value;
4413 }
4414 
4416 {
4417  CheckSelected(e_Reals);
4418  return *static_cast<const TReals*>(m_object);
4419 }
4420 
4422 {
4425  value.SetReals();
4426  return value;
4427 }
4428 
4430 {
4431  CheckSelected(e_Rationals);
4432  return *static_cast<const TRationals*>(m_object);
4433 }
4434 
4436 {
4439  value.SetRationals();
4440  return value;
4441 }
4442 
4444 {
4445  CheckSelected(e_Naturalnumbers);
4446  return *static_cast<const TNaturalnumbers*>(m_object);
4447 }
4448 
4450 {
4451  Select(e_Naturalnumbers, NCBI_NS_NCBI::eDoNotResetVariant);
4453  value.SetNaturalnumbers();
4454  return value;
4455 }
4456 
4458 {
4459  CheckSelected(e_Complexes);
4460  return *static_cast<const TComplexes*>(m_object);
4461 }
4462 
4464 {
4467  value.SetComplexes();
4468  return value;
4469 }
4470 
4472 {
4473  CheckSelected(e_Primes);
4474  return *static_cast<const TPrimes*>(m_object);
4475 }
4476 
4478 {
4481  value.SetPrimes();
4482  return value;
4483 }
4484 
4486 {
4487  CheckSelected(e_Emptyset);
4488  return *static_cast<const TEmptyset*>(m_object);
4489 }
4490 
4492 {
4495  value.SetEmptyset();
4496  return value;
4497 }
4498 
4499 // helper methods
4500 
4501 // type info
4503 {
4504  SET_INTERNAL_NAME("bind.content.ContExp.ContExp.E.constant-set", "mmlclass");
4505  SET_CHOICE_MODULE("pubmed_mathml3");
4506  ADD_NAMED_REF_CHOICE_VARIANT("integers", m_object, CIntegers)->SetNsQualified(true);
4507  ADD_NAMED_REF_CHOICE_VARIANT("reals", m_object, CReals)->SetNsQualified(true);
4508  ADD_NAMED_REF_CHOICE_VARIANT("rationals", m_object, CRationals)->SetNsQualified(true);
4509  ADD_NAMED_REF_CHOICE_VARIANT("naturalnumbers", m_object, CNaturalnumbers)->SetNsQualified(true);
4510  ADD_NAMED_REF_CHOICE_VARIANT("complexes", m_object, CComplexes)->SetNsQualified(true);
4511  ADD_NAMED_REF_CHOICE_VARIANT("primes", m_object, CPrimes)->SetNsQualified(true);
4512  ADD_NAMED_REF_CHOICE_VARIANT("emptyset", m_object, CEmptyset)->SetNsQualified(true);
4513  info->CodeVersion(22301);
4514  info->DataSpec(ncbi::EDataSpec::eXSD);
4515 }
4517 
4518 // constructor
4520  : m_choice(e_not_set)
4521 {
4522 }
4523 
4524 // destructor
4526 {
4527  Reset();
4528 }
4529 
4530 
4532 {
4533  if ( m_choice != e_not_set )
4534  ResetSelection();
4535 }
4536 
4538 {
4539  switch ( m_choice ) {
4540  case e_Exponentiale:
4541  case e_Imaginaryi:
4542  case e_Notanumber:
4543  case e_True:
4544  case e_False:
4545  case e_Pi:
4546  case e_Eulergamma:
4547  case e_Infinity:
4548  m_object->RemoveReference();
4549  break;
4550  default:
4551  break;
4552  }
4553  m_choice = e_not_set;
4554 }
4555 
4557 {
4558  switch ( index ) {
4559  case e_Exponentiale:
4560  (m_object = new(pool) ncbi::objects::CExponentiale())->AddReference();
4561  break;
4562  case e_Imaginaryi:
4563  (m_object = new(pool) ncbi::objects::CImaginaryi())->AddReference();
4564  break;
4565  case e_Notanumber:
4566  (m_object = new(pool) ncbi::objects::CNotanumber())->AddReference();
4567  break;
4568  case e_True:
4569  (m_object = new(pool) ncbi::objects::CTrue())->AddReference();
4570  break;
4571  case e_False:
4572  (m_object = new(pool) ncbi::objects::CFalse())->AddReference();
4573  break;
4574  case e_Pi:
4575  (m_object = new(pool) ncbi::objects::CPi())->AddReference();
4576  break;
4577  case e_Eulergamma:
4578  (m_object = new(pool) ncbi::objects::CEulergamma())->AddReference();
4579  break;
4580  case e_Infinity:
4581  (m_object = new(pool) ncbi::objects::CInfinity())->AddReference();
4582  break;
4583  default:
4584  break;
4585  }
4586  m_choice = index;
4587 }
4588 
4590  "not set",
4591  "exponentiale",
4592  "imaginaryi",
4593  "notanumber",
4594  "true",
4595  "false",
4596  "pi",
4597  "eulergamma",
4598  "infinity"
4599 };
4600 
4602 {
4603  return NCBI_NS_NCBI::CInvalidChoiceSelection::GetName(index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4604 }
4605 
4607 {
4608  throw NCBI_NS_NCBI::CInvalidChoiceSelection(DIAG_COMPILE_INFO, this, m_choice, index, sm_SelectionNames, sizeof(sm_SelectionNames)/sizeof(sm_SelectionNames[0]));
4609 }
4610 
4612 {
4613  CheckSelected(e_Exponentiale);
4614  return *static_cast<const TExponentiale*>(m_object);
4615 }
4616 
4618 {
4619  Select(e_Exponentiale, NCBI_NS_NCBI::eDoNotResetVariant);
4621  value.SetExponentiale();
4622  return value;
4623 }
4624 
4626 {
4627  CheckSelected(e_Imaginaryi);
4628  return *static_cast<const TImaginaryi*>(m_object);
4629 }
4630 
4632 {
4635  value.SetImaginaryi();
4636  return value;
4637 }
4638 
4640 {
4641  CheckSelected(e_Notanumber);
4642  return *static_cast<const TNotanumber*>(m_object);
4643 }
4644 
4646 {
4649  value.SetNotanumber();
4650  return value;
4651 }
4652 
4654 {
4655  CheckSelected(e_True);
4656  return *static_cast<const TTrue*>(m_object);
4657 }
4658 
4660 {
4663  value.SetTrue();
4664  return value;
4665 }
4666 
4668 {
4669  CheckSelected(e_False);
4670  return *static_cast<const TFalse*>(m_object);
4671 }
4672 
4674 {
4677  value.SetFalse();
4678  return value;
4679 }
4680 
4682 {
4683  CheckSelected(e_Pi);
4684  return *static_cast<const TPi*>(m_object);
4685 }
4686 
4688 {