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

Go to the SVN repository for this file.

1 /* $Id$
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  */
27 
28 /// @file Rs_.hpp
29 /// Data storage class.
30 ///
31 /// This file was generated by application DATATOOL
32 /// using the following specifications:
33 /// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/docsum/docsum.asn">docsum.asn</a>
34 /// and additional tune-up parameters:
35 /// <a href="/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/docsum/docsum.def">docsum.def</a>
36 ///
37 /// ATTENTION:
38 /// Don't edit or commit this file into CVS as this file will
39 /// be overridden (by DATATOOL) without warning!
40 
41 #ifndef OBJECTS_DOCSUM_RS_BASE_HPP
42 #define OBJECTS_DOCSUM_RS_BASE_HPP
43 
44 // standard includes
45 #include <serial/serialbase.hpp>
46 
47 // generated includes
48 #include <list>
49 #include <string>
50 
52 
53 #ifndef BEGIN_objects_SCOPE
54 # define BEGIN_objects_SCOPE BEGIN_SCOPE(objects)
55 # define END_objects_SCOPE END_SCOPE(objects)
56 #endif
57 BEGIN_objects_SCOPE // namespace ncbi::objects::
58 
59 
60 // forward declarations
61 class CAssembly;
62 class CPrimarySequence;
63 class CRsLinkout;
64 class CRsStruct;
65 class CSs;
66 
67 
68 // generated classes
69 
70 
71 /** @addtogroup dataspec_Docsum_3_4
72  *
73  * @{
74  */
75 
76 /////////////////////////////////////////////////////////////////////////////
77 ///defines the docsum structure for refSNP clusters, where a refSNP
78 /// cluster (rs) is a grouping of individual dbSNP submissions that all refer to the
79 /// same variation. The refsnp provides a single unified record for annotation of NCBI
80 /// resources such as reference genome sequence.
81 ///
82 /// CRs_Base --
83 ///
84 
86 {
88 public:
89  // constructor
90  CRs_Base(void);
91  // destructor
92  virtual ~CRs_Base(void);
93 
94  // type info
96 
97  /////////////////////////////////////////////////////////////////////////////
98  ///
99  /// C_Attlist --
100  ///
101 
103  {
105  public:
106  // constructor
107  C_Attlist(void);
108  // destructor
109  ~C_Attlist(void);
110 
111  // type info
113 
115  eAttlist_snpClass_snp = 1,
116  eAttlist_snpClass_in_del = 2,
117  eAttlist_snpClass_heterozygous = 3,
118  eAttlist_snpClass_microsatellite = 4,
119  eAttlist_snpClass_named_locus = 5,
120  eAttlist_snpClass_no_variation = 6,
121  eAttlist_snpClass_mixed = 7,
122  eAttlist_snpClass_multinucleotide_polymorphism = 8
123  };
124 
125  /// Access to EAttlist_snpClass's attributes (values, names) as defined in spec
126  static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_snpClass)(void);
127 
129  eAttlist_snpType_notwithdrawn = 1,
130  eAttlist_snpType_artifact = 2,
131  eAttlist_snpType_gene_duplication = 3,
132  eAttlist_snpType_duplicate_submission = 4,
133  eAttlist_snpType_notspecified = 5,
134  eAttlist_snpType_ambiguous_location = 6,
135  eAttlist_snpType_low_map_quality = 7
136  };
137 
138  /// Access to EAttlist_snpType's attributes (values, names) as defined in spec
139  static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_snpType)(void);
140 
142  eAttlist_molType_genomic = 1,
143  eAttlist_molType_cDNA = 2,
144  eAttlist_molType_mito = 3,
145  eAttlist_molType_chloro = 4,
146  eAttlist_molType_unknown = 5
147  };
148 
149  /// Access to EAttlist_molType's attributes (values, names) as defined in spec
150  static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EAttlist_molType)(void);
151 
152  // types
153  typedef int TRsId;
157  typedef int TValidProbMin;
158  typedef int TValidProbMax;
159  typedef bool TGenotype;
160  typedef string TBitField;
161  typedef int TTaxId;
162 
163  // member index
164  enum class E_memberIndex {
165  e__allMandatory = 0,
166  e_rsId,
167  e_snpClass,
168  e_snpType,
169  e_molType,
170  e_validProbMin,
171  e_validProbMax,
172  e_genotype,
173  e_bitField,
174  e_taxId
175  };
177 
178  // getters
179  // setters
180 
181  ///refSNP (rs) number
182  /// Check if a value has been assigned to RsId data member.
183  ///
184  /// Data member RsId is mandatory;
185  /// its type is defined as 'typedef int TRsId'
186  /// @return
187  /// - true, if a value has been assigned.
188  /// - false, otherwise.
189  bool IsSetRsId(void) const;
190 
191  /// Check if it is safe to call GetRsId method.
192  ///
193  /// @return
194  /// - true, if the data member is getatable.
195  /// - false, otherwise.
196  bool CanGetRsId(void) const;
197 
198  /// Reset RsId data member.
199  void ResetRsId(void);
200 
201  /// Get the RsId member data.
202  ///
203  /// @return
204  /// Copy of the member data.
205  TRsId GetRsId(void) const;
206 
207  /// Assign a value to RsId data member.
208  ///
209  /// @param value
210  /// Value to assign
211  void SetRsId(TRsId value);
212 
213  /// Assign a value to RsId data member.
214  ///
215  /// @return
216  /// Reference to the data value.
217  TRsId& SetRsId(void);
218 
219  /// Check if a value has been assigned to SnpClass data member.
220  ///
221  /// Data member SnpClass is mandatory;
222  /// its type is defined as 'typedef EAttlist_snpClass TSnpClass'
223  /// @return
224  /// - true, if a value has been assigned.
225  /// - false, otherwise.
226  bool IsSetSnpClass(void) const;
227 
228  /// Check if it is safe to call GetSnpClass method.
229  ///
230  /// @return
231  /// - true, if the data member is getatable.
232  /// - false, otherwise.
233  bool CanGetSnpClass(void) const;
234 
235  /// Reset SnpClass data member.
236  void ResetSnpClass(void);
237 
238  /// Get the SnpClass member data.
239  ///
240  /// @return
241  /// Copy of the member data.
242  TSnpClass GetSnpClass(void) const;
243 
244  /// Assign a value to SnpClass data member.
245  ///
246  /// @param value
247  /// Value to assign
248  void SetSnpClass(TSnpClass value);
249 
250  /// Assign a value to SnpClass data member.
251  ///
252  /// @return
253  /// Reference to the data value.
254  TSnpClass& SetSnpClass(void);
255 
256  /// Check if a value has been assigned to SnpType data member.
257  ///
258  /// Data member SnpType is mandatory;
259  /// its type is defined as 'typedef EAttlist_snpType TSnpType'
260  /// @return
261  /// - true, if a value has been assigned.
262  /// - false, otherwise.
263  bool IsSetSnpType(void) const;
264 
265  /// Check if it is safe to call GetSnpType method.
266  ///
267  /// @return
268  /// - true, if the data member is getatable.
269  /// - false, otherwise.
270  bool CanGetSnpType(void) const;
271 
272  /// Reset SnpType data member.
273  void ResetSnpType(void);
274 
275  /// Get the SnpType member data.
276  ///
277  /// @return
278  /// Copy of the member data.
279  TSnpType GetSnpType(void) const;
280 
281  /// Assign a value to SnpType data member.
282  ///
283  /// @param value
284  /// Value to assign
285  void SetSnpType(TSnpType value);
286 
287  /// Assign a value to SnpType data member.
288  ///
289  /// @return
290  /// Reference to the data value.
291  TSnpType& SetSnpType(void);
292 
293  /// Check if a value has been assigned to MolType data member.
294  ///
295  /// Data member MolType is mandatory;
296  /// its type is defined as 'typedef EAttlist_molType TMolType'
297  /// @return
298  /// - true, if a value has been assigned.
299  /// - false, otherwise.
300  bool IsSetMolType(void) const;
301 
302  /// Check if it is safe to call GetMolType method.
303  ///
304  /// @return
305  /// - true, if the data member is getatable.
306  /// - false, otherwise.
307  bool CanGetMolType(void) const;
308 
309  /// Reset MolType data member.
310  void ResetMolType(void);
311 
312  /// Get the MolType member data.
313  ///
314  /// @return
315  /// Copy of the member data.
316  TMolType GetMolType(void) const;
317 
318  /// Assign a value to MolType data member.
319  ///
320  /// @param value
321  /// Value to assign
322  void SetMolType(TMolType value);
323 
324  /// Assign a value to MolType data member.
325  ///
326  /// @return
327  /// Reference to the data value.
328  TMolType& SetMolType(void);
329 
330  ///minimum reported success rate of all submissions in
331  /// cluster
332  /// Check if a value has been assigned to ValidProbMin data member.
333  ///
334  /// Data member ValidProbMin is optional;
335  /// its type is defined as 'typedef int TValidProbMin'
336  /// @return
337  /// - true, if a value has been assigned.
338  /// - false, otherwise.
339  bool IsSetValidProbMin(void) const;
340 
341  /// Check if it is safe to call GetValidProbMin method.
342  ///
343  /// @return
344  /// - true, if the data member is getatable.
345  /// - false, otherwise.
346  bool CanGetValidProbMin(void) const;
347 
348  /// Reset ValidProbMin data member.
349  void ResetValidProbMin(void);
350 
351  /// Get the ValidProbMin member data.
352  ///
353  /// @return
354  /// Copy of the member data.
355  TValidProbMin GetValidProbMin(void) const;
356 
357  /// Assign a value to ValidProbMin data member.
358  ///
359  /// @param value
360  /// Value to assign
361  void SetValidProbMin(TValidProbMin value);
362 
363  /// Assign a value to ValidProbMin data member.
364  ///
365  /// @return
366  /// Reference to the data value.
367  TValidProbMin& SetValidProbMin(void);
368 
369  ///maximum reported success rate of all submissions in
370  /// cluster
371  /// Check if a value has been assigned to ValidProbMax data member.
372  ///
373  /// Data member ValidProbMax is optional;
374  /// its type is defined as 'typedef int TValidProbMax'
375  /// @return
376  /// - true, if a value has been assigned.
377  /// - false, otherwise.
378  bool IsSetValidProbMax(void) const;
379 
380  /// Check if it is safe to call GetValidProbMax method.
381  ///
382  /// @return
383  /// - true, if the data member is getatable.
384  /// - false, otherwise.
385  bool CanGetValidProbMax(void) const;
386 
387  /// Reset ValidProbMax data member.
388  void ResetValidProbMax(void);
389 
390  /// Get the ValidProbMax member data.
391  ///
392  /// @return
393  /// Copy of the member data.
394  TValidProbMax GetValidProbMax(void) const;
395 
396  /// Assign a value to ValidProbMax data member.
397  ///
398  /// @param value
399  /// Value to assign
400  void SetValidProbMax(TValidProbMax value);
401 
402  /// Assign a value to ValidProbMax data member.
403  ///
404  /// @return
405  /// Reference to the data value.
406  TValidProbMax& SetValidProbMax(void);
407 
408  ///at least one genotype reported for this
409  /// refSNP
410  /// Check if a value has been assigned to Genotype data member.
411  ///
412  /// Data member Genotype is optional;
413  /// its type is defined as 'typedef bool TGenotype'
414  /// @return
415  /// - true, if a value has been assigned.
416  /// - false, otherwise.
417  bool IsSetGenotype(void) const;
418 
419  /// Check if it is safe to call GetGenotype method.
420  ///
421  /// @return
422  /// - true, if the data member is getatable.
423  /// - false, otherwise.
424  bool CanGetGenotype(void) const;
425 
426  /// Reset Genotype data member.
427  void ResetGenotype(void);
428 
429  /// Get the Genotype member data.
430  ///
431  /// @return
432  /// Copy of the member data.
433  TGenotype GetGenotype(void) const;
434 
435  /// Assign a value to Genotype data member.
436  ///
437  /// @param value
438  /// Value to assign
439  void SetGenotype(TGenotype value);
440 
441  /// Assign a value to Genotype data member.
442  ///
443  /// @return
444  /// Reference to the data value.
445  TGenotype& SetGenotype(void);
446 
447  /// Check if a value has been assigned to BitField data member.
448  ///
449  /// Data member BitField is optional;
450  /// its type is defined as 'typedef string TBitField'
451  /// @return
452  /// - true, if a value has been assigned.
453  /// - false, otherwise.
454  bool IsSetBitField(void) const;
455 
456  /// Check if it is safe to call GetBitField method.
457  ///
458  /// @return
459  /// - true, if the data member is getatable.
460  /// - false, otherwise.
461  bool CanGetBitField(void) const;
462 
463  /// Reset BitField data member.
464  void ResetBitField(void);
465 
466  /// Get the BitField member data.
467  ///
468  /// @return
469  /// Reference to the member data.
470  const TBitField& GetBitField(void) const;
471 
472  /// Assign a value to BitField data member.
473  ///
474  /// @param value
475  /// Value to assign
476  void SetBitField(const TBitField& value);
477  void SetBitField(TBitField&& value);
478 
479  /// Assign a value to BitField data member.
480  ///
481  /// @return
482  /// Reference to the data value.
483  TBitField& SetBitField(void);
484 
485  /// Check if a value has been assigned to TaxId data member.
486  ///
487  /// Data member TaxId is optional;
488  /// its type is defined as 'typedef int TTaxId'
489  /// @return
490  /// - true, if a value has been assigned.
491  /// - false, otherwise.
492  bool IsSetTaxId(void) const;
493 
494  /// Check if it is safe to call GetTaxId method.
495  ///
496  /// @return
497  /// - true, if the data member is getatable.
498  /// - false, otherwise.
499  bool CanGetTaxId(void) const;
500 
501  /// Reset TaxId data member.
502  void ResetTaxId(void);
503 
504  /// Get the TaxId member data.
505  ///
506  /// @return
507  /// Copy of the member data.
508  TTaxId GetTaxId(void) const;
509 
510  /// Assign a value to TaxId data member.
511  ///
512  /// @param value
513  /// Value to assign
514  void SetTaxId(TTaxId value);
515 
516  /// Assign a value to TaxId data member.
517  ///
518  /// @return
519  /// Reference to the data value.
520  TTaxId& SetTaxId(void);
521 
522  /// Reset the whole object
523  void Reset(void);
524 
525 
526  private:
527  // Prohibit copy constructor and assignment operator
530 
531  // data
532  Uint4 m_set_State[1];
533  int m_RsId;
540  string m_BitField;
541  int m_TaxId;
542  };
543  /////////////////////////////////////////////////////////////////////////////
544  ///
545  /// C_Het --
546  ///
547 
549  {
551  public:
552  // constructor
553  C_Het(void);
554  // destructor
555  ~C_Het(void);
556 
557  // type info
559 
560  /////////////////////////////////////////////////////////////////////////////
561  ///
562  /// C_Attlist --
563  ///
564 
566  {
568  public:
569  // constructor
570  C_Attlist(void);
571  // destructor
572  ~C_Attlist(void);
573 
574  // type info
576 
577  ///Est=Estimated average het from allele
578  /// frequencies, Obs=Observed from genotype data
580  eHet_attlist_type_est = 1,
581  eHet_attlist_type_obs = 2
582  };
583 
584  /// Access to EHet_attlist_type's attributes (values, names) as defined in spec
585  static const NCBI_NS_NCBI::CEnumeratedTypeValues* ENUM_METHOD_NAME(EHet_attlist_type)(void);
586 
587  // types
589  typedef double TValue;
590  typedef double TStdError;
591 
592  // member index
593  enum class E_memberIndex {
594  e__allMandatory = 0,
595  e_type,
596  e_value,
597  e_stdError
598  };
600 
601  // getters
602  // setters
603 
604  /// Check if a value has been assigned to Type data member.
605  ///
606  /// Data member Type is mandatory;
607  /// its type is defined as 'typedef EHet_attlist_type TType'
608  /// @return
609  /// - true, if a value has been assigned.
610  /// - false, otherwise.
611  bool IsSetType(void) const;
612 
613  /// Check if it is safe to call GetType method.
614  ///
615  /// @return
616  /// - true, if the data member is getatable.
617  /// - false, otherwise.
618  bool CanGetType(void) const;
619 
620  /// Reset Type data member.
621  void ResetType(void);
622 
623  /// Get the Type member data.
624  ///
625  /// @return
626  /// Copy of the member data.
627  TType GetType(void) const;
628 
629  /// Assign a value to Type data member.
630  ///
631  /// @param value
632  /// Value to assign
633  void SetType(TType value);
634 
635  /// Assign a value to Type data member.
636  ///
637  /// @return
638  /// Reference to the data value.
639  TType& SetType(void);
640 
641  ///Heterozygosity
642  /// Check if a value has been assigned to Value data member.
643  ///
644  /// Data member Value is mandatory;
645  /// its type is defined as 'typedef double TValue'
646  /// @return
647  /// - true, if a value has been assigned.
648  /// - false, otherwise.
649  bool IsSetValue(void) const;
650 
651  /// Check if it is safe to call GetValue method.
652  ///
653  /// @return
654  /// - true, if the data member is getatable.
655  /// - false, otherwise.
656  bool CanGetValue(void) const;
657 
658  /// Reset Value data member.
659  void ResetValue(void);
660 
661  /// Get the Value member data.
662  ///
663  /// @return
664  /// Copy of the member data.
665  TValue GetValue(void) const;
666 
667  /// Assign a value to Value data member.
668  ///
669  /// @param value
670  /// Value to assign
671  void SetValue(TValue value);
672 
673  /// Assign a value to Value data member.
674  ///
675  /// @return
676  /// Reference to the data value.
677  TValue& SetValue(void);
678 
679  ///Standard error of Het
680  /// estimate
681  /// Check if a value has been assigned to StdError data member.
682  ///
683  /// Data member StdError is optional;
684  /// its type is defined as 'typedef double TStdError'
685  /// @return
686  /// - true, if a value has been assigned.
687  /// - false, otherwise.
688  bool IsSetStdError(void) const;
689 
690  /// Check if it is safe to call GetStdError method.
691  ///
692  /// @return
693  /// - true, if the data member is getatable.
694  /// - false, otherwise.
695  bool CanGetStdError(void) const;
696 
697  /// Reset StdError data member.
698  void ResetStdError(void);
699 
700  /// Get the StdError member data.
701  ///
702  /// @return
703  /// Copy of the member data.
704  TStdError GetStdError(void) const;
705 
706  /// Assign a value to StdError data member.
707  ///
708  /// @param value
709  /// Value to assign
710  void SetStdError(TStdError value);
711 
712  /// Assign a value to StdError data member.
713  ///
714  /// @return
715  /// Reference to the data value.
716  TStdError& SetStdError(void);
717 
718  /// Reset the whole object
719  void Reset(void);
720 
721 
722  private:
723  // Prohibit copy constructor and assignment operator
726 
727  // data
728  Uint4 m_set_State[1];
730  double m_Value;
731  double m_StdError;
732  };
733  // types
735 
736  // member index
737  enum class E_memberIndex {
738  e__allMandatory = 0,
739  e_attlist,
740  e_het
741  };
743 
744  // getters
745  // setters
746 
747  /// Check if a value has been assigned to Attlist data member.
748  ///
749  /// Data member Attlist is mandatory;
750  /// its type is defined as 'typedef C_Attlist TAttlist'
751  /// @return
752  /// - true, if a value has been assigned.
753  /// - false, otherwise.
754  bool IsSetAttlist(void) const;
755 
756  /// Check if it is safe to call GetAttlist method.
757  ///
758  /// @return
759  /// - true, if the data member is getatable.
760  /// - false, otherwise.
761  bool CanGetAttlist(void) const;
762 
763  /// Reset Attlist data member.
764  void ResetAttlist(void);
765 
766  /// Get the Attlist member data.
767  ///
768  /// @return
769  /// Reference to the member data.
770  const TAttlist& GetAttlist(void) const;
771 
772  /// Assign a value to Attlist data member.
773  ///
774  /// @param value
775  /// Reference to value.
776  void SetAttlist(TAttlist& value);
777 
778  /// Assign a value to Attlist data member.
779  ///
780  /// @return
781  /// Reference to the data value.
782  TAttlist& SetAttlist(void);
783 
784  /// Check if a value has been assigned to Het data member.
785  ///
786  /// Data member Het is mandatory
787  /// @return
788  /// - true, if a value has been assigned.
789  /// - false, otherwise.
790  bool IsSetHet(void) const;
791 
792  /// Check if value of Het member is getatable.
793  ///
794  /// @return
795  /// - false; the data member of type 'NULL' has no value.
796  bool CanGetHet(void) const;
797 
798  /// Reset Het data member.
799  void ResetHet(void);
800 
801  /// Set NULL data member (assign 'NULL' value to Het data member).
802  void SetHet(void);
803 
804  /// Reset the whole object
805  void Reset(void);
806 
807 
808  private:
809  // Prohibit copy constructor and assignment operator
810  C_Het(const C_Het&);
812 
813  // data
814  Uint4 m_set_State[1];
816  };
817  /////////////////////////////////////////////////////////////////////////////
818  ///
819  /// C_Validation --
820  ///
821 
823  {
825  public:
826  // constructor
827  C_Validation(void);
828  // destructor
829  ~C_Validation(void);
830 
831  // type info
833 
834  /////////////////////////////////////////////////////////////////////////////
835  ///
836  /// C_Attlist --
837  ///
838 
840  {
842  public:
843  // constructor
844  C_Attlist(void);
845  // destructor
846  ~C_Attlist(void);
847 
848  // type info
850 
851  // types
852  typedef bool TByCluster;
853  typedef bool TByFrequency;
854  typedef bool TByOtherPop;
855  typedef bool TBy2Hit2Allele;
856  typedef bool TByHapMap;
857  typedef bool TBy1000G;
858  typedef bool TSuspect;
859 
860  // member index
861  enum class E_memberIndex {
862  e__allMandatory = 0,
863  e_byCluster,
864  e_byFrequency,
865  e_byOtherPop,
866  e_by2Hit2Allele,
867  e_byHapMap,
868  e_by1000G,
869  e_suspect
870  };
872 
873  // getters
874  // setters
875 
876  ///at least one subsnp in cluster has frequency data
877  /// submitted
878  /// Check if a value has been assigned to ByCluster data member.
879  ///
880  /// Data member ByCluster is optional;
881  /// its type is defined as 'typedef bool TByCluster'
882  /// @return
883  /// - true, if a value has been assigned.
884  /// - false, otherwise.
885  bool IsSetByCluster(void) const;
886 
887  /// Check if it is safe to call GetByCluster method.
888  ///
889  /// @return
890  /// - true, if the data member is getatable.
891  /// - false, otherwise.
892  bool CanGetByCluster(void) const;
893 
894  /// Reset ByCluster data member.
895  void ResetByCluster(void);
896 
897  /// Get the ByCluster member data.
898  ///
899  /// @return
900  /// Copy of the member data.
901  TByCluster GetByCluster(void) const;
902 
903  /// Assign a value to ByCluster data member.
904  ///
905  /// @param value
906  /// Value to assign
907  void SetByCluster(TByCluster value);
908 
909  /// Assign a value to ByCluster data member.
910  ///
911  /// @return
912  /// Reference to the data value.
913  TByCluster& SetByCluster(void);
914 
915  ///Validated by allele frequency
916  /// Check if a value has been assigned to ByFrequency data member.
917  ///
918  /// Data member ByFrequency is optional;
919  /// its type is defined as 'typedef bool TByFrequency'
920  /// @return
921  /// - true, if a value has been assigned.
922  /// - false, otherwise.
923  bool IsSetByFrequency(void) const;
924 
925  /// Check if it is safe to call GetByFrequency method.
926  ///
927  /// @return
928  /// - true, if the data member is getatable.
929  /// - false, otherwise.
930  bool CanGetByFrequency(void) const;
931 
932  /// Reset ByFrequency data member.
933  void ResetByFrequency(void);
934 
935  /// Get the ByFrequency member data.
936  ///
937  /// @return
938  /// Copy of the member data.
939  TByFrequency GetByFrequency(void) const;
940 
941  /// Assign a value to ByFrequency data member.
942  ///
943  /// @param value
944  /// Value to assign
945  void SetByFrequency(TByFrequency value);
946 
947  /// Assign a value to ByFrequency data member.
948  ///
949  /// @return
950  /// Reference to the data value.
951  TByFrequency& SetByFrequency(void);
952 
953  /// Check if a value has been assigned to ByOtherPop data member.
954  ///
955  /// Data member ByOtherPop is optional;
956  /// its type is defined as 'typedef bool TByOtherPop'
957  /// @return
958  /// - true, if a value has been assigned.
959  /// - false, otherwise.
960  bool IsSetByOtherPop(void) const;
961 
962  /// Check if it is safe to call GetByOtherPop method.
963  ///
964  /// @return
965  /// - true, if the data member is getatable.
966  /// - false, otherwise.
967  bool CanGetByOtherPop(void) const;
968 
969  /// Reset ByOtherPop data member.
970  void ResetByOtherPop(void);
971 
972  /// Get the ByOtherPop member data.
973  ///
974  /// @return
975  /// Copy of the member data.
976  TByOtherPop GetByOtherPop(void) const;
977 
978  /// Assign a value to ByOtherPop data member.
979  ///
980  /// @param value
981  /// Value to assign
982  void SetByOtherPop(TByOtherPop value);
983 
984  /// Assign a value to ByOtherPop data member.
985  ///
986  /// @return
987  /// Reference to the data value.
988  TByOtherPop& SetByOtherPop(void);
989 
990  ///cluster has 2+ submissions, with 1+ submissions
991  /// assayed with a non-computational method
992  /// Check if a value has been assigned to By2Hit2Allele data member.
993  ///
994  /// Data member By2Hit2Allele is optional;
995  /// its type is defined as 'typedef bool TBy2Hit2Allele'
996  /// @return
997  /// - true, if a value has been assigned.
998  /// - false, otherwise.
999  bool IsSetBy2Hit2Allele(void) const;
1000 
1001  /// Check if it is safe to call GetBy2Hit2Allele method.
1002  ///
1003  /// @return
1004  /// - true, if the data member is getatable.
1005  /// - false, otherwise.
1006  bool CanGetBy2Hit2Allele(void) const;
1007 
1008  /// Reset By2Hit2Allele data member.
1009  void ResetBy2Hit2Allele(void);
1010 
1011  /// Get the By2Hit2Allele member data.
1012  ///
1013  /// @return
1014  /// Copy of the member data.
1015  TBy2Hit2Allele GetBy2Hit2Allele(void) const;
1016 
1017  /// Assign a value to By2Hit2Allele data member.
1018  ///
1019  /// @param value
1020  /// Value to assign
1021  void SetBy2Hit2Allele(TBy2Hit2Allele value);
1022 
1023  /// Assign a value to By2Hit2Allele data member.
1024  ///
1025  /// @return
1026  /// Reference to the data value.
1027  TBy2Hit2Allele& SetBy2Hit2Allele(void);
1028 
1029  ///Validated by HapMap Project
1030  /// Check if a value has been assigned to ByHapMap data member.
1031  ///
1032  /// Data member ByHapMap is optional;
1033  /// its type is defined as 'typedef bool TByHapMap'
1034  /// @return
1035  /// - true, if a value has been assigned.
1036  /// - false, otherwise.
1037  bool IsSetByHapMap(void) const;
1038 
1039  /// Check if it is safe to call GetByHapMap method.
1040  ///
1041  /// @return
1042  /// - true, if the data member is getatable.
1043  /// - false, otherwise.
1044  bool CanGetByHapMap(void) const;
1045 
1046  /// Reset ByHapMap data member.
1047  void ResetByHapMap(void);
1048 
1049  /// Get the ByHapMap member data.
1050  ///
1051  /// @return
1052  /// Copy of the member data.
1053  TByHapMap GetByHapMap(void) const;
1054 
1055  /// Assign a value to ByHapMap data member.
1056  ///
1057  /// @param value
1058  /// Value to assign
1059  void SetByHapMap(TByHapMap value);
1060 
1061  /// Assign a value to ByHapMap data member.
1062  ///
1063  /// @return
1064  /// Reference to the data value.
1065  TByHapMap& SetByHapMap(void);
1066 
1067  ///Validated by 1000 Genomes Project
1068  /// Check if a value has been assigned to By1000G data member.
1069  ///
1070  /// Data member By1000G is optional;
1071  /// its type is defined as 'typedef bool TBy1000G'
1072  /// @return
1073  /// - true, if a value has been assigned.
1074  /// - false, otherwise.
1075  bool IsSetBy1000G(void) const;
1076 
1077  /// Check if it is safe to call GetBy1000G method.
1078  ///
1079  /// @return
1080  /// - true, if the data member is getatable.
1081  /// - false, otherwise.
1082  bool CanGetBy1000G(void) const;
1083 
1084  /// Reset By1000G data member.
1085  void ResetBy1000G(void);
1086 
1087  /// Get the By1000G member data.
1088  ///
1089  /// @return
1090  /// Copy of the member data.
1091  TBy1000G GetBy1000G(void) const;
1092 
1093  /// Assign a value to By1000G data member.
1094  ///
1095  /// @param value
1096  /// Value to assign
1097  void SetBy1000G(TBy1000G value);
1098 
1099  /// Assign a value to By1000G data member.
1100  ///
1101  /// @return
1102  /// Reference to the data value.
1103  TBy1000G& SetBy1000G(void);
1104 
1105  ///Suspected to be false SNP
1106  /// Check if a value has been assigned to Suspect data member.
1107  ///
1108  /// Data member Suspect is optional;
1109  /// its type is defined as 'typedef bool TSuspect'
1110  /// @return
1111  /// - true, if a value has been assigned.
1112  /// - false, otherwise.
1113  bool IsSetSuspect(void) const;
1114 
1115  /// Check if it is safe to call GetSuspect method.
1116  ///
1117  /// @return
1118  /// - true, if the data member is getatable.
1119  /// - false, otherwise.
1120  bool CanGetSuspect(void) const;
1121 
1122  /// Reset Suspect data member.
1123  void ResetSuspect(void);
1124 
1125  /// Get the Suspect member data.
1126  ///
1127  /// @return
1128  /// Copy of the member data.
1129  TSuspect GetSuspect(void) const;
1130 
1131  /// Assign a value to Suspect data member.
1132  ///
1133  /// @param value
1134  /// Value to assign
1135  void SetSuspect(TSuspect value);
1136 
1137  /// Assign a value to Suspect data member.
1138  ///
1139  /// @return
1140  /// Reference to the data value.
1141  TSuspect& SetSuspect(void);
1142 
1143  /// Reset the whole object
1144  void Reset(void);
1145 
1146 
1147  private:
1148  // Prohibit copy constructor and assignment operator
1151 
1152  // data
1153  Uint4 m_set_State[1];
1161  };
1162  // types
1164  typedef list< int > TOtherPopBatchId;
1165  typedef list< int > TTwoHit2AlleleBatchId;
1166  typedef list< int > TFrequencyClass;
1167  typedef list< int > THapMapPhase;
1168  typedef list< int > TTGPPhase;
1169  typedef list< string > TSuspectEvidence;
1170 
1171  // member index
1172  enum class E_memberIndex {
1173  e__allMandatory = 0,
1174  e_attlist,
1175  e_otherPopBatchId,
1176  e_twoHit2AlleleBatchId,
1177  e_frequencyClass,
1178  e_hapMapPhase,
1179  e_tGPPhase,
1180  e_suspectEvidence
1181  };
1183 
1184  // getters
1185  // setters
1186 
1187  /// Check if a value has been assigned to Attlist data member.
1188  ///
1189  /// Data member Attlist is mandatory;
1190  /// its type is defined as 'typedef C_Attlist TAttlist'
1191  /// @return
1192  /// - true, if a value has been assigned.
1193  /// - false, otherwise.
1194  bool IsSetAttlist(void) const;
1195 
1196  /// Check if it is safe to call GetAttlist method.
1197  ///
1198  /// @return
1199  /// - true, if the data member is getatable.
1200  /// - false, otherwise.
1201  bool CanGetAttlist(void) const;
1202 
1203  /// Reset Attlist data member.
1204  void ResetAttlist(void);
1205 
1206  /// Get the Attlist member data.
1207  ///
1208  /// @return
1209  /// Reference to the member data.
1210  const TAttlist& GetAttlist(void) const;
1211 
1212  /// Assign a value to Attlist data member.
1213  ///
1214  /// @param value
1215  /// Reference to value.
1216  void SetAttlist(TAttlist& value);
1217 
1218  /// Assign a value to Attlist data member.
1219  ///
1220  /// @return
1221  /// Reference to the data value.
1222  TAttlist& SetAttlist(void);
1223 
1224  ///dbSNP batch-id's for other pop snp validation
1225  /// data.
1226  /// Check if a value has been assigned to OtherPopBatchId data member.
1227  ///
1228  /// Data member OtherPopBatchId is optional;
1229  /// its type is defined as 'typedef list< int > TOtherPopBatchId'
1230  /// @return
1231  /// - true, if a value has been assigned.
1232  /// - false, otherwise.
1233  bool IsSetOtherPopBatchId(void) const;
1234 
1235  /// Check if it is safe to call GetOtherPopBatchId method.
1236  ///
1237  /// @return
1238  /// - true, if the data member is getatable.
1239  /// - false, otherwise.
1240  bool CanGetOtherPopBatchId(void) const;
1241 
1242  /// Reset OtherPopBatchId data member.
1243  void ResetOtherPopBatchId(void);
1244 
1245  /// Get the OtherPopBatchId member data.
1246  ///
1247  /// @return
1248  /// Reference to the member data.
1249  const TOtherPopBatchId& GetOtherPopBatchId(void) const;
1250 
1251  /// Assign a value to OtherPopBatchId data member.
1252  ///
1253  /// @return
1254  /// Reference to the data value.
1255  TOtherPopBatchId& SetOtherPopBatchId(void);
1256 
1257  ///dbSNP batch-id's for double-hit snp
1258  /// validation data. Use batch-id to get methods, etc.
1259  /// Check if a value has been assigned to TwoHit2AlleleBatchId data member.
1260  ///
1261  /// Data member TwoHit2AlleleBatchId is optional;
1262  /// its type is defined as 'typedef list< int > TTwoHit2AlleleBatchId'
1263  /// @return
1264  /// - true, if a value has been assigned.
1265  /// - false, otherwise.
1266  bool IsSetTwoHit2AlleleBatchId(void) const;
1267 
1268  /// Check if it is safe to call GetTwoHit2AlleleBatchId method.
1269  ///
1270  /// @return
1271  /// - true, if the data member is getatable.
1272  /// - false, otherwise.
1273  bool CanGetTwoHit2AlleleBatchId(void) const;
1274 
1275  /// Reset TwoHit2AlleleBatchId data member.
1276  void ResetTwoHit2AlleleBatchId(void);
1277 
1278  /// Get the TwoHit2AlleleBatchId member data.
1279  ///
1280  /// @return
1281  /// Reference to the member data.
1282  const TTwoHit2AlleleBatchId& GetTwoHit2AlleleBatchId(void) const;
1283 
1284  /// Assign a value to TwoHit2AlleleBatchId data member.
1285  ///
1286  /// @return
1287  /// Reference to the data value.
1288  TTwoHit2AlleleBatchId& SetTwoHit2AlleleBatchId(void);
1289 
1290  ///Frequency validation class (1) low frequency
1291  /// variation that is cited in journal and other reputable
1292  /// sources (2) greater than 5 percent minor allele freq in each
1293  /// and all populations (4) greater than 5 percent minor allele
1294  /// freq in 1+ populations (8) if the variant has 2+ minor
1295  /// allele count based on freq or genotype data (16) less than 1
1296  /// percent minor allele freq in each and all populations (32)
1297  /// less than 1 percent minor freq in 1+ populations
1298  /// Check if a value has been assigned to FrequencyClass data member.
1299  ///
1300  /// Data member FrequencyClass is optional;
1301  /// its type is defined as 'typedef list< int > TFrequencyClass'
1302  /// @return
1303  /// - true, if a value has been assigned.
1304  /// - false, otherwise.
1305  bool IsSetFrequencyClass(void) const;
1306 
1307  /// Check if it is safe to call GetFrequencyClass method.
1308  ///
1309  /// @return
1310  /// - true, if the data member is getatable.
1311  /// - false, otherwise.
1312  bool CanGetFrequencyClass(void) const;
1313 
1314  /// Reset FrequencyClass data member.
1315  void ResetFrequencyClass(void);
1316 
1317  /// Get the FrequencyClass member data.
1318  ///
1319  /// @return
1320  /// Reference to the member data.
1321  const TFrequencyClass& GetFrequencyClass(void) const;
1322 
1323  /// Assign a value to FrequencyClass data member.
1324  ///
1325  /// @return
1326  /// Reference to the data value.
1327  TFrequencyClass& SetFrequencyClass(void);
1328 
1329  ///alidated by HapMap Project phase1-genotyped
1330  /// (1), Phase 1 genotyped; filtered, non-redundant
1331  /// phase2-genotyped (2), Phase 2 genotyped; filtered,
1332  /// non-redundant phase3-genotyped (4) Phase 3 genotyped;
1333  /// filtered, non-redundant
1334  /// Check if a value has been assigned to HapMapPhase data member.
1335  ///
1336  /// Data member HapMapPhase is optional;
1337  /// its type is defined as 'typedef list< int > THapMapPhase'
1338  /// @return
1339  /// - true, if a value has been assigned.
1340  /// - false, otherwise.
1341  bool IsSetHapMapPhase(void) const;
1342 
1343  /// Check if it is safe to call GetHapMapPhase method.
1344  ///
1345  /// @return
1346  /// - true, if the data member is getatable.
1347  /// - false, otherwise.
1348  bool CanGetHapMapPhase(void) const;
1349 
1350  /// Reset HapMapPhase data member.
1351  void ResetHapMapPhase(void);
1352 
1353  /// Get the HapMapPhase member data.
1354  ///
1355  /// @return
1356  /// Reference to the member data.
1357  const THapMapPhase& GetHapMapPhase(void) const;
1358 
1359  /// Assign a value to HapMapPhase data member.
1360  ///
1361  /// @return
1362  /// Reference to the data value.
1363  THapMapPhase& SetHapMapPhase(void);
1364 
1365  ///Validated by 1000 Genomes Project (TGP) pilot
1366  /// 1 (1), pilot 2 (2), pilot 3 (4)
1367  /// Check if a value has been assigned to TGPPhase data member.
1368  ///
1369  /// Data member TGPPhase is optional;
1370  /// its type is defined as 'typedef list< int > TTGPPhase'
1371  /// @return
1372  /// - true, if a value has been assigned.
1373  /// - false, otherwise.
1374  bool IsSetTGPPhase(void) const;
1375 
1376  /// Check if it is safe to call GetTGPPhase method.
1377  ///
1378  /// @return
1379  /// - true, if the data member is getatable.
1380  /// - false, otherwise.
1381  bool CanGetTGPPhase(void) const;
1382 
1383  /// Reset TGPPhase data member.
1384  void ResetTGPPhase(void);
1385 
1386  /// Get the TGPPhase member data.
1387  ///
1388  /// @return
1389  /// Reference to the member data.
1390  const TTGPPhase& GetTGPPhase(void) const;
1391 
1392  /// Assign a value to TGPPhase data member.
1393  ///
1394  /// @return
1395  /// Reference to the data value.
1396  TTGPPhase& SetTGPPhase(void);
1397 
1398  ///Suspected to be false SNP evidence Single
1399  /// Nucleotide Difference - paralogous genes (1), Genotype or
1400  /// base calling errors (2), Submission evidence or errors (4),
1401  /// Others (8)
1402  /// Check if a value has been assigned to SuspectEvidence data member.
1403  ///
1404  /// Data member SuspectEvidence is optional;
1405  /// its type is defined as 'typedef list< string > TSuspectEvidence'
1406  /// @return
1407  /// - true, if a value has been assigned.
1408  /// - false, otherwise.
1409  bool IsSetSuspectEvidence(void) const;
1410 
1411  /// Check if it is safe to call GetSuspectEvidence method.
1412  ///
1413  /// @return
1414  /// - true, if the data member is getatable.
1415  /// - false, otherwise.
1416  bool CanGetSuspectEvidence(void) const;
1417 
1418  /// Reset SuspectEvidence data member.
1419  void ResetSuspectEvidence(void);
1420 
1421  /// Get the SuspectEvidence member data.
1422  ///
1423  /// @return
1424  /// Reference to the member data.
1425  const TSuspectEvidence& GetSuspectEvidence(void) const;
1426 
1427  /// Assign a value to SuspectEvidence data member.
1428  ///
1429  /// @return
1430  /// Reference to the data value.
1431  TSuspectEvidence& SetSuspectEvidence(void);
1432 
1433  /// Reset the whole object
1434  void Reset(void);
1435 
1436 
1437  private:
1438  // Prohibit copy constructor and assignment operator
1441 
1442  // data
1443  Uint4 m_set_State[1];
1445  list< int > m_OtherPopBatchId;
1447  list< int > m_FrequencyClass;
1448  list< int > m_HapMapPhase;
1449  list< int > m_TGPPhase;
1450  list< string > m_SuspectEvidence;
1451  };
1452  /////////////////////////////////////////////////////////////////////////////
1453  ///date the refsnp cluster was
1454  /// instantiated
1455  ///date the refsnp cluster was
1456  /// instantiated
1457  ///
1458  /// C_Create --
1459  ///
1460 
1462  {
1464  public:
1465  // constructor
1466  C_Create(void);
1467  // destructor
1468  ~C_Create(void);
1469 
1470  // type info
1472 
1473  /////////////////////////////////////////////////////////////////////////////
1474  ///
1475  /// C_Attlist --
1476  ///
1477 
1479  {
1481  public:
1482  // constructor
1483  C_Attlist(void);
1484  // destructor
1485  ~C_Attlist(void);
1486 
1487  // type info
1489 
1490  // types
1491  typedef int TBuild;
1492  typedef string TDate;
1493 
1494  // member index
1495  enum class E_memberIndex {
1496  e__allMandatory = 0,
1497  e_build,
1498  e_date
1499  };
1501 
1502  // getters
1503  // setters
1504 
1505  ///build number when the cluster was
1506  /// created
1507  /// Check if a value has been assigned to Build data member.
1508  ///
1509  /// Data member Build is optional;
1510  /// its type is defined as 'typedef int TBuild'
1511  /// @return
1512  /// - true, if a value has been assigned.
1513  /// - false, otherwise.
1514  bool IsSetBuild(void) const;
1515 
1516  /// Check if it is safe to call GetBuild method.
1517  ///
1518  /// @return
1519  /// - true, if the data member is getatable.
1520  /// - false, otherwise.
1521  bool CanGetBuild(void) const;
1522 
1523  /// Reset Build data member.
1524  void ResetBuild(void);
1525 
1526  /// Get the Build member data.
1527  ///
1528  /// @return
1529  /// Copy of the member data.
1530  TBuild GetBuild(void) const;
1531 
1532  /// Assign a value to Build data member.
1533  ///
1534  /// @param value
1535  /// Value to assign
1536  void SetBuild(TBuild value);
1537 
1538  /// Assign a value to Build data member.
1539  ///
1540  /// @return
1541  /// Reference to the data value.
1542  TBuild& SetBuild(void);
1543 
1544  ///yyyy-mm-dd
1545  /// Check if a value has been assigned to Date data member.
1546  ///
1547  /// Data member Date is optional;
1548  /// its type is defined as 'typedef string TDate'
1549  /// @return
1550  /// - true, if a value has been assigned.
1551  /// - false, otherwise.
1552  bool IsSetDate(void) const;
1553 
1554  /// Check if it is safe to call GetDate method.
1555  ///
1556  /// @return
1557  /// - true, if the data member is getatable.
1558  /// - false, otherwise.
1559  bool CanGetDate(void) const;
1560 
1561  /// Reset Date data member.
1562  void ResetDate(void);
1563 
1564  /// Get the Date member data.
1565  ///
1566  /// @return
1567  /// Reference to the member data.
1568  const TDate& GetDate(void) const;
1569 
1570  /// Assign a value to Date data member.
1571  ///
1572  /// @param value
1573  /// Value to assign
1574  void SetDate(const TDate& value);
1575  void SetDate(TDate&& value);
1576 
1577  /// Assign a value to Date data member.
1578  ///
1579  /// @return
1580  /// Reference to the data value.
1581  TDate& SetDate(void);
1582 
1583  /// Reset the whole object
1584  void Reset(void);
1585 
1586 
1587  private:
1588  // Prohibit copy constructor and assignment operator
1591 
1592  // data
1593  Uint4 m_set_State[1];
1594  int m_Build;
1595  string m_Date;
1596  };
1597  // types
1599 
1600  // member index
1601  enum class E_memberIndex {
1602  e__allMandatory = 0,
1603  e_attlist,
1604  e_create
1605  };
1607 
1608  // getters
1609  // setters
1610 
1611  /// Check if a value has been assigned to Attlist data member.
1612  ///
1613  /// Data member Attlist is mandatory;
1614  /// its type is defined as 'typedef C_Attlist TAttlist'
1615  /// @return
1616  /// - true, if a value has been assigned.
1617  /// - false, otherwise.
1618  bool IsSetAttlist(void) const;
1619 
1620  /// Check if it is safe to call GetAttlist method.
1621  ///
1622  /// @return
1623  /// - true, if the data member is getatable.
1624  /// - false, otherwise.
1625  bool CanGetAttlist(void) const;
1626 
1627  /// Reset Attlist data member.
1628  void ResetAttlist(void);
1629 
1630  /// Get the Attlist member data.
1631  ///
1632  /// @return
1633  /// Reference to the member data.
1634  const TAttlist& GetAttlist(void) const;
1635 
1636  /// Assign a value to Attlist data member.
1637  ///
1638  /// @param value
1639  /// Reference to value.
1640  void SetAttlist(TAttlist& value);
1641 
1642  /// Assign a value to Attlist data member.
1643  ///
1644  /// @return
1645  /// Reference to the data value.
1646  TAttlist& SetAttlist(void);
1647 
1648  ///date the refsnp cluster was
1649  /// instantiated
1650  /// Check if a value has been assigned to Create data member.
1651  ///
1652  /// Data member Create is mandatory
1653  /// @return
1654  /// - true, if a value has been assigned.
1655  /// - false, otherwise.
1656  bool IsSetCreate(void) const;
1657 
1658  /// Check if value of Create member is getatable.
1659  ///
1660  /// @return
1661  /// - false; the data member of type 'NULL' has no value.
1662  bool CanGetCreate(void) const;
1663 
1664  /// Reset Create data member.
1665  void ResetCreate(void);
1666 
1667  /// Set NULL data member (assign 'NULL' value to Create data member).
1668  void SetCreate(void);
1669 
1670  /// Reset the whole object
1671  void Reset(void);
1672 
1673 
1674  private:
1675  // Prohibit copy constructor and assignment operator
1678 
1679  // data
1680  Uint4 m_set_State[1];
1682  };
1683  /////////////////////////////////////////////////////////////////////////////
1684  ///most recent date the cluster was updated (member added or
1685  /// deleted)
1686  ///most recent date the cluster was updated (member added or
1687  /// deleted)
1688  ///
1689  /// C_Update --
1690  ///
1691 
1693  {
1695  public:
1696  // constructor
1697  C_Update(void);
1698  // destructor
1699  ~C_Update(void);
1700 
1701  // type info
1703 
1704  /////////////////////////////////////////////////////////////////////////////
1705  ///
1706  /// C_Attlist --
1707  ///
1708 
1710  {
1712  public:
1713  // constructor
1714  C_Attlist(void);
1715  // destructor
1716  ~C_Attlist(void);
1717 
1718  // type info
1720 
1721  // types
1722  typedef int TBuild;
1723  typedef string TDate;
1724 
1725  // member index
1726  enum class E_memberIndex {
1727  e__allMandatory = 0,
1728  e_build,
1729  e_date
1730  };
1732 
1733  // getters
1734  // setters
1735 
1736  ///build number when the cluster was
1737  /// updated
1738  /// Check if a value has been assigned to Build data member.
1739  ///
1740  /// Data member Build is optional;
1741  /// its type is defined as 'typedef int TBuild'
1742  /// @return
1743  /// - true, if a value has been assigned.
1744  /// - false, otherwise.
1745  bool IsSetBuild(void) const;
1746 
1747  /// Check if it is safe to call GetBuild method.
1748  ///
1749  /// @return
1750  /// - true, if the data member is getatable.
1751  /// - false, otherwise.
1752  bool CanGetBuild(void) const;
1753 
1754  /// Reset Build data member.
1755  void ResetBuild(void);
1756 
1757  /// Get the Build member data.
1758  ///
1759  /// @return
1760  /// Copy of the member data.
1761  TBuild GetBuild(void) const;
1762 
1763  /// Assign a value to Build data member.
1764  ///
1765  /// @param value
1766  /// Value to assign
1767  void SetBuild(TBuild value);
1768 
1769  /// Assign a value to Build data member.
1770  ///
1771  /// @return
1772  /// Reference to the data value.
1773  TBuild& SetBuild(void);
1774 
1775  ///yyyy-mm-dd
1776  /// Check if a value has been assigned to Date data member.
1777  ///
1778  /// Data member Date is optional;
1779  /// its type is defined as 'typedef string TDate'
1780  /// @return
1781  /// - true, if a value has been assigned.
1782  /// - false, otherwise.
1783  bool IsSetDate(void) const;
1784 
1785  /// Check if it is safe to call GetDate method.
1786  ///
1787  /// @return
1788  /// - true, if the data member is getatable.
1789  /// - false, otherwise.
1790  bool CanGetDate(void) const;
1791 
1792  /// Reset Date data member.
1793  void ResetDate(void);
1794 
1795  /// Get the Date member data.
1796  ///
1797  /// @return
1798  /// Reference to the member data.
1799  const TDate& GetDate(void) const;
1800 
1801  /// Assign a value to Date data member.
1802  ///
1803  /// @param value
1804  /// Value to assign
1805  void SetDate(const TDate& value);
1806  void SetDate(TDate&& value);
1807 
1808  /// Assign a value to Date data member.
1809  ///
1810  /// @return
1811  /// Reference to the data value.
1812  TDate& SetDate(void);
1813 
1814  /// Reset the whole object
1815  void Reset(void);
1816 
1817 
1818  private:
1819  // Prohibit copy constructor and assignment operator
1822 
1823  // data
1824  Uint4 m_set_State[1];
1825  int m_Build;
1826  string m_Date;
1827  };
1828  // types
1830 
1831  // member index
1832  enum class E_memberIndex {
1833  e__allMandatory = 0,
1834  e_attlist,
1835  e_update
1836  };
1838 
1839  // getters
1840  // setters
1841 
1842  /// Check if a value has been assigned to Attlist data member.
1843  ///
1844  /// Data member Attlist is mandatory;
1845  /// its type is defined as 'typedef C_Attlist TAttlist'
1846  /// @return
1847  /// - true, if a value has been assigned.
1848  /// - false, otherwise.
1849  bool IsSetAttlist(void) const;
1850 
1851  /// Check if it is safe to call GetAttlist method.
1852  ///
1853  /// @return
1854  /// - true, if the data member is getatable.
1855  /// - false, otherwise.
1856  bool CanGetAttlist(void) const;
1857 
1858  /// Reset Attlist data member.
1859  void ResetAttlist(void);
1860 
1861  /// Get the Attlist member data.
1862  ///
1863  /// @return
1864  /// Reference to the member data.
1865  const TAttlist& GetAttlist(void) const;
1866 
1867  /// Assign a value to Attlist data member.
1868  ///
1869  /// @param value
1870  /// Reference to value.
1871  void SetAttlist(TAttlist& value);
1872 
1873  /// Assign a value to Attlist data member.
1874  ///
1875  /// @return
1876  /// Reference to the data value.
1877  TAttlist& SetAttlist(void);
1878 
1879  ///most recent date the cluster was updated (member added or
1880  /// deleted)
1881  /// Check if a value has been assigned to Update data member.
1882  ///
1883  /// Data member Update is mandatory
1884  /// @return
1885  /// - true, if a value has been assigned.
1886  /// - false, otherwise.
1887  bool IsSetUpdate(void) const;
1888 
1889  /// Check if value of Update member is getatable.
1890  ///
1891  /// @return
1892  /// - false; the data member of type 'NULL' has no value.
1893  bool CanGetUpdate(void) const;
1894 
1895  /// Reset Update data member.
1896  void ResetUpdate(void);
1897 
1898  /// Set NULL data member (assign 'NULL' value to Update data member).
1899  void SetUpdate(void);
1900 
1901  /// Reset the whole object
1902  void Reset(void);
1903 
1904 
1905  private:
1906  // Prohibit copy constructor and assignment operator
1909 
1910  // data
1911  Uint4 m_set_State[1];
1913  };
1914  /////////////////////////////////////////////////////////////////////////////
1915  ///
1916  /// C_Sequence --
1917  ///
1918 
1920  {
1922  public:
1923  // constructor
1924  C_Sequence(void);
1925  // destructor
1926  ~C_Sequence(void);
1927 
1928  // type info
1930 
1931  /////////////////////////////////////////////////////////////////////////////
1932  ///
1933  /// C_Attlist --
1934  ///
1935 
1937  {
1939  public:
1940  // constructor
1941  C_Attlist(void);
1942  // destructor
1943  ~C_Attlist(void);
1944 
1945  // type info
1947 
1948  // types
1950  typedef string TAncestralAllele;
1951 
1952  // member index
1953  enum class E_memberIndex {
1954  e__allMandatory = 0,
1955  e_exemplarSs,
1956  e_ancestralAllele
1957  };
1959 
1960  // getters
1961  // setters
1962 
1963  ///dbSNP ss# selected as source of refSNP flanking
1964  /// sequence, ss# part of ss-list below
1965  /// Check if a value has been assigned to ExemplarSs data member.
1966  ///
1967  /// Data member ExemplarSs is mandatory;
1968  /// its type is defined as 'typedef Int8 TExemplarSs'
1969  /// @return
1970  /// - true, if a value has been assigned.
1971  /// - false, otherwise.
1972  bool IsSetExemplarSs(void) const;
1973 
1974  /// Check if it is safe to call GetExemplarSs method.
1975  ///
1976  /// @return
1977  /// - true, if the data member is getatable.
1978  /// - false, otherwise.
1979  bool CanGetExemplarSs(void) const;
1980 
1981  /// Reset ExemplarSs data member.
1982  void ResetExemplarSs(void);
1983 
1984  /// Get the ExemplarSs member data.
1985  ///
1986  /// @return
1987  /// Copy of the member data.
1988  TExemplarSs GetExemplarSs(void) const;
1989 
1990  /// Assign a value to ExemplarSs data member.
1991  ///
1992  /// @param value
1993  /// Value to assign
1994  void SetExemplarSs(TExemplarSs value);
1995 
1996  /// Assign a value to ExemplarSs data member.
1997  ///
1998  /// @return
1999  /// Reference to the data value.
2000  TExemplarSs& SetExemplarSs(void);
2001 
2002  /// Check if a value has been assigned to AncestralAllele data member.
2003  ///
2004  /// Data member AncestralAllele is optional;
2005  /// its type is defined as 'typedef string TAncestralAllele'
2006  /// @return
2007  /// - true, if a value has been assigned.
2008  /// - false, otherwise.
2009  bool IsSetAncestralAllele(void) const;
2010 
2011  /// Check if it is safe to call GetAncestralAllele method.
2012  ///
2013  /// @return
2014  /// - true, if the data member is getatable.
2015  /// - false, otherwise.
2016  bool CanGetAncestralAllele(void) const;
2017 
2018  /// Reset AncestralAllele data member.
2019  void ResetAncestralAllele(void);
2020 
2021  /// Get the AncestralAllele member data.
2022  ///
2023  /// @return
2024  /// Reference to the member data.
2025  const TAncestralAllele& GetAncestralAllele(void) const;
2026 
2027  /// Assign a value to AncestralAllele data member.
2028  ///
2029  /// @param value
2030  /// Value to assign
2031  void SetAncestralAllele(const TAncestralAllele& value);
2032  void SetAncestralAllele(TAncestralAllele&& value);
2033 
2034  /// Assign a value to AncestralAllele data member.
2035  ///
2036  /// @return
2037  /// Reference to the data value.
2038  TAncestralAllele& SetAncestralAllele(void);
2039 
2040  /// Reset the whole object
2041  void Reset(void);
2042 
2043 
2044  private:
2045  // Prohibit copy constructor and assignment operator
2048 
2049  // data
2050  Uint4 m_set_State[1];
2053  };
2054  // types
2056  typedef string TSeq5;
2057  typedef string TObserved;
2058  typedef string TSeq3;
2059 
2060  // member index
2061  enum class E_memberIndex {
2062  e__allMandatory = 0,
2063  e_attlist,
2064  e_seq5,
2065  e_observed,
2066  e_seq3
2067  };
2069 
2070  // getters
2071  // setters
2072 
2073  /// Check if a value has been assigned to Attlist data member.
2074  ///
2075  /// Data member Attlist is mandatory;
2076  /// its type is defined as 'typedef C_Attlist TAttlist'
2077  /// @return
2078  /// - true, if a value has been assigned.
2079  /// - false, otherwise.
2080  bool IsSetAttlist(void) const;
2081 
2082  /// Check if it is safe to call GetAttlist method.
2083  ///
2084  /// @return
2085  /// - true, if the data member is getatable.
2086  /// - false, otherwise.
2087  bool CanGetAttlist(void) const;
2088 
2089  /// Reset Attlist data member.
2090  void ResetAttlist(void);
2091 
2092  /// Get the Attlist member data.
2093  ///
2094  /// @return
2095  /// Reference to the member data.
2096  const TAttlist& GetAttlist(void) const;
2097 
2098  /// Assign a value to Attlist data member.
2099  ///
2100  /// @param value
2101  /// Reference to value.
2102  void SetAttlist(TAttlist& value);
2103 
2104  /// Assign a value to Attlist data member.
2105  ///
2106  /// @return
2107  /// Reference to the data value.
2108  TAttlist& SetAttlist(void);
2109 
2110  ///5' sequence that flanks the
2111  /// variation
2112  /// Check if a value has been assigned to Seq5 data member.
2113  ///
2114  /// Data member Seq5 is optional;
2115  /// its type is defined as 'typedef string TSeq5'
2116  /// @return
2117  /// - true, if a value has been assigned.
2118  /// - false, otherwise.
2119  bool IsSetSeq5(void) const;
2120 
2121  /// Check if it is safe to call GetSeq5 method.
2122  ///
2123  /// @return
2124  /// - true, if the data member is getatable.
2125  /// - false, otherwise.
2126  bool CanGetSeq5(void) const;
2127 
2128  /// Reset Seq5 data member.
2129  void ResetSeq5(void);
2130 
2131  /// Get the Seq5 member data.
2132  ///
2133  /// @return
2134  /// Reference to the member data.
2135  const TSeq5& GetSeq5(void) const;
2136 
2137  /// Assign a value to Seq5 data member.
2138  ///
2139  /// @param value
2140  /// Value to assign
2141  void SetSeq5(const TSeq5& value);
2142  void SetSeq5(TSeq5&& value);
2143 
2144  /// Assign a value to Seq5 data member.
2145  ///
2146  /// @return
2147  /// Reference to the data value.
2148  TSeq5& SetSeq5(void);
2149 
2150  ///list of all nucleotide alleles observed in
2151  /// ss-list members, correcting for reverse complementation of
2152  /// members reported in reverse orientation
2153  /// Check if a value has been assigned to Observed data member.
2154  ///
2155  /// Data member Observed is mandatory;
2156  /// its type is defined as 'typedef string TObserved'
2157  /// @return
2158  /// - true, if a value has been assigned.
2159  /// - false, otherwise.
2160  bool IsSetObserved(void) const;
2161 
2162  /// Check if it is safe to call GetObserved method.
2163  ///
2164  /// @return
2165  /// - true, if the data member is getatable.
2166  /// - false, otherwise.
2167  bool CanGetObserved(void) const;
2168 
2169  /// Reset Observed data member.
2170  void ResetObserved(void);
2171 
2172  /// Get the Observed member data.
2173  ///
2174  /// @return
2175  /// Reference to the member data.
2176  const TObserved& GetObserved(void) const;
2177 
2178  /// Assign a value to Observed data member.
2179  ///
2180  /// @param value
2181  /// Value to assign
2182  void SetObserved(const TObserved& value);
2183  void SetObserved(TObserved&& value);
2184 
2185  /// Assign a value to Observed data member.
2186  ///
2187  /// @return
2188  /// Reference to the data value.
2189  TObserved& SetObserved(void);
2190 
2191  ///3' sequence that flanks the
2192  /// variation
2193  /// Check if a value has been assigned to Seq3 data member.
2194  ///
2195  /// Data member Seq3 is optional;
2196  /// its type is defined as 'typedef string TSeq3'
2197  /// @return
2198  /// - true, if a value has been assigned.
2199  /// - false, otherwise.
2200  bool IsSetSeq3(void) const;
2201 
2202  /// Check if it is safe to call GetSeq3 method.
2203  ///
2204  /// @return
2205  /// - true, if the data member is getatable.
2206  /// - false, otherwise.
2207  bool CanGetSeq3(void) const;
2208 
2209  /// Reset Seq3 data member.
2210  void ResetSeq3(void);
2211 
2212  /// Get the Seq3 member data.
2213  ///
2214  /// @return
2215  /// Reference to the member data.
2216  const TSeq3& GetSeq3(void) const;
2217 
2218  /// Assign a value to Seq3 data member.
2219  ///
2220  /// @param value
2221  /// Value to assign
2222  void SetSeq3(const TSeq3& value);
2223  void SetSeq3(TSeq3&& value);
2224 
2225  /// Assign a value to Seq3 data member.
2226  ///
2227  /// @return
2228  /// Reference to the data value.
2229  TSeq3& SetSeq3(void);
2230 
2231  /// Reset the whole object
2232  void Reset(void);
2233 
2234 
2235  private:
2236  // Prohibit copy constructor and assignment operator
2239 
2240  // data
2241  Uint4 m_set_State[1];
2243  string m_Seq5;
2244  string m_Observed;
2245  string m_Seq3;
2246  };
2247  /////////////////////////////////////////////////////////////////////////////
2248  ///
2249  /// C_E_MergeHistory --
2250  ///
2251 
2253  {
2255  public:
2256  // constructor
2257  C_E_MergeHistory(void);
2258  // destructor
2259  ~C_E_MergeHistory(void);
2260 
2261  // type info
2263 
2264  /////////////////////////////////////////////////////////////////////////////
2265  ///
2266  /// C_Attlist --
2267  ///
2268 
2270  {
2272  public:
2273  // constructor
2274  C_Attlist(void);
2275  // destructor
2276  ~C_Attlist(void);
2277 
2278  // type info
2280 
2281  // types
2282  typedef int TRsId;
2283  typedef int TBuildId;
2284  typedef bool TOrientFlip;
2285 
2286  // member index
2287  enum class E_memberIndex {
2288  e__allMandatory = 0,
2289  e_rsId,
2290  e_buildId,
2291  e_orientFlip
2292  };
2294 
2295  // getters
2296  // setters
2297 
2298  ///previously issued rs id whose member assays have
2299  /// now been merged
2300  /// Check if a value has been assigned to RsId data member.
2301  ///
2302  /// Data member RsId is mandatory;
2303  /// its type is defined as 'typedef int TRsId'
2304  /// @return
2305  /// - true, if a value has been assigned.
2306  /// - false, otherwise.
2307  bool IsSetRsId(void) const;
2308 
2309  /// Check if it is safe to call GetRsId method.
2310  ///
2311  /// @return
2312  /// - true, if the data member is getatable.
2313  /// - false, otherwise.
2314  bool CanGetRsId(void) const;
2315 
2316  /// Reset RsId data member.
2317  void ResetRsId(void);
2318 
2319  /// Get the RsId member data.
2320  ///
2321  /// @return
2322  /// Copy of the member data.
2323  TRsId GetRsId(void) const;
2324 
2325  /// Assign a value to RsId data member.
2326  ///
2327  /// @param value
2328  /// Value to assign
2329  void SetRsId(TRsId value);
2330 
2331  /// Assign a value to RsId data member.
2332  ///
2333  /// @return
2334  /// Reference to the data value.
2335  TRsId& SetRsId(void);
2336 
2337  ///build id when rs id was merged into parent
2338  /// rs
2339  /// Check if a value has been assigned to BuildId data member.
2340  ///
2341  /// Data member BuildId is optional;
2342  /// its type is defined as 'typedef int TBuildId'
2343  /// @return
2344  /// - true, if a value has been assigned.
2345  /// - false, otherwise.
2346  bool IsSetBuildId(void) const;
2347 
2348  /// Check if it is safe to call GetBuildId method.
2349  ///
2350  /// @return
2351  /// - true, if the data member is getatable.
2352  /// - false, otherwise.
2353  bool CanGetBuildId(void) const;
2354 
2355  /// Reset BuildId data member.
2356  void ResetBuildId(void);
2357 
2358  /// Get the BuildId member data.
2359  ///
2360  /// @return
2361  /// Copy of the member data.
2362  TBuildId GetBuildId(void) const;
2363 
2364  /// Assign a value to BuildId data member.
2365  ///
2366  /// @param value
2367  /// Value to assign
2368  void SetBuildId(TBuildId value);
2369 
2370  /// Assign a value to BuildId data member.
2371  ///
2372  /// @return
2373  /// Reference to the data value.
2374  TBuildId& SetBuildId(void);
2375 
2376  ///TRUE if strand of rs id is reverse to parent
2377  /// object's current strand
2378  /// Check if a value has been assigned to OrientFlip data member.
2379  ///
2380  /// Data member OrientFlip is optional;
2381  /// its type is defined as 'typedef bool TOrientFlip'
2382  /// @return
2383  /// - true, if a value has been assigned.
2384  /// - false, otherwise.
2385  bool IsSetOrientFlip(void) const;
2386 
2387  /// Check if it is safe to call GetOrientFlip method.
2388  ///
2389  /// @return
2390  /// - true, if the data member is getatable.
2391  /// - false, otherwise.
2392  bool CanGetOrientFlip(void) const;
2393 
2394  /// Reset OrientFlip data member.
2395  void ResetOrientFlip(void);
2396 
2397  /// Get the OrientFlip member data.
2398  ///
2399  /// @return
2400  /// Copy of the member data.
2401  TOrientFlip GetOrientFlip(void) const;
2402 
2403  /// Assign a value to OrientFlip data member.
2404  ///
2405  /// @param value
2406  /// Value to assign
2407  void SetOrientFlip(TOrientFlip value);
2408 
2409  /// Assign a value to OrientFlip data member.
2410  ///
2411  /// @return
2412  /// Reference to the data value.
2413  TOrientFlip& SetOrientFlip(void);
2414 
2415  /// Reset the whole object
2416  void Reset(void);
2417 
2418 
2419  private:
2420  // Prohibit copy constructor and assignment operator
2423 
2424  // data
2425  Uint4 m_set_State[1];
2426  int m_RsId;
2429  };
2430  // types
2432 
2433  // member index
2434  enum class E_memberIndex {
2435  e__allMandatory = 0,
2436  e_attlist,
2437  e_mergeHistory
2438  };
2440 
2441  // getters
2442  // setters
2443 
2444  /// Check if a value has been assigned to Attlist data member.
2445  ///
2446  /// Data member Attlist is mandatory;
2447  /// its type is defined as 'typedef C_Attlist TAttlist'
2448  /// @return
2449  /// - true, if a value has been assigned.
2450  /// - false, otherwise.
2451  bool IsSetAttlist(void) const;
2452 
2453  /// Check if it is safe to call GetAttlist method.
2454  ///
2455  /// @return
2456  /// - true, if the data member is getatable.
2457  /// - false, otherwise.
2458  bool CanGetAttlist(void) const;
2459 
2460  /// Reset Attlist data member.
2461  void ResetAttlist(void);
2462 
2463  /// Get the Attlist member data.
2464  ///
2465  /// @return
2466  /// Reference to the member data.
2467  const TAttlist& GetAttlist(void) const;
2468 
2469  /// Assign a value to Attlist data member.
2470  ///
2471  /// @param value
2472  /// Reference to value.
2473  void SetAttlist(TAttlist& value);
2474 
2475  /// Assign a value to Attlist data member.
2476  ///
2477  /// @return
2478  /// Reference to the data value.
2479  TAttlist& SetAttlist(void);
2480 
2481  /// Check if a value has been assigned to MergeHistory data member.
2482  ///
2483  /// Data member MergeHistory is mandatory
2484  /// @return
2485  /// - true, if a value has been assigned.
2486  /// - false, otherwise.
2487  bool IsSetMergeHistory(void) const;
2488 
2489  /// Check if value of MergeHistory member is getatable.
2490  ///
2491  /// @return
2492  /// - false; the data member of type 'NULL' has no value.
2493  bool CanGetMergeHistory(void) const;
2494 
2495  /// Reset MergeHistory data member.
2496  void ResetMergeHistory(void);
2497 
2498  /// Set NULL data member (assign 'NULL' value to MergeHistory data member).
2499  void SetMergeHistory(void);
2500 
2501  /// Reset the whole object
2502  void Reset(void);
2503 
2504 
2505  private:
2506  // Prohibit copy constructor and assignment operator
2509 
2510  // data
2511  Uint4 m_set_State[1];
2513  };
2514  /////////////////////////////////////////////////////////////////////////////
2515  ///
2516  /// C_E_AlleleOrigin --
2517  ///
2518 
2520  {
2522  public:
2523  // constructor
2524  C_E_AlleleOrigin(void);
2525  // destructor
2526  ~C_E_AlleleOrigin(void);
2527 
2528  // type info
2530 
2531  /////////////////////////////////////////////////////////////////////////////
2532  ///
2533  /// C_Attlist --
2534  ///
2535 
2537  {
2539  public:
2540  // constructor
2541  C_Attlist(void);
2542  // destructor
2543  ~C_Attlist(void);
2544 
2545  // type info
2547 
2548  // types
2549  typedef string TAllele;
2550 
2551  // member index
2552  enum class E_memberIndex {
2553  e__allMandatory = 0,
2554  e_allele
2555  };
2557 
2558  // getters
2559  // setters
2560 
2561  /// Check if a value has been assigned to Allele data member.
2562  ///
2563  /// Data member Allele is optional;
2564  /// its type is defined as 'typedef string TAllele'
2565  /// @return
2566  /// - true, if a value has been assigned.
2567  /// - false, otherwise.
2568  bool IsSetAllele(void) const;
2569 
2570  /// Check if it is safe to call GetAllele method.
2571  ///
2572  /// @return
2573  /// - true, if the data member is getatable.
2574  /// - false, otherwise.
2575  bool CanGetAllele(void) const;
2576 
2577  /// Reset Allele data member.
2578  void ResetAllele(void);
2579 
2580  /// Get the Allele member data.
2581  ///
2582  /// @return
2583  /// Reference to the member data.
2584  const TAllele& GetAllele(void) const;
2585 
2586  /// Assign a value to Allele data member.
2587  ///
2588  /// @param value
2589  /// Value to assign
2590  void SetAllele(const TAllele& value);
2591  void SetAllele(TAllele&& value);
2592 
2593  /// Assign a value to Allele data member.
2594  ///
2595  /// @return
2596  /// Reference to the data value.
2597  TAllele& SetAllele(void);
2598 
2599  /// Reset the whole object
2600  void Reset(void);
2601 
2602 
2603  private:
2604  // Prohibit copy constructor and assignment operator
2607 
2608  // data
2609  Uint4 m_set_State[1];
2610  string m_Allele;
2611  };
2612  // types
2614  typedef int TAlleleOrigin;
2615 
2616  // member index
2617  enum class E_memberIndex {
2618  e__allMandatory = 0,
2619  e_attlist,
2620  e_alleleOrigin
2621  };
2623 
2624  // getters
2625  // setters
2626 
2627  /// Check if a value has been assigned to Attlist data member.
2628  ///
2629  /// Data member Attlist is mandatory;
2630  /// its type is defined as 'typedef C_Attlist TAttlist'
2631  /// @return
2632  /// - true, if a value has been assigned.
2633  /// - false, otherwise.
2634  bool IsSetAttlist(void) const;
2635 
2636  /// Check if it is safe to call GetAttlist method.
2637  ///
2638  /// @return
2639  /// - true, if the data member is getatable.
2640  /// - false, otherwise.
2641  bool CanGetAttlist(void) const;
2642 
2643  /// Reset Attlist data member.
2644  void ResetAttlist(void);
2645 
2646  /// Get the Attlist member data.
2647  ///
2648  /// @return
2649  /// Reference to the member data.
2650  const TAttlist& GetAttlist(void) const;
2651 
2652  /// Assign a value to Attlist data member.
2653  ///
2654  /// @param value
2655  /// Reference to value.
2656  void SetAttlist(TAttlist& value);
2657 
2658  /// Assign a value to Attlist data member.
2659  ///
2660  /// @return
2661  /// Reference to the data value.
2662  TAttlist& SetAttlist(void);
2663 
2664  /// origin of this allele, if known
2665  /// note that these are powers-of-two, and represent bits; thus, we can
2666  /// represent more than one state simultaneously through a bitwise OR
2667  /// unknown (0),
2668  /// germline (1),
2669  /// somatic (2),
2670  /// inherited (4),
2671  /// paternal (8),
2672  /// maternal (16),
2673  /// de-novo (32),
2674  /// biparental (64),
2675  /// uniparental (128),
2676  /// not-tested (256),
2677  /// tested-inconclusive (512),
2678  /// Check if a value has been assigned to AlleleOrigin data member.
2679  ///
2680  /// Data member AlleleOrigin is mandatory;
2681  /// its type is defined as 'typedef int TAlleleOrigin'
2682  /// @return
2683  /// - true, if a value has been assigned.
2684  /// - false, otherwise.
2685  bool IsSetAlleleOrigin(void) const;
2686 
2687  /// Check if it is safe to call GetAlleleOrigin method.
2688  ///
2689  /// @return
2690  /// - true, if the data member is getatable.
2691  /// - false, otherwise.
2692  bool CanGetAlleleOrigin(void) const;
2693 
2694  /// Reset AlleleOrigin data member.
2695  void ResetAlleleOrigin(void);
2696 
2697  /// Get the AlleleOrigin member data.
2698  ///
2699  /// @return
2700  /// Copy of the member data.
2701  TAlleleOrigin GetAlleleOrigin(void) const;
2702 
2703  /// Assign a value to AlleleOrigin data member.
2704  ///
2705  /// @param value
2706  /// Value to assign
2707  void SetAlleleOrigin(TAlleleOrigin value);
2708 
2709  /// Assign a value to AlleleOrigin data member.
2710  ///
2711  /// @return
2712  /// Reference to the data value.
2713  TAlleleOrigin& SetAlleleOrigin(void);
2714 
2715  /// Reset the whole object
2716  void Reset(void);
2717 
2718 
2719  private:
2720  // Prohibit copy constructor and assignment operator
2723 
2724  // data
2725  Uint4 m_set_State[1];
2728  };
2729  /////////////////////////////////////////////////////////////////////////////
2730  ///
2731  /// C_E_Phenotype --
2732  ///
2733 
2735  {
2737  public:
2738  // constructor
2739  C_E_Phenotype(void);
2740  // destructor
2741  ~C_E_Phenotype(void);
2742 
2743  // type info
2745 
2746  // types
2747  typedef list< string > TClinicalSignificance;
2748 
2749  // member index
2750  enum class E_memberIndex {
2751  e__allMandatory = 0,
2752  e_clinicalSignificance
2753  };
2755 
2756  // getters
2757  // setters
2758 
2759  /// unknown (0),
2760  /// untested (1),
2761  /// non-pathogenic (2),
2762  /// probable-non-pathogenic (3),
2763  /// probable-pathogenic (4),
2764  /// pathogenic (5),
2765  /// drug response (6),
2766  /// other (255)
2767  /// Check if a value has been assigned to ClinicalSignificance data member.
2768  ///
2769  /// Data member ClinicalSignificance is optional;
2770  /// its type is defined as 'typedef list< string > TClinicalSignificance'
2771  /// @return
2772  /// - true, if a value has been assigned.
2773  /// - false, otherwise.
2774  bool IsSetClinicalSignificance(void) const;
2775 
2776  /// Check if it is safe to call GetClinicalSignificance method.
2777  ///
2778  /// @return
2779  /// - true, if the data member is getatable.
2780  /// - false, otherwise.
2781  bool CanGetClinicalSignificance(void) const;
2782 
2783  /// Reset ClinicalSignificance data member.
2784  void ResetClinicalSignificance(void);
2785 
2786  /// Get the ClinicalSignificance member data.
2787  ///
2788  /// @return
2789  /// Reference to the member data.
2790  const TClinicalSignificance& GetClinicalSignificance(void) const;
2791 
2792  /// Assign a value to ClinicalSignificance data member.
2793  ///
2794  /// @return
2795  /// Reference to the data value.
2796  TClinicalSignificance& SetClinicalSignificance(void);
2797 
2798  /// Reset the whole object
2799  void Reset(void);
2800 
2801 
2802  private:
2803  // Prohibit copy constructor and assignment operator
2806 
2807  // data
2808  Uint4 m_set_State[1];
2809  list< string > m_ClinicalSignificance;
2810  };
2811  /////////////////////////////////////////////////////////////////////////////
2812  ///
2813  /// C_E_BioSource --
2814  ///
2815 
2817  {
2819  public:
2820  // constructor
2821  C_E_BioSource(void);
2822  // destructor
2823  ~C_E_BioSource(void);
2824 
2825  // type info
2827 
2828  // types
2829  typedef list< string > TGenome;
2830  typedef list< string > TOrigin;
2831 
2832  // member index
2833  enum class E_memberIndex {
2834  e__allMandatory = 0,
2835  e_genome,
2836  e_origin
2837  };
2839 
2840  // getters
2841  // setters
2842 
2843  /// unknown (0) ,
2844  /// genomic (1) ,
2845  /// chloroplast (2) ,
2846  /// chromoplast (3) ,
2847  /// kinetoplast (4) ,
2848  /// mitochondrion (5) ,
2849  /// plastid (6) ,
2850  /// macronuclear (7) ,
2851  /// extrachrom (8) ,
2852  /// plasmid (9) ,
2853  /// transposon (10) ,
2854  /// insertion-seq (11) ,
2855  /// cyanelle (12) ,
2856  /// proviral (13) ,
2857  /// virion (14) ,
2858  /// nucleomorph (15) ,
2859  /// apicoplast (16) ,
2860  /// leucoplast (17) ,
2861  /// proplastid (18) ,
2862  /// endogenous-virus (19) ,
2863  /// hydrogenosome (20) ,
2864  /// chromosome (21) ,
2865  /// chromatophore (22)
2866  /// Check if a value has been assigned to Genome data member.
2867  ///
2868  /// Data member Genome is optional;
2869  /// its type is defined as 'typedef list< string > TGenome'
2870  /// @return
2871  /// - true, if a value has been assigned.
2872  /// - false, otherwise.
2873  bool IsSetGenome(void) const;
2874 
2875  /// Check if it is safe to call GetGenome method.
2876  ///
2877  /// @return
2878  /// - true, if the data member is getatable.
2879  /// - false, otherwise.
2880  bool CanGetGenome(void) const;
2881 
2882  /// Reset Genome data member.
2883  void ResetGenome(void);
2884 
2885  /// Get the Genome member data.
2886  ///
2887  /// @return
2888  /// Reference to the member data.
2889  const TGenome& GetGenome(void) const;
2890 
2891  /// Assign a value to Genome data member.
2892  ///
2893  /// @return
2894  /// Reference to the data value.
2895  TGenome& SetGenome(void);
2896 
2897  /// unknown (0) ,
2898  /// natural (1) , normal biological entity
2899  /// natmut (2) , naturally occurring mutant
2900  /// mut (3) , artificially mutagenized
2901  /// artificial (4) , artificially engineered
2902  /// synthetic (5) , purely synthetic
2903  /// other (255)
2904  /// Check if a value has been assigned to Origin data member.
2905  ///
2906  /// Data member Origin is optional;
2907  /// its type is defined as 'typedef list< string > TOrigin'
2908  /// @return
2909  /// - true, if a value has been assigned.
2910  /// - false, otherwise.
2911  bool IsSetOrigin(void) const;
2912 
2913  /// Check if it is safe to call GetOrigin method.
2914  ///
2915  /// @return
2916  /// - true, if the data member is getatable.
2917  /// - false, otherwise.
2918  bool CanGetOrigin(void) const;
2919 
2920  /// Reset Origin data member.
2921  void ResetOrigin(void);
2922 
2923  /// Get the Origin member data.
2924  ///
2925  /// @return
2926  /// Reference to the member data.
2927  const TOrigin& GetOrigin(void) const;
2928 
2929  /// Assign a value to Origin data member.
2930  ///
2931  /// @return
2932  /// Reference to the data value.
2933  TOrigin& SetOrigin(void);
2934 
2935  /// Reset the whole object
2936  void Reset(void);
2937 
2938 
2939  private:
2940  // Prohibit copy constructor and assignment operator
2943 
2944  // data
2945  Uint4 m_set_State[1];
2946  list< string > m_Genome;
2947  list< string > m_Origin;
2948  };
2949  /////////////////////////////////////////////////////////////////////////////
2950  ///
2951  /// C_E_Frequency --
2952  ///
2953 
2955  {
2957  public:
2958  // constructor
2959  C_E_Frequency(void);
2960  // destructor
2961  ~C_E_Frequency(void);
2962 
2963  // type info
2965 
2966  /////////////////////////////////////////////////////////////////////////////
2967  ///
2968  /// C_Attlist --
2969  ///
2970 
2972  {
2974  public:
2975  // constructor
2976  C_Attlist(void);
2977  // destructor
2978  ~C_Attlist(void);
2979 
2980  // type info
2982 
2983  // types
2984  typedef double TFreq;
2985  typedef string TAllele;
2986  typedef int TPopId;
2987  typedef int TSampleSize;
2988 
2989  // member index
2990  enum class E_memberIndex {
2991  e__allMandatory = 0,
2992  e_freq,
2993  e_allele,
2994  e_popId,
2995  e_sampleSize
2996  };
2998 
2999  // getters
3000  // setters
3001 
3002  /// Check if a value has been assigned to Freq data member.
3003  ///
3004  /// Data member Freq is optional;
3005  /// its type is defined as 'typedef double TFreq'
3006  /// @return
3007  /// - true, if a value has been assigned.
3008  /// - false, otherwise.
3009  bool IsSetFreq(void) const;
3010 
3011  /// Check if it is safe to call GetFreq method.
3012  ///
3013  /// @return
3014  /// - true, if the data member is getatable.
3015  /// - false, otherwise.
3016  bool CanGetFreq(void) const;
3017 
3018  /// Reset Freq data member.
3019  void ResetFreq(void);
3020 
3021  /// Get the Freq member data.
3022  ///
3023  /// @return
3024  /// Copy of the member data.
3025  TFreq GetFreq(void) const;
3026 
3027  /// Assign a value to Freq data member.
3028  ///
3029  /// @param value
3030  /// Value to assign
3031  void SetFreq(TFreq value);
3032 
3033  /// Assign a value to Freq data member.
3034  ///
3035  /// @return
3036  /// Reference to the data value.
3037  TFreq& SetFreq(void);
3038 
3039  /// Check if a value has been assigned to Allele data member.
3040  ///
3041  /// Data member Allele is optional;
3042  /// its type is defined as 'typedef string TAllele'
3043  /// @return
3044  /// - true, if a value has been assigned.
3045  /// - false, otherwise.
3046  bool IsSetAllele(void) const;
3047 
3048  /// Check if it is safe to call GetAllele method.
3049  ///
3050  /// @return
3051  /// - true, if the data member is getatable.
3052  /// - false, otherwise.
3053  bool CanGetAllele(void) const;
3054 
3055  /// Reset Allele data member.
3056  void ResetAllele(void);
3057 
3058  /// Get the Allele member data.
3059  ///
3060  /// @return
3061  /// Reference to the member data.
3062  const TAllele& GetAllele(void) const;
3063 
3064  /// Assign a value to Allele data member.
3065  ///
3066  /// @param value
3067  /// Value to assign
3068  void SetAllele(const TAllele& value);
3069  void SetAllele(TAllele&& value);
3070 
3071  /// Assign a value to Allele data member.
3072  ///
3073  /// @return
3074  /// Reference to the data value.
3075  TAllele& SetAllele(void);
3076 
3077  ///dbSNP Populaton ID
3078  /// Check if a value has been assigned to PopId data member.
3079  ///
3080  /// Data member PopId is optional;
3081  /// its type is defined as 'typedef int TPopId'
3082  /// @return
3083  /// - true, if a value has been assigned.
3084  /// - false, otherwise.
3085  bool IsSetPopId(void) const;
3086 
3087  /// Check if it is safe to call GetPopId method.
3088  ///
3089  /// @return
3090  /// - true, if the data member is getatable.
3091  /// - false, otherwise.
3092  bool CanGetPopId(void) const;
3093 
3094  /// Reset PopId data member.
3095  void ResetPopId(void);
3096 
3097  /// Get the PopId member data.
3098  ///
3099  /// @return
3100  /// Copy of the member data.
3101  TPopId GetPopId(void) const;
3102 
3103  /// Assign a value to PopId data member.
3104  ///
3105  /// @param value
3106  /// Value to assign
3107  void SetPopId(TPopId value);
3108 
3109  /// Assign a value to PopId data member.
3110  ///
3111  /// @return
3112  /// Reference to the data value.
3113  TPopId& SetPopId(void);
3114 
3115  /// Check if a value has been assigned to SampleSize data member.
3116  ///
3117  /// Data member SampleSize is optional;
3118  /// its type is defined as 'typedef int TSampleSize'
3119  /// @return
3120  /// - true, if a value has been assigned.
3121  /// - false, otherwise.
3122  bool IsSetSampleSize(void) const;
3123 
3124  /// Check if it is safe to call GetSampleSize method.
3125  ///
3126  /// @return
3127  /// - true, if the data member is getatable.
3128  /// - false, otherwise.
3129  bool CanGetSampleSize(void) const;
3130 
3131  /// Reset SampleSize data member.
3132  void ResetSampleSize(void);
3133 
3134  /// Get the SampleSize member data.
3135  ///
3136  /// @return
3137  /// Copy of the member data.
3138  TSampleSize GetSampleSize(void) const;
3139 
3140  /// Assign a value to SampleSize data member.
3141  ///
3142  /// @param value
3143  /// Value to assign
3144  void SetSampleSize(TSampleSize value);
3145 
3146  /// Assign a value to SampleSize data member.
3147  ///
3148  /// @return
3149  /// Reference to the data value.
3150  TSampleSize& SetSampleSize(void);
3151 
3152  /// Reset the whole object
3153  void Reset(void);
3154 
3155 
3156  private:
3157  // Prohibit copy constructor and assignment operator
3160 
3161  // data
3162  Uint4 m_set_State[1];
3163  double m_Freq;
3164  string m_Allele;
3165  int m_PopId;
3167  };
3168  // types
3170 
3171  // member index
3172  enum class E_memberIndex {
3173  e__allMandatory = 0,
3174  e_attlist,
3175  e_frequency
3176  };
3178 
3179  // getters
3180  // setters
3181 
3182  /// Check if a value has been assigned to Attlist data member.
3183  ///
3184  /// Data member Attlist is mandatory;
3185  /// its type is defined as 'typedef C_Attlist TAttlist'
3186  /// @return
3187  /// - true, if a value has been assigned.
3188  /// - false, otherwise.
3189  bool IsSetAttlist(void) const;
3190 
3191  /// Check if it is safe to call GetAttlist method.
3192  ///
3193  /// @return
3194  /// - true, if the data member is getatable.
3195  /// - false, otherwise.
3196  bool CanGetAttlist(void) const;
3197 
3198  /// Reset Attlist data member.
3199  void ResetAttlist(void);
3200 
3201  /// Get the Attlist member data.
3202  ///
3203  /// @return
3204  /// Reference to the member data.
3205  const TAttlist& GetAttlist(void) const;
3206 
3207  /// Assign a value to Attlist data member.
3208  ///
3209  /// @param value
3210  /// Reference to value.
3211  void SetAttlist(TAttlist& value);
3212 
3213  /// Assign a value to Attlist data member.
3214  ///
3215  /// @return
3216  /// Reference to the data value.
3217  TAttlist& SetAttlist(void);
3218 
3219  /// Check if a value has been assigned to Frequency data member.
3220  ///
3221  /// Data member Frequency is mandatory
3222  /// @return
3223  /// - true, if a value has been assigned.
3224  /// - false, otherwise.
3225  bool IsSetFrequency(void) const;
3226 
3227  /// Check if value of Frequency member is getatable.
3228  ///
3229  /// @return
3230  /// - false; the data member of type 'NULL' has no value.
3231  bool CanGetFrequency(void) const;
3232 
3233  /// Reset Frequency data member.
3234  void ResetFrequency(void);
3235 
3236  /// Set NULL data member (assign 'NULL' value to Frequency data member).
3237  void SetFrequency(void);
3238 
3239  /// Reset the whole object
3240  void Reset(void);
3241 
3242 
3243  private:
3244  // Prohibit copy constructor and assignment operator
3247 
3248  // data
3249  Uint4 m_set_State[1];
3251  };
3252  // types
3254  typedef C_Het THet;
3259  typedef list< CRef< CSs > > TSs;
3260  typedef list< CRef< CAssembly > > TAssembly;
3261  typedef list< CRef< CPrimarySequence > > TPrimarySequence;
3262  typedef list< CRef< CRsStruct > > TRsStruct;
3263  typedef list< CRef< CRsLinkout > > TRsLinkout;
3265  typedef list< CRef< C_E_MergeHistory > > TMergeHistory;
3266  typedef list< string > THgvs;
3267  typedef list< CRef< C_E_AlleleOrigin > > TAlleleOrigin;
3268  typedef list< CRef< C_E_Phenotype > > TPhenotype;
3269  typedef list< CRef< C_E_BioSource > > TBioSource;
3270  typedef list< CRef< C_E_Frequency > > TFrequency;
3271 
3272  // member index
3273  enum class E_memberIndex {
3274  e__allMandatory = 0,
3275  e_attlist,
3276  e_het,
3277  e_validation,
3278  e_create,
3279  e_update,
3280  e_sequence,
3281  e_ss,
3282  e_assembly,
3283  e_primarySequence,
3284  e_rsStruct,
3285  e_rsLinkout,
3286  e_mergeHistory,
3287  e_hgvs,
3288  e_alleleOrigin,
3289  e_phenotype,
3290  e_bioSource,
3291  e_frequency
3292  };
3294 
3295  // getters
3296  // setters
3297 
3298  /// Check if a value has been assigned to Attlist data member.
3299  ///
3300  /// Data member Attlist is mandatory;
3301  /// its type is defined as 'typedef C_Attlist TAttlist'
3302  /// @return
3303  /// - true, if a value has been assigned.
3304  /// - false, otherwise.
3305  bool IsSetAttlist(void) const;
3306 
3307  /// Check if it is safe to call GetAttlist method.
3308  ///
3309  /// @return
3310  /// - true, if the data member is getatable.
3311  /// - false, otherwise.
3312  bool CanGetAttlist(void) const;
3313 
3314  /// Reset Attlist data member.
3315  void ResetAttlist(void);
3316 
3317  /// Get the Attlist member data.
3318  ///
3319  /// @return
3320  /// Reference to the member data.
3321  const TAttlist& GetAttlist(void) const;
3322 
3323  /// Assign a value to Attlist data member.
3324  ///
3325  /// @param value
3326  /// Reference to value.
3327  void SetAttlist(TAttlist& value);
3328 
3329  /// Assign a value to Attlist data member.
3330  ///
3331  /// @return
3332  /// Reference to the data value.
3333  TAttlist& SetAttlist(void);
3334 
3335  /// Check if a value has been assigned to Het data member.
3336  ///
3337  /// Data member Het is optional;
3338  /// its type is defined as 'typedef C_Het THet'
3339  /// @return
3340  /// - true, if a value has been assigned.
3341  /// - false, otherwise.
3342  bool IsSetHet(void) const;
3343 
3344  /// Check if it is safe to call GetHet method.
3345  ///
3346  /// @return
3347  /// - true, if the data member is getatable.
3348  /// - false, otherwise.
3349  bool CanGetHet(void) const;
3350 
3351  /// Reset Het data member.
3352  void ResetHet(void);
3353 
3354  /// Get the Het member data.
3355  ///
3356  /// @return
3357  /// Reference to the member data.
3358  const THet& GetHet(void) const;
3359 
3360  /// Assign a value to Het data member.
3361  ///
3362  /// @param value
3363  /// Reference to value.
3364  void SetHet(THet& value);
3365 
3366  /// Assign a value to Het data member.
3367  ///
3368  /// @return
3369  /// Reference to the data value.
3370  THet& SetHet(void);
3371 
3372  /// Check if a value has been assigned to Validation data member.
3373  ///
3374  /// Data member Validation is mandatory;
3375  /// its type is defined as 'typedef C_Validation TValidation'
3376  /// @return
3377  /// - true, if a value has been assigned.
3378  /// - false, otherwise.
3379  bool IsSetValidation(void) const;
3380 
3381  /// Check if it is safe to call GetValidation method.
3382  ///
3383  /// @return
3384  /// - true, if the data member is getatable.
3385  /// - false, otherwise.
3386  bool CanGetValidation(void) const;
3387 
3388  /// Reset Validation data member.
3389  void ResetValidation(void);
3390 
3391  /// Get the Validation member data.
3392  ///
3393  /// @return
3394  /// Reference to the member data.
3395  const TValidation& GetValidation(void) const;
3396 
3397  /// Assign a value to Validation data member.
3398  ///
3399  /// @param value
3400  /// Reference to value.
3401  void SetValidation(TValidation& value);
3402 
3403  /// Assign a value to Validation data member.
3404  ///
3405  /// @return
3406  /// Reference to the data value.
3407  TValidation& SetValidation(void);
3408 
3409  /// Check if a value has been assigned to Create data member.
3410  ///
3411  /// Data member Create is mandatory;
3412  /// its type is defined as 'typedef C_Create TCreate'
3413  /// @return
3414  /// - true, if a value has been assigned.
3415  /// - false, otherwise.
3416  bool IsSetCreate(void) const;
3417 
3418  /// Check if it is safe to call GetCreate method.
3419  ///
3420  /// @return
3421  /// - true, if the data member is getatable.
3422  /// - false, otherwise.
3423  bool CanGetCreate(void) const;
3424 
3425  /// Reset Create data member.
3426  void ResetCreate(void);
3427 
3428  /// Get the Create member data.
3429  ///
3430  /// @return
3431  /// Reference to the member data.
3432  const TCreate& GetCreate(void) const;
3433 
3434  /// Assign a value to Create data member.
3435  ///
3436  /// @param value
3437  /// Reference to value.
3438  void SetCreate(TCreate& value);
3439 
3440  /// Assign a value to Create data member.
3441  ///
3442  /// @return
3443  /// Reference to the data value.
3444  TCreate& SetCreate(void);
3445 
3446  /// Check if a value has been assigned to Update data member.
3447  ///
3448  /// Data member Update is optional;
3449  /// its type is defined as 'typedef C_Update TUpdate'
3450  /// @return
3451  /// - true, if a value has been assigned.
3452  /// - false, otherwise.
3453  bool IsSetUpdate(void) const;
3454 
3455  /// Check if it is safe to call GetUpdate method.
3456  ///
3457  /// @return
3458  /// - true, if the data member is getatable.
3459  /// - false, otherwise.
3460  bool CanGetUpdate(void) const;
3461 
3462  /// Reset Update data member.
3463  void ResetUpdate(void);
3464 
3465  /// Get the Update member data.
3466  ///
3467  /// @return
3468  /// Reference to the member data.
3469  const TUpdate& GetUpdate(void) const;
3470 
3471  /// Assign a value to Update data member.
3472  ///
3473  /// @param value
3474  /// Reference to value.
3475  void SetUpdate(TUpdate& value);
3476 
3477  /// Assign a value to Update data member.
3478  ///
3479  /// @return
3480  /// Reference to the data value.
3481  TUpdate& SetUpdate(void);
3482 
3483  /// Check if a value has been assigned to Sequence data member.
3484  ///
3485  /// Data member Sequence is mandatory;
3486  /// its type is defined as 'typedef C_Sequence TSequence'
3487  /// @return
3488  /// - true, if a value has been assigned.
3489  /// - false, otherwise.
3490  bool IsSetSequence(void) const;
3491 
3492  /// Check if it is safe to call GetSequence method.
3493  ///
3494  /// @return
3495  /// - true, if the data member is getatable.
3496  /// - false, otherwise.
3497  bool CanGetSequence(void) const;
3498 
3499  /// Reset Sequence data member.
3500  void ResetSequence(void);
3501 
3502  /// Get the Sequence member data.
3503  ///
3504  /// @return
3505  /// Reference to the member data.
3506  const TSequence& GetSequence(void) const;
3507 
3508  /// Assign a value to Sequence data member.
3509  ///
3510  /// @param value
3511  /// Reference to value.
3512  void SetSequence(TSequence& value);
3513 
3514  /// Assign a value to Sequence data member.
3515  ///
3516  /// @return
3517  /// Reference to the data value.
3518  TSequence& SetSequence(void);
3519 
3520  /// Check if a value has been assigned to Ss data member.
3521  ///
3522  /// Data member Ss is mandatory;
3523  /// its type is defined as 'typedef list< CRef< CSs > > TSs'
3524  /// @return
3525  /// - true, if a value has been assigned.
3526  /// - false, otherwise.
3527  bool IsSetSs(void) const;
3528 
3529  /// Check if it is safe to call GetSs method.
3530  ///
3531  /// @return
3532  /// - true, if the data member is getatable.
3533  /// - false, otherwise.
3534  bool CanGetSs(void) const;
3535 
3536  /// Reset Ss data member.
3537  void ResetSs(void);
3538 
3539  /// Get the Ss member data.
3540  ///
3541  /// @return
3542  /// Reference to the member data.
3543  const TSs& GetSs(void) const;
3544 
3545  /// Assign a value to Ss data member.
3546  ///
3547  /// @return
3548  /// Reference to the data value.
3549  TSs& SetSs(void);
3550 
3551  /// Check if a value has been assigned to Assembly data member.
3552  ///
3553  /// Data member Assembly is optional;
3554  /// its type is defined as 'typedef list< CRef< CAssembly > > TAssembly'
3555  /// @return
3556  /// - true, if a value has been assigned.
3557  /// - false, otherwise.
3558  bool IsSetAssembly(void) const;
3559 
3560  /// Check if it is safe to call GetAssembly method.
3561  ///
3562  /// @return
3563  /// - true, if the data member is getatable.
3564  /// - false, otherwise.
3565  bool CanGetAssembly(void) const;
3566 
3567  /// Reset Assembly data member.
3568  void ResetAssembly(void);
3569 
3570  /// Get the Assembly member data.
3571  ///
3572  /// @return
3573  /// Reference to the member data.
3574  const TAssembly& GetAssembly(void) const;
3575 
3576  /// Assign a value to Assembly data member.
3577  ///
3578  /// @return
3579  /// Reference to the data value.
3580  TAssembly& SetAssembly(void);
3581 
3582  /// Check if a value has been assigned to PrimarySequence data member.
3583  ///
3584  /// Data member PrimarySequence is optional;
3585  /// its type is defined as 'typedef list< CRef< CPrimarySequence > > TPrimarySequence'
3586  /// @return
3587  /// - true, if a value has been assigned.
3588  /// - false, otherwise.
3589  bool IsSetPrimarySequence(void) const;
3590 
3591  /// Check if it is safe to call GetPrimarySequence method.
3592  ///
3593  /// @return
3594  /// - true, if the data member is getatable.
3595  /// - false, otherwise.
3596  bool CanGetPrimarySequence(void) const;
3597 
3598  /// Reset PrimarySequence data member.
3599  void ResetPrimarySequence(void);
3600 
3601  /// Get the PrimarySequence member data.
3602  ///
3603  /// @return
3604  /// Reference to the member data.
3605  const TPrimarySequence& GetPrimarySequence(void) const;
3606 
3607  /// Assign a value to PrimarySequence data member.
3608  ///
3609  /// @return
3610  /// Reference to the data value.
3611  TPrimarySequence& SetPrimarySequence(void);
3612 
3613  /// Check if a value has been assigned to RsStruct data member.
3614  ///
3615  /// Data member RsStruct is optional;
3616  /// its type is defined as 'typedef list< CRef< CRsStruct > > TRsStruct'
3617  /// @return
3618  /// - true, if a value has been assigned.
3619  /// - false, otherwise.
3620  bool IsSetRsStruct(void) const;
3621 
3622  /// Check if it is safe to call GetRsStruct method.
3623  ///
3624  /// @return
3625  /// - true, if the data member is getatable.
3626  /// - false, otherwise.
3627  bool CanGetRsStruct(void) const;
3628 
3629  /// Reset RsStruct data member.
3630  void ResetRsStruct(void);
3631 
3632  /// Get the RsStruct member data.
3633  ///
3634  /// @return
3635  /// Reference to the member data.
3636  const TRsStruct& GetRsStruct(void) const;
3637 
3638  /// Assign a value to RsStruct data member.
3639  ///
3640  /// @return
3641  /// Reference to the data value.
3642  TRsStruct& SetRsStruct(void);
3643 
3644  /// Check if a value has been assigned to RsLinkout data member.
3645  ///
3646  /// Data member RsLinkout is optional;
3647  /// its type is defined as 'typedef list< CRef< CRsLinkout > > TRsLinkout'
3648  /// @return
3649  /// - true, if a value has been assigned.
3650  /// - false, otherwise.
3651  bool IsSetRsLinkout(void) const;
3652 
3653  /// Check if it is safe to call GetRsLinkout method.
3654  ///
3655  /// @return
3656  /// - true, if the data member is getatable.
3657  /// - false, otherwise.
3658  bool CanGetRsLinkout(void) const;
3659 
3660  /// Reset RsLinkout data member.
3661  void ResetRsLinkout(void);
3662 
3663  /// Get the RsLinkout member data.
3664  ///
3665  /// @return
3666  /// Reference to the member data.
3667  const TRsLinkout& GetRsLinkout(void) const;
3668 
3669  /// Assign a value to RsLinkout data member.
3670  ///
3671  /// @return
3672  /// Reference to the data value.
3673  TRsLinkout& SetRsLinkout(void);
3674 
3675  /// Check if a value has been assigned to MergeHistory data member.
3676  ///
3677  /// Data member MergeHistory is optional;
3678  /// its type is defined as 'typedef list< CRef< C_E_MergeHistory > > TMergeHistory'
3679  /// @return
3680  /// - true, if a value has been assigned.
3681  /// - false, otherwise.
3682  bool IsSetMergeHistory(void) const;
3683 
3684  /// Check if it is safe to call GetMergeHistory method.
3685  ///
3686  /// @return
3687  /// - true, if the data member is getatable.
3688  /// - false, otherwise.
3689  bool CanGetMergeHistory(void) const;
3690 
3691  /// Reset MergeHistory data member.
3692  void ResetMergeHistory(void);
3693 
3694  /// Get the MergeHistory member data.
3695  ///
3696  /// @return
3697  /// Reference to the member data.
3698  const TMergeHistory& GetMergeHistory(void) const;
3699 
3700  /// Assign a value to MergeHistory data member.
3701  ///
3702  /// @return
3703  /// Reference to the data value.
3704  TMergeHistory& SetMergeHistory(void);
3705 
3706  /// HGVS name list
3707  /// Check if a value has been assigned to Hgvs data member.
3708  ///
3709  /// Data member Hgvs is optional;
3710  /// its type is defined as 'typedef list< string > THgvs'
3711  /// @return
3712  /// - true, if a value has been assigned.
3713  /// - false, otherwise.
3714  bool IsSetHgvs(void) const;
3715 
3716  /// Check if it is safe to call GetHgvs method.
3717  ///
3718  /// @return
3719  /// - true, if the data member is getatable.
3720  /// - false, otherwise.
3721  bool CanGetHgvs(void) const;
3722 
3723  /// Reset Hgvs data member.
3724  void ResetHgvs(void);
3725 
3726  /// Get the Hgvs member data.
3727  ///
3728  /// @return
3729  /// Reference to the member data.
3730  const THgvs& GetHgvs(void) const;
3731 
3732  /// Assign a value to Hgvs data member.
3733  ///
3734  /// @return
3735  /// Reference to the data value.
3736  THgvs& SetHgvs(void);
3737 
3738  /// Check if a value has been assigned to AlleleOrigin data member.
3739  ///
3740  /// Data member AlleleOrigin is optional;
3741  /// its type is defined as 'typedef list< CRef< C_E_AlleleOrigin > > TAlleleOrigin'
3742  /// @return
3743  /// - true, if a value has been assigned.
3744  /// - false, otherwise.
3745  bool IsSetAlleleOrigin(void) const;
3746 
3747  /// Check if it is safe to call GetAlleleOrigin method.
3748  ///
3749  /// @return
3750  /// - true, if the data member is getatable.
3751  /// - false, otherwise.
3752  bool CanGetAlleleOrigin(void) const;
3753 
3754  /// Reset AlleleOrigin data member.
3755  void ResetAlleleOrigin(void);
3756 
3757  /// Get the AlleleOrigin member data.
3758  ///
3759  /// @return
3760  /// Reference to the member data.
3761  const TAlleleOrigin& GetAlleleOrigin(void) const;
3762 
3763  /// Assign a value to AlleleOrigin data member.
3764  ///
3765  /// @return
3766  /// Reference to the data value.
3767  TAlleleOrigin& SetAlleleOrigin(void);
3768 
3769  /// Check if a value has been assigned to Phenotype data member.
3770  ///
3771  /// Data member Phenotype is optional;
3772  /// its type is defined as 'typedef list< CRef< C_E_Phenotype > > TPhenotype'
3773  /// @return
3774  /// - true, if a value has been assigned.
3775  /// - false, otherwise.
3776  bool IsSetPhenotype(void) const;
3777 
3778  /// Check if it is safe to call GetPhenotype method.
3779  ///
3780  /// @return
3781  /// - true, if the data member is getatable.
3782  /// - false, otherwise.
3783  bool CanGetPhenotype(void) const;
3784 
3785  /// Reset Phenotype data member.
3786  void ResetPhenotype(void);
3787 
3788  /// Get the Phenotype member data.
3789  ///
3790  /// @return
3791  /// Reference to the member data.
3792  const TPhenotype& GetPhenotype(void) const;
3793 
3794  /// Assign a value to Phenotype data member.
3795  ///
3796  /// @return
3797  /// Reference to the data value.
3798  TPhenotype& SetPhenotype(void);
3799 
3800  /// Check if a value has been assigned to BioSource data member.
3801  ///
3802  /// Data member BioSource is optional;
3803  /// its type is defined as 'typedef list< CRef< C_E_BioSource > > TBioSource'
3804  /// @return
3805  /// - true, if a value has been assigned.
3806  /// - false, otherwise.
3807  bool IsSetBioSource(void) const;
3808 
3809  /// Check if it is safe to call GetBioSource method.
3810  ///
3811  /// @return
3812  /// - true, if the data member is getatable.
3813  /// - false, otherwise.
3814  bool CanGetBioSource(void) const;
3815 
3816  /// Reset BioSource data member.
3817  void ResetBioSource(void);
3818 
3819  /// Get the BioSource member data.
3820  ///
3821  /// @return
3822  /// Reference to the member data.
3823  const TBioSource& GetBioSource(void) const;
3824 
3825  /// Assign a value to BioSource data member.
3826  ///
3827  /// @return
3828  /// Reference to the data value.
3829  TBioSource& SetBioSource(void);
3830 
3831  /// Check if a value has been assigned to Frequency data member.
3832  ///
3833  /// Data member Frequency is optional;
3834  /// its type is defined as 'typedef list< CRef< C_E_Frequency > > TFrequency'
3835  /// @return
3836  /// - true, if a value has been assigned.
3837  /// - false, otherwise.
3838  bool IsSetFrequency(void) const;
3839 
3840  /// Check if it is safe to call GetFrequency method.
3841  ///
3842  /// @return
3843  /// - true, if the data member is getatable.
3844  /// - false, otherwise.
3845  bool CanGetFrequency(void) const;
3846 
3847  /// Reset Frequency data member.
3848  void ResetFrequency(void);
3849 
3850  /// Get the Frequency member data.
3851  ///
3852  /// @return
3853  /// Reference to the member data.
3854  const TFrequency& GetFrequency(void) const;
3855 
3856  /// Assign a value to Frequency data member.
3857  ///
3858  /// @return
3859  /// Reference to the data value.
3860  TFrequency& SetFrequency(void);
3861 
3862  /// Reset the whole object
3863  virtual void Reset(void);
3864 
3865 
3866 private:
3867  // Prohibit copy constructor and assignment operator
3870 
3871  // data
3872  Uint4 m_set_State[2];
3879  list< CRef< CSs > > m_Ss;
3880  list< CRef< CAssembly > > m_Assembly;
3881  list< CRef< CPrimarySequence > > m_PrimarySequence;
3882  list< CRef< CRsStruct > > m_RsStruct;
3883  list< CRef< CRsLinkout > > m_RsLinkout;
3884  list< CRef< C_E_MergeHistory > > m_MergeHistory;
3885  list< string > m_Hgvs;
3886  list< CRef< C_E_AlleleOrigin > > m_AlleleOrigin;
3887  list< CRef< C_E_Phenotype > > m_Phenotype;
3888  list< CRef< C_E_BioSource > > m_BioSource;
3889  list< CRef< C_E_Frequency > > m_Frequency;
3890 };
3891 
3892 /* @} */
3893 
3894 
3895 
3896 
3897 
3898 ///////////////////////////////////////////////////////////
3899 ///////////////////// inline methods //////////////////////
3900 ///////////////////////////////////////////////////////////
3901 inline
3903 {
3904  return ((m_set_State[0] & 0x3) != 0);
3905 }
3906 
3907 inline
3909 {
3910  return IsSetRsId();
3911 }
3912 
3913 inline
3915 {
3916  m_RsId = 0;
3917  m_set_State[0] &= ~0x3;
3918 }
3919 
3920 inline
3922 {
3923  if (!CanGetRsId()) {
3924  ThrowUnassigned(0);
3925  }
3926  return m_RsId;
3927 }
3928 
3929 inline
3931 {
3932  m_RsId = value;
3933  m_set_State[0] |= 0x3;
3934 }
3935 
3936 inline
3938 {
3939 #ifdef _DEBUG
3940  if (!IsSetRsId()) {
3941  memset(&m_RsId,UnassignedByte(),sizeof(m_RsId));
3942  }
3943 #endif
3944  m_set_State[0] |= 0x1;
3945  return m_RsId;
3946 }
3947 
3948 inline
3950 {
3951  return ((m_set_State[0] & 0xc) != 0);
3952 }
3953 
3954 inline
3956 {
3957  return IsSetSnpClass();
3958 }
3959 
3960 inline
3962 {
3963  m_SnpClass = (EAttlist_snpClass)(0);
3964  m_set_State[0] &= ~0xc;
3965 }
3966 
3967 inline
3969 {
3970  if (!CanGetSnpClass()) {
3971  ThrowUnassigned(1);
3972  }
3973  return m_SnpClass;
3974 }
3975 
3976 inline
3978 {
3979  m_SnpClass = value;
3980  m_set_State[0] |= 0xc;
3981 }
3982 
3983 inline
3985 {
3986 #ifdef _DEBUG
3987  if (!IsSetSnpClass()) {
3988  memset(&m_SnpClass,UnassignedByte(),sizeof(m_SnpClass));
3989  }
3990 #endif
3991  m_set_State[0] |= 0x4;
3992  return m_SnpClass;
3993 }
3994 
3995 inline
3997 {
3998  return ((m_set_State[0] & 0x30) != 0);
3999 }
4000 
4001 inline
4003 {
4004  return IsSetSnpType();
4005 }
4006 
4007 inline
4009 {
4010  m_SnpType = (EAttlist_snpType)(0);
4011  m_set_State[0] &= ~0x30;
4012 }
4013 
4014 inline
4016 {
4017  if (!CanGetSnpType()) {
4018  ThrowUnassigned(2);
4019  }
4020  return m_SnpType;
4021 }
4022 
4023 inline
4025 {
4026  m_SnpType = value;
4027  m_set_State[0] |= 0x30;
4028 }
4029 
4030 inline
4032 {
4033 #ifdef _DEBUG
4034  if (!IsSetSnpType()) {
4035  memset(&m_SnpType,UnassignedByte(),sizeof(m_SnpType));
4036  }
4037 #endif
4038  m_set_State[0] |= 0x10;
4039  return m_SnpType;
4040 }
4041 
4042 inline
4044 {
4045  return ((m_set_State[0] & 0xc0) != 0);
4046 }
4047 
4048 inline
4050 {
4051  return IsSetMolType();
4052 }
4053 
4054 inline
4056 {
4057  m_MolType = (EAttlist_molType)(0);
4058  m_set_State[0] &= ~0xc0;
4059 }
4060 
4061 inline
4063 {
4064  if (!CanGetMolType()) {
4065  ThrowUnassigned(3);
4066  }
4067  return m_MolType;
4068 }
4069 
4070 inline
4072 {
4073  m_MolType = value;
4074  m_set_State[0] |= 0xc0;
4075 }
4076 
4077 inline
4079 {
4080 #ifdef _DEBUG
4081  if (!IsSetMolType()) {
4082  memset(&m_MolType,UnassignedByte(),sizeof(m_MolType));
4083  }
4084 #endif
4085  m_set_State[0] |= 0x40;
4086  return m_MolType;
4087 }
4088 
4089 inline
4091 {
4092  return ((m_set_State[0] & 0x300) != 0);
4093 }
4094 
4095 inline
4097 {
4098  return IsSetValidProbMin();
4099 }
4100 
4101 inline
4103 {
4104  m_ValidProbMin = 0;
4105  m_set_State[0] &= ~0x300;
4106 }
4107 
4108 inline
4110 {
4111  if (!CanGetValidProbMin()) {
4112  ThrowUnassigned(4);
4113  }
4114  return m_ValidProbMin;
4115 }
4116 
4117 inline
4119 {
4120  m_ValidProbMin = value;
4121  m_set_State[0] |= 0x300;
4122 }
4123 
4124 inline
4126 {
4127 #ifdef _DEBUG
4128  if (!IsSetValidProbMin()) {
4129  memset(&m_ValidProbMin,UnassignedByte(),sizeof(m_ValidProbMin));
4130  }
4131 #endif
4132  m_set_State[0] |= 0x100;
4133  return m_ValidProbMin;
4134 }
4135 
4136 inline
4138 {
4139  return ((m_set_State[0] & 0xc00) != 0);
4140 }
4141 
4142 inline
4144 {
4145  return IsSetValidProbMax();
4146 }
4147 
4148 inline
4150 {
4151  m_ValidProbMax = 0;
4152  m_set_State[0] &= ~0xc00;
4153 }
4154 
4155 inline
4157 {
4158  if (!CanGetValidProbMax()) {
4159  ThrowUnassigned(5);
4160  }
4161  return m_ValidProbMax;
4162 }
4163 
4164 inline
4166 {
4167  m_ValidProbMax = value;
4168  m_set_State[0] |= 0xc00;
4169 }
4170 
4171 inline
4173 {
4174 #ifdef _DEBUG
4175  if (!IsSetValidProbMax()) {
4176  memset(&m_ValidProbMax,UnassignedByte(),sizeof(m_ValidProbMax));
4177  }
4178 #endif
4179  m_set_State[0] |= 0x400;
4180  return m_ValidProbMax;
4181 }
4182 
4183 inline
4185 {
4186  return ((m_set_State[0] & 0x3000) != 0);
4187 }
4188 
4189 inline
4191 {
4192  return IsSetGenotype();
4193 }
4194 
4195 inline
4197 {
4198  m_Genotype = 0;
4199  m_set_State[0] &= ~0x3000;
4200 }
4201 
4202 inline
4204 {
4205  if (!CanGetGenotype()) {
4206  ThrowUnassigned(6);
4207  }
4208  return m_Genotype;
4209 }
4210 
4211 inline
4213 {
4214  m_Genotype = value;
4215  m_set_State[0] |= 0x3000;
4216 }
4217 
4218 inline
4220 {
4221 #ifdef _DEBUG
4222  if (!IsSetGenotype()) {
4223  memset(&m_Genotype,UnassignedByte(),sizeof(m_Genotype));
4224  }
4225 #endif
4226  m_set_State[0] |= 0x1000;
4227  return m_Genotype;
4228 }
4229 
4230 inline
4232 {
4233  return ((m_set_State[0] & 0xc000) != 0);
4234 }
4235 
4236 inline
4238 {
4239  return IsSetBitField();
4240 }
4241 
4242 inline
4244 {
4245  if (!CanGetBitField()) {
4246  ThrowUnassigned(7);
4247  }
4248  return m_BitField;
4249 }
4250 
4251 inline
4253 {
4254  m_BitField = value;
4255  m_set_State[0] |= 0xc000;
4256 }
4257 
4258 inline
4260 {
4261  m_BitField = std::forward<CRs_Base::C_Attlist::TBitField>(value);
4262  m_set_State[0] |= 0xc000;
4263 }
4264 
4265 inline
4267 {
4268 #ifdef _DEBUG
4269  if (!IsSetBitField()) {
4270  m_BitField = UnassignedString();
4271  }
4272 #endif
4273  m_set_State[0] |= 0x4000;
4274  return m_BitField;
4275 }
4276 
4277 inline
4279 {
4280  return ((m_set_State[0] & 0x30000) != 0);
4281 }
4282 
4283 inline
4285 {
4286  return IsSetTaxId();
4287 }
4288 
4289 inline
4291 {
4292  m_TaxId = 0;
4293  m_set_State[0] &= ~0x30000;
4294 }
4295 
4296 inline
4298 {
4299  if (!CanGetTaxId()) {
4300  ThrowUnassigned(8);
4301  }
4302  return m_TaxId;
4303 }
4304 
4305 inline
4307 {
4308  m_TaxId = value;
4309  m_set_State[0] |= 0x30000;
4310 }
4311 
4312 inline
4314 {
4315 #ifdef _DEBUG
4316  if (!IsSetTaxId()) {
4317  memset(&m_TaxId,UnassignedByte(),sizeof(m_TaxId));
4318  }
4319 #endif
4320  m_set_State[0] |= 0x10000;
4321  return m_TaxId;
4322 }
4323 
4324 inline
4326 {
4327  return ((m_set_State[0] & 0x3) != 0);
4328 }
4329 
4330 inline
4332 {
4333  return IsSetType();
4334 }
4335 
4336 inline
4338 {
4339  m_Type = (EHet_attlist_type)(0);
4340  m_set_State[0] &= ~0x3;
4341 }
4342 
4343 inline
4345 {
4346  if (!CanGetType()) {
4347  ThrowUnassigned(0);
4348  }
4349  return m_Type;
4350 }
4351 
4352 inline
4354 {
4355  m_Type = value;
4356  m_set_State[0] |= 0x3;
4357 }
4358 
4359 inline
4361 {
4362 #ifdef _DEBUG
4363  if (!IsSetType()) {
4364  memset(&m_Type,UnassignedByte(),sizeof(m_Type));
4365  }
4366 #endif
4367  m_set_State[0] |= 0x1;
4368  return m_Type;
4369 }
4370 
4371 inline
4373 {
4374  return ((m_set_State[0] & 0xc) != 0);
4375 }
4376 
4377 inline
4379 {
4380  return IsSetValue();
4381 }
4382 
4383 inline
4385 {
4386  m_Value = 0;
4387  m_set_State[0] &= ~0xc;
4388 }
4389 
4390 inline
4392 {
4393  if (!CanGetValue()) {
4394  ThrowUnassigned(1);
4395  }
4396  return m_Value;
4397 }
4398 
4399 inline
4401 {
4402  m_Value = value;
4403  m_set_State[0] |= 0xc;
4404 }
4405 
4406 inline
4408 {
4409 #ifdef _DEBUG
4410  if (!IsSetValue()) {
4411  memset(&m_Value,UnassignedByte(),sizeof(m_Value));
4412  }
4413 #endif
4414  m_set_State[0] |= 0x4;
4415  return m_Value;
4416 }
4417 
4418 inline
4420 {
4421  return ((m_set_State[0] & 0x30) != 0);
4422 }
4423 
4424 inline
4426 {
4427  return IsSetStdError();
4428 }
4429 
4430 inline
4432 {
4433  m_StdError = 0;
4434  m_set_State[0] &= ~0x30;
4435 }
4436 
4437 inline
4439 {
4440  if (!CanGetStdError()) {
4441  ThrowUnassigned(2);
4442  }
4443  return m_StdError;
4444 }
4445 
4446 inline
4448 {
4449  m_StdError = value;
4450  m_set_State[0] |= 0x30;
4451 }
4452 
4453 inline
4455 {
4456 #ifdef _DEBUG
4457  if (!IsSetStdError()) {
4458  memset(&m_StdError,UnassignedByte(),sizeof(m_StdError));
4459  }
4460 #endif
4461  m_set_State[0] |= 0x10;
4462  return m_StdError;
4463 }
4464 
4465 inline
4467 {
4468  return m_Attlist.NotEmpty();
4469 }
4470 
4471 inline
4473 {
4474  return true;
4475 }
4476 
4477 inline
4479 {
4480  if ( !m_Attlist ) {
4481  const_cast<C_Het*>(this)->ResetAttlist();
4482  }
4483  return (*m_Attlist);
4484 }
4485 
4486 inline
4488 {
4489  if ( !m_Attlist ) {
4490  ResetAttlist();
4491  }
4492  return (*m_Attlist);
4493 }
4494 
4495 inline
4497 {
4498  return ((m_set_State[0] & 0xc) != 0);
4499 }
4500 
4501 inline
4503 {
4504  return false;
4505 }
4506 
4507 inline
4509 {
4510  m_set_State[0] &= ~0xc;
4511 }
4512 
4513 inline
4515 {
4516  m_set_State[0] |= 0xc;
4517 }
4518 
4519 inline
4521 {
4522  return ((m_set_State[0] & 0x3) != 0);
4523 }
4524 
4525 inline
4527 {
4528  return IsSetByCluster();
4529 }
4530 
4531 inline
4533 {
4534  m_ByCluster = 0;
4535  m_set_State[0] &= ~0x3;
4536 }
4537 
4538 inline
4540 {
4541  if (!CanGetByCluster()) {
4542  ThrowUnassigned(0);
4543  }
4544  return m_ByCluster;
4545 }
4546 
4547 inline
4549 {
4550  m_ByCluster = value;
4551  m_set_State[0] |= 0x3;
4552 }
4553 
4554 inline
4556 {
4557 #ifdef _DEBUG
4558  if (!IsSetByCluster()) {
4559  memset(&m_ByCluster,UnassignedByte(),sizeof(m_ByCluster));
4560  }
4561 #endif
4562  m_set_State[0] |= 0x1;
4563  return m_ByCluster;
4564 }
4565 
4566 inline
4568 {
4569  return ((m_set_State[0] & 0xc) != 0);
4570 }
4571 
4572 inline
4574 {
4575  return IsSetByFrequency();
4576 }
4577 
4578 inline
4580 {
4581  m_ByFrequency = 0;
4582  m_set_State[0] &= ~0xc;
4583 }
4584 
4585 inline
4587 {
4588  if (!CanGetByFrequency()) {
4589  ThrowUnassigned(1);
4590  }
4591  return m_ByFrequency;
4592 }
4593 
4594 inline
4596 {
4597  m_ByFrequency = value;
4598  m_set_State[0] |= 0xc;
4599 }
4600 
4601 inline
4603 {
4604 #ifdef _DEBUG
4605  if (!IsSetByFrequency()) {
4606  memset(&m_ByFrequency,UnassignedByte(),sizeof(m_ByFrequency));
4607  }
4608 #endif
4609  m_set_State[0] |= 0x4;
4610  return m_ByFrequency;
4611 }
4612 
4613 inline
4615 {
4616  return ((m_set_State[0] & 0x30) != 0);
4617 }
4618 
4619 inline
4621 {
4622  return IsSetByOtherPop();
4623 }
4624 
4625 inline
4627 {
4628  m_ByOtherPop = 0;
4629  m_set_State[0] &= ~0x30;
4630 }
4631 
4632 inline
4634 {
4635  if (!CanGetByOtherPop()) {
4636  ThrowUnassigned(2);
4637  }
4638  return m_ByOtherPop;
4639 }
4640 
4641 inline
4643 {
4644  m_ByOtherPop = value;
4645  m_set_State[0] |= 0x30;
4646 }
4647 
4648 inline
4650 {
4651 #ifdef _DEBUG
4652  if (!IsSetByOtherPop()) {
4653  memset(&m_ByOtherPop,UnassignedByte(),sizeof(m_ByOtherPop));
4654  }
4655 #endif
4656  m_set_State[0] |= 0x10;
4657  return m_ByOtherPop;
4658 }
4659 
4660 inline
4662 {
4663  return ((m_set_State[0] & 0xc0) != 0);
4664 }
4665 
4666 inline
4668 {
4669  return IsSetBy2Hit2Allele();
4670 }
4671 
4672 inline
4674 {
4675  m_By2Hit2Allele = 0;
4676  m_set_State[0] &= ~0xc0;
4677 }
4678 
4679 inline
4681 {
4682  if (!CanGetBy2Hit2Allele()) {
4683  ThrowUnassigned(3);
4684  }
4685  return m_By2Hit2Allele;
4686 }
4687 
4688 inline
4690 {
4691  m_By2Hit2Allele = value;
4692  m_set_State[0] |= 0xc0;
4693 }
4694 
4695 inline
4697 {
4698 #ifdef _DEBUG
4699  if (!IsSetBy2Hit2Allele()) {
4700  memset(&m_By2Hit2Allele,UnassignedByte(),sizeof(m_By2Hit2Allele));
4701  }
4702 #endif
4703  m_set_State[0] |= 0x40;
4704  return m_By2Hit2Allele;
4705 }
4706 
4707 inline
4709 {
4710  return ((m_set_State[0] & 0x300) != 0);
4711 }
4712 
4713 inline
4715 {
4716  return IsSetByHapMap();
4717 }
4718 
4719 inline
4721 {
4722  m_ByHapMap = 0;
4723  m_set_State[0] &= ~0x300;
4724 }
4725 
4726 inline
4728 {
4729  if (!CanGetByHapMap()) {
4730  ThrowUnassigned(4);
4731  }
4732  return m_ByHapMap;
4733 }
4734 
4735 inline
4737 {
4738  m_ByHapMap = value;
4739  m_set_State[0] |= 0x300;
4740 }
4741 
4742 inline
4744 {
4745 #ifdef _DEBUG
4746  if (!IsSetByHapMap()) {
4747  memset(&m_ByHapMap,UnassignedByte(),sizeof(m_ByHapMap));
4748  }
4749 #endif
4750  m_set_State[0] |= 0x100;
4751  return m_ByHapMap;
4752 }
4753 
4754 inline
4756 {
4757  return ((m_set_State[0] & 0xc00) != 0);
4758 }
4759 
4760 inline
4762 {
4763  return IsSetBy1000G();
4764 }
4765 
4766 inline
4768 {
4769  m_By1000G = 0;
4770  m_set_State[0] &= ~0xc00;
4771 }
4772 
4773 inline
4775 {
4776  if (!CanGetBy1000G()) {
4777  ThrowUnassigned(5);
4778  }
4779  return m_By1000G;
4780 }
4781 
4782 inline
4784 {
4785  m_By1000G = value;
4786  m_set_State[0] |= 0xc00;
4787 }
4788 
4789 inline
4791 {
4792 #ifdef _DEBUG
4793  if (!IsSetBy1000G()) {
4794  memset(&m_By1000G,UnassignedByte(),sizeof(m_By1000G));
4795  }
4796 #endif
4797  m_set_State[0] |= 0x400;
4798  return m_By1000G;
4799 }
4800 
4801 inline
4803 {
4804  return ((m_set_State[0] & 0x3000) != 0);
4805 }
4806 
4807 inline
4809 {
4810  return IsSetSuspect();
4811 }
4812 
4813 inline
4815 {
4816  m_Suspect = 0;
4817  m_set_State[0] &= ~0x3000;
4818 }
4819 
4820 inline
4822 {
4823  if (!CanGetSuspect()) {
4824  ThrowUnassigned(6);
4825  }
4826  return m_Suspect;
4827 }
4828 
4829 inline
4831 {
4832  m_Suspect = value;
4833  m_set_State[0] |= 0x3000;
4834 }
4835 
4836 inline
4838 {
4839 #ifdef _DEBUG
4840  if (!IsSetSuspect()) {
4841  memset(&m_Suspect,UnassignedByte(),sizeof(m_Suspect));
4842  }
4843 #endif
4844  m_set_State[0] |= 0x1000;
4845  return m_Suspect;
4846 }
4847 
4848 inline
4850 {
4851  return m_Attlist.NotEmpty();
4852 }
4853 
4854 inline
4856 {
4857  return true;
4858 }
4859 
4860 inline
4862 {
4863  if ( !m_Attlist ) {
4864  const_cast<C_Validation*>(this)->ResetAttlist();
4865  }
4866  return (*m_Attlist);
4867 }
4868 
4869 inline
4871 {
4872  if ( !m_Attlist ) {
4873  ResetAttlist();
4874  }
4875  return (*m_Attlist);
4876 }
4877 
4878 inline
4880 {
4881  return ((m_set_State[0] & 0xc) != 0);
4882 }
4883 
4884 inline
4886 {
4887  return true;
4888 }
4889 
4890 inline
4892 {
4893  return m_OtherPopBatchId;
4894 }
4895 
4896 inline
4898 {
4899  m_set_State[0] |= 0x4;
4900  return m_OtherPopBatchId;
4901 }
4902 
4903 inline
4905 {
4906  return ((m_set_State[0] & 0x30) != 0);
4907 }
4908 
4909 inline
4911 {
4912  return true;
4913 }
4914 
4915 inline
4917 {
4918  return m_TwoHit2AlleleBatchId;
4919 }
4920 
4921 inline
4923 {
4924  m_set_State[0] |= 0x10;
4925  return m_TwoHit2AlleleBatchId;
4926 }
4927 
4928 inline
4930 {
4931  return ((m_set_State[0] & 0xc0) != 0);
4932 }
4933 
4934 inline
4936 {
4937  return true;
4938 }
4939 
4940 inline
4942 {
4943  return m_FrequencyClass;
4944 }
4945 
4946 inline
4948 {
4949  m_set_State[0] |= 0x40;
4950  return m_FrequencyClass;
4951 }
4952 
4953 inline
4955 {
4956  return ((m_set_State[0] & 0x300) != 0);
4957 }
4958 
4959 inline
4961 {
4962  return true;
4963 }
4964 
4965 inline
4967 {
4968  return m_HapMapPhase;
4969 }
4970 
4971 inline
4973 {
4974  m_set_State[0] |= 0x100;
4975  return m_HapMapPhase;
4976 }
4977 
4978 inline
4980 {
4981  return ((m_set_State[0] & 0xc00) != 0);
4982 }
4983 
4984 inline
4986 {
4987  return true;
4988 }
4989 
4990 inline
4992 {
4993  return m_TGPPhase;
4994 }
4995 
4996 inline
4998 {
4999  m_set_State[0] |= 0x400;
5000  return m_TGPPhase;
5001 }
5002 
5003 inline
5005 {
5006  return ((m_set_State[0] & 0x3000) != 0);
5007 }
5008 
5009 inline
5011 {
5012  return true;
5013 }
5014 
5015 inline
5017 {
5018  return m_SuspectEvidence;
5019 }
5020 
5021 inline
5023 {
5024  m_set_State[0] |= 0x1000;
5025  return m_SuspectEvidence;
5026 }
5027 
5028 inline
5030 {
5031  return ((m_set_State[0] & 0x3) != 0);
5032 }
5033 
5034 inline
5036 {
5037  return IsSetBuild();
5038 }
5039 
5040 inline
5042 {
5043  m_Build = 0;
5044  m_set_State[0] &= ~0x3;
5045 }
5046 
5047 inline
5049 {
5050  if (!CanGetBuild()) {
5051  ThrowUnassigned(0);
5052  }
5053  return m_Build;
5054 }
5055 
5056 inline
5058 {
5059  m_Build = value;
5060  m_set_State[0] |= 0x3;
5061 }
5062 
5063 inline
5065 {
5066 #ifdef _DEBUG
5067  if (!IsSetBuild()) {
5068  memset(&m_Build,UnassignedByte(),sizeof(m_Build));
5069  }
5070 #endif
5071  m_set_State[0] |= 0x1;
5072  return m_Build;
5073 }
5074 
5075 inline
5077 {
5078  return ((m_set_State[0] & 0xc) != 0);
5079 }
5080 
5081 inline
5083 {
5084  return IsSetDate();
5085 }
5086 
5087 inline
5089 {
5090  if (!CanGetDate()) {
5091  ThrowUnassigned(1);
5092  }
5093  return m_Date;
5094 }
5095 
5096 inline
5098 {
5099  m_Date = value;
5100  m_set_State[0] |= 0xc;
5101 }
5102 
5103 inline
5105 {
5106  m_Date = std::forward<CRs_Base::C_Create::C_Attlist::TDate>(value);
5107  m_set_State[0] |= 0xc;
5108 }
5109 
5110 inline
5112 {
5113 #ifdef _DEBUG
5114  if (!IsSetDate()) {
5115  m_Date = UnassignedString();
5116  }
5117 #endif
5118  m_set_State[0] |= 0x4;
5119  return m_Date;
5120 }
5121 
5122 inline
5124 {
5125  return m_Attlist.NotEmpty();
5126 }
5127 
5128 inline
5130 {
5131  return true;
5132 }
5133 
5134 inline
5136 {
5137  if ( !m_Attlist ) {
5138  const_cast<C_Create*>(this)->ResetAttlist();
5139  }
5140  return (*m_Attlist);
5141 }
5142 
5143 inline
5145 {
5146  if ( !m_Attlist ) {
5147  ResetAttlist();
5148  }
5149  return (*m_Attlist);
5150 }
5151 
5152 inline
5154 {
5155  return ((m_set_State[0] & 0xc) != 0);
5156 }
5157 
5158 inline
5160 {
5161  return false;
5162 }
5163 
5164 inline
5166 {
5167  m_set_State[0] &= ~0xc;
5168 }
5169 
5170 inline
5172 {
5173  m_set_State[0] |= 0xc;
5174 }
5175 
5176 inline
5178 {
5179  return ((m_set_State[0] & 0x3) != 0);
5180 }
5181 
5182 inline
5184 {
5185  return IsSetBuild();
5186 }
5187 
5188 inline
5190 {
5191  m_Build = 0;
5192  m_set_State[0] &= ~0x3;
5193 }
5194 
5195 inline
5197 {
5198  if (!CanGetBuild()) {
5199  ThrowUnassigned(0);
5200  }
5201  return m_Build;
5202 }
5203 
5204 inline
5206 {
5207  m_Build = value;
5208  m_set_State[0] |= 0x3;
5209 }
5210 
5211 inline
5213 {
5214 #ifdef _DEBUG
5215  if (!IsSetBuild()) {
5216  memset(&m_Build,UnassignedByte(),sizeof(m_Build));
5217  }
5218 #endif
5219  m_set_State[0] |= 0x1;
5220  return m_Build;
5221 }
5222 
5223 inline
5225 {
5226  return ((m_set_State[0] & 0xc) != 0);
5227 }
5228 
5229 inline
5231 {
5232  return IsSetDate();
5233 }
5234 
5235 inline
5237 {
5238  if (!CanGetDate()) {
5239  ThrowUnassigned(1);
5240  }
5241  return m_Date;
5242 }
5243 
5244 inline
5246 {
5247  m_Date = value;
5248  m_set_State[0] |= 0xc;
5249 }
5250 
5251 inline
5253 {
5254  m_Date = std::forward<CRs_Base::C_Update::C_Attlist::TDate>(value);
5255  m_set_State[0] |= 0xc;
5256 }
5257 
5258 inline
5260 {
5261 #ifdef _DEBUG
5262  if (!IsSetDate()) {
5263  m_Date = UnassignedString();
5264  }
5265 #endif
5266  m_set_State[0] |= 0x4;
5267  return m_Date;
5268 }
5269 
5270 inline
5272 {
5273  return m_Attlist.NotEmpty();
5274 }
5275 
5276 inline
5278 {
5279  return true;
5280 }
5281 
5282 inline
5284 {
5285  if ( !m_Attlist ) {
5286  const_cast<C_Update*>(this)->ResetAttlist();
5287  }
5288  return (*m_Attlist);
5289 }
5290 
5291 inline
5293 {
5294  if ( !m_Attlist ) {
5295  ResetAttlist();
5296  }
5297  return (*m_Attlist);
5298 }
5299 
5300 inline
5302 {
5303  return ((m_set_State[0] & 0xc) != 0);
5304 }
5305 
5306 inline
5308 {
5309  return false;
5310 }
5311 
5312 inline
5314 {
5315  m_set_State[0] &= ~0xc;
5316 }
5317 
5318 inline
5320 {
5321  m_set_State[0] |= 0xc;
5322 }
5323 
5324 inline
5326 {
5327  return ((m_set_State[0] & 0x3) != 0);
5328 }
5329 
5330 inline
5332 {
5333  return IsSetExemplarSs();
5334 }
5335 
5336 inline
5338 {
5339  m_ExemplarSs = 0;
5340  m_set_State[0] &= ~0x3;
5341 }
5342 
5343 inline
5345 {
5346  if (!CanGetExemplarSs()) {
5347  ThrowUnassigned(0);
5348  }
5349  return m_ExemplarSs;
5350 }
5351 
5352 inline
5354 {
5355  m_ExemplarSs = value;
5356  m_set_State[0] |= 0x3;
5357 }
5358 
5359 inline
5361 {
5362 #ifdef _DEBUG
5363  if (!IsSetExemplarSs()) {
5364  memset(&m_ExemplarSs,UnassignedByte(),sizeof(m_ExemplarSs));
5365  }
5366 #endif
5367  m_set_State[0] |= 0x1;
5368  return m_ExemplarSs;
5369 }
5370 
5371 inline
5373 {
5374  return ((m_set_State[0] & 0xc) != 0);
5375 }
5376 
5377 inline
5379 {
5380  return IsSetAncestralAllele();
5381 }
5382 
5383 inline
5385 {
5386  if (!CanGetAncestralAllele()) {
5387  ThrowUnassigned(1);
5388  }
5389  return m_AncestralAllele;
5390 }
5391 
5392 inline
5394 {
5395  m_AncestralAllele = value;
5396  m_set_State[0] |= 0xc;
5397 }
5398 
5399 inline
5401 {
5402  m_AncestralAllele = std::forward<CRs_Base::C_Sequence::C_Attlist::TAncestralAllele>(value);
5403  m_set_State[0] |= 0xc;
5404 }
5405 
5406 inline
5408 {
5409 #ifdef _DEBUG
5410  if (!IsSetAncestralAllele()) {
5411  m_AncestralAllele = UnassignedString();
5412  }
5413 #endif
5414  m_set_State[0] |= 0x4;
5415  return m_AncestralAllele;
5416 }
5417 
5418 inline
5420 {
5421  return m_Attlist.NotEmpty();
5422 }
5423 
5424 inline
5426 {
5427  return true;
5428 }
5429 
5430 inline
5432 {
5433  if ( !m_Attlist ) {
5434  const_cast<C_Sequence*>(this)->ResetAttlist();
5435  }
5436  return (*m_Attlist);
5437 }
5438 
5439 inline
5441 {
5442  if ( !m_Attlist ) {
5443  ResetAttlist();
5444  }
5445  return (*m_Attlist);
5446 }
5447 
5448 inline
5450 {
5451  return ((m_set_State[0] & 0xc) != 0);
5452 }
5453 
5454 inline
5456 {
5457  return IsSetSeq5();
5458 }
5459 
5460 inline
5462 {
5463  if (!CanGetSeq5()) {
5464  ThrowUnassigned(1);
5465  }
5466  return m_Seq5;
5467 }
5468 
5469 inline
5471 {
5472  m_Seq5 = value;
5473  m_set_State[0] |= 0xc;
5474 }
5475 
5476 inline
5478 {
5479  m_Seq5 = std::forward<CRs_Base::C_Sequence::TSeq5>(value);
5480  m_set_State[0] |= 0xc;
5481 }
5482 
5483 inline
5485 {
5486 #ifdef _DEBUG
5487  if (!IsSetSeq5()) {
5488  m_Seq5 = UnassignedString();
5489  }
5490 #endif
5491  m_set_State[0] |= 0x4;
5492  return m_Seq5;
5493 }
5494 
5495 inline
5497 {
5498  return ((m_set_State[0] & 0x30) != 0);
5499 }
5500 
5501 inline
5503 {
5504  return IsSetObserved();
5505 }
5506 
5507 inline
5509 {
5510  if (!CanGetObserved()) {
5511  ThrowUnassigned(2);
5512  }
5513  return m_Observed;
5514 }
5515 
5516 inline
5518 {
5519  m_Observed = value;
5520  m_set_State[0] |= 0x30;
5521 }
5522 
5523 inline
5525 {
5526  m_Observed = std::forward<CRs_Base::C_Sequence::TObserved>(value);
5527  m_set_State[0] |= 0x30;
5528 }
5529 
5530 inline
5532 {
5533 #ifdef _DEBUG
5534  if (!IsSetObserved()) {
5535  m_Observed = UnassignedString();
5536  }
5537 #endif
5538  m_set_State[0] |= 0x10;
5539  return m_Observed;
5540 }
5541 
5542 inline
5544 {
5545  return ((m_set_State[0] & 0xc0) != 0);
5546 }
5547 
5548 inline
5550 {
5551  return IsSetSeq3();
5552 }
5553 
5554 inline
5556 {
5557  if (!CanGetSeq3()) {
5558  ThrowUnassigned(3);
5559  }
5560  return m_Seq3;
5561 }
5562 
5563 inline
5565 {
5566  m_Seq3 = value;
5567  m_set_State[0] |= 0xc0;
5568 }
5569 
5570 inline
5572 {
5573  m_Seq3 = std::forward<CRs_Base::C_Sequence::TSeq3>(value);
5574  m_set_State[0] |= 0xc0;
5575 }
5576 
5577 inline
5579 {
5580 #ifdef _DEBUG
5581  if (!IsSetSeq3()) {
5582  m_Seq3 = UnassignedString();
5583  }
5584 #endif
5585  m_set_State[0] |= 0x40;
5586  return m_Seq3;
5587 }
5588 
5589 inline
5591 {
5592  return ((m_set_State[0] & 0x3) != 0);
5593 }
5594 
5595 inline
5597 {
5598  return IsSetRsId();
5599 }
5600 
5601 inline
5603 {
5604  m_RsId = 0;
5605  m_set_State[0] &= ~0x3;
5606 }
5607 
5608 inline
5610 {
5611  if (!CanGetRsId()) {
5612  ThrowUnassigned(0);
5613  }
5614  return m_RsId;
5615 }
5616 
5617 inline
5619 {
5620  m_RsId = value;
5621  m_set_State[0] |= 0x3;
5622 }
5623 
5624 inline
5626 {
5627 #ifdef _DEBUG
5628  if (!IsSetRsId()) {
5629  memset(&m_RsId,UnassignedByte(),sizeof(m_RsId));
5630  }
5631 #endif
5632  m_set_State[0] |= 0x1;
5633  return m_RsId;
5634 }
5635 
5636 inline
5638 {
5639  return ((m_set_State[0] & 0xc) != 0);
5640 }
5641 
5642 inline
5644 {
5645  return IsSetBuildId();
5646 }
5647 
5648 inline
5650 {
5651  m_BuildId = 0;
5652  m_set_State[0] &= ~0xc;
5653 }
5654 
5655 inline
5657 {
5658  if (!CanGetBuildId()) {
5659  ThrowUnassigned(1);
5660  }
5661  return m_BuildId;
5662 }
5663 
5664 inline
5666 {
5667  m_BuildId = value;
5668  m_set_State[0] |= 0xc;
5669 }
5670 
5671 inline
5673 {
5674 #ifdef _DEBUG
5675  if (!IsSetBuildId()) {
5676  memset(&m_BuildId,UnassignedByte(),sizeof(m_BuildId));
5677  }
5678 #endif
5679  m_set_State[0] |= 0x4;
5680  return m_BuildId;
5681 }
5682 
5683 inline
5685 {
5686  return ((m_set_State[0] & 0x30) != 0);
5687 }
5688 
5689 inline
5691 {
5692  return IsSetOrientFlip();
5693 }
5694 
5695 inline
5697 {
5698  m_OrientFlip = 0;
5699  m_set_State[0] &= ~0x30;
5700 }
5701 
5702 inline
5704 {
5705  if (!CanGetOrientFlip()) {
5706  ThrowUnassigned(2);
5707  }
5708  return m_OrientFlip;
5709 }
5710 
5711 inline
5713 {
5714  m_OrientFlip = value;
5715  m_set_State[0] |= 0x30;
5716 }
5717 
5718 inline
5720 {
5721 #ifdef _DEBUG
5722  if (!IsSetOrientFlip()) {
5723  memset(&m_OrientFlip,UnassignedByte(),sizeof(m_OrientFlip));
5724  }
5725 #endif
5726  m_set_State[0] |= 0x10;
5727  return m_OrientFlip;
5728 }
5729 
5730 inline
5732 {
5733  return m_Attlist.NotEmpty();
5734 }
5735 
5736 inline
5738 {
5739  return true;
5740 }
5741 
5742 inline
5744 {
5745  if ( !m_Attlist ) {
5746  const_cast<C_E_MergeHistory*>(this)->ResetAttlist();
5747  }
5748  return (*m_Attlist);
5749 }
5750 
5751 inline
5753 {
5754  if ( !m_Attlist ) {
5755  ResetAttlist();
5756  }
5757  return (*m_Attlist);
5758 }
5759 
5760 inline
5762 {
5763  return ((m_set_State[0] & 0xc) != 0);
5764 }
5765 
5766 inline
5768 {
5769  return false;
5770 }
5771 
5772 inline
5774 {
5775  m_set_State[0] &= ~0xc;
5776 }
5777 
5778 inline
5780 {
5781  m_set_State[0] |= 0xc;
5782 }
5783 
5784 inline
5786 {
5787  return ((m_set_State[0] & 0x3) != 0);
5788 }
5789 
5790 inline
5792 {
5793  return IsSetAllele();
5794 }
5795 
5796 inline
5798 {
5799  if (!CanGetAllele()) {
5800  ThrowUnassigned(0);
5801  }
5802  return m_Allele;
5803 }
5804 
5805 inline
5807 {
5808  m_Allele = value;
5809  m_set_State[0] |= 0x3;
5810 }
5811 
5812 inline
5814 {
5815  m_Allele = std::forward<CRs_Base::C_E_AlleleOrigin::C_Attlist::TAllele>(value);
5816  m_set_State[0] |= 0x3;
5817 }
5818 
5819 inline
5821 {
5822 #ifdef _DEBUG
5823  if (!IsSetAllele()) {
5824  m_Allele = UnassignedString();
5825  }
5826 #endif
5827  m_set_State[0] |= 0x1;
5828  return m_Allele;
5829 }
5830 
5831 inline
5833 {
5834  return m_Attlist.NotEmpty();
5835 }
5836 
5837 inline
5839 {
5840  return true;
5841 }
5842 
5843 inline
5845 {
5846  if ( !m_Attlist ) {
5847  const_cast<C_E_AlleleOrigin*>(this)->ResetAttlist();
5848  }
5849  return (*m_Attlist);
5850 }
5851 
5852 inline
5854 {
5855  if ( !m_Attlist ) {
5856  ResetAttlist();
5857  }
5858  return (*m_Attlist);
5859 }
5860 
5861 inline
5863 {
5864  return ((m_set_State[0] & 0xc) != 0);
5865 }
5866 
5867 inline
5869 {
5870  return IsSetAlleleOrigin();
5871 }
5872 
5873 inline
5875 {
5876  m_AlleleOrigin = 0;
5877  m_set_State[0] &= ~0xc;
5878 }
5879 
5880 inline
5882 {
5883  if (!CanGetAlleleOrigin()) {
5884  ThrowUnassigned(1);
5885  }
5886  return m_AlleleOrigin;
5887 }
5888 
5889 inline
5891 {
5893  m_set_State[0] |= 0xc;
5894 }
5895 
5896 inline
5898 {
5899 #ifdef _DEBUG
5900  if (!IsSetAlleleOrigin()) {
5901  memset(&m_AlleleOrigin,UnassignedByte(),sizeof(m_AlleleOrigin));
5902  }
5903 #endif
5904  m_set_State[0] |= 0x4;
5905  return m_AlleleOrigin;
5906 }
5907 
5908 inline
5910 {
5911  return ((m_set_State[0] & 0x3) != 0);
5912 }
5913 
5914 inline
5916 {
5917  return true;
5918 }
5919 
5920 inline
5922 {
5923  return m_ClinicalSignificance;
5924 }
5925 
5926 inline