NCBI C++ ToolKit
seq_table_setters.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: seq_table_setters.cpp 74559 2016-09-13 11:58:16Z ivanov $
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 * Author: Eugene Vasilchenko
27 *
28 * File Description:
29 * CSeq_table_Info -- parsed information about Seq-table and its columns
30 *
31 */
32 
33 #include <ncbi_pch.hpp>
36 #include <serial/iterator.hpp>
37 #include <serial/objectinfo.hpp>
41 
44 
45 
46 /////////////////////////////////////////////////////////////////////////////
47 // CSeq_feat and CSeq_loc setters
48 /////////////////////////////////////////////////////////////////////////////
49 
50 
52 {
53 }
54 
55 
57 {
58  NCBI_THROW_FMT(CAnnotException, eOtherError,
59  "Incompatible Seq-feat field value: "<<value);
60 }
61 
62 
64 {
65  NCBI_THROW_FMT(CAnnotException, eOtherError,
66  "Incompatible Seq-feat field value: "<<value);
67 }
68 
69 
71 {
72  NCBI_THROW_FMT(CAnnotException, eOtherError,
73  "Incompatible Seq-feat field value: "<<value);
74 }
75 
76 
78 {
79  NCBI_THROW_FMT(CAnnotException, eOtherError,
80  "Incompatible Seq-feat field value: "<<value);
81 }
82 
83 
84 void CSeqTableSetFeatField::SetBytes(CSeq_feat&, const vector<char>& /*value*/) const
85 {
86  NCBI_THROW_FMT(CAnnotException, eOtherError,
87  "Incompatible Seq-feat field value: vector<char>");
88 }
89 
90 /////////////////////////////////////////////////////////////////////////////
91 
93 {
94 }
95 
96 
98 {
99  NCBI_THROW_FMT(CAnnotException, eOtherError,
100  "Incompatible Seq-loc field value: "<<value);
101 }
102 
103 
105 {
106  NCBI_THROW_FMT(CAnnotException, eOtherError,
107  "Incompatible Seq-loc field value: "<<value);
108 }
109 
110 
112 {
113  NCBI_THROW_FMT(CAnnotException, eOtherError,
114  "Incompatible Seq-loc field value: "<<value);
115 }
116 
117 
118 void CSeqTableSetLocField::SetString(CSeq_loc&, const string& value) const
119 {
120  NCBI_THROW_FMT(CAnnotException, eOtherError,
121  "Incompatible Seq-loc field value: "<<value);
122 }
123 
124 /////////////////////////////////////////////////////////////////////////////
125 
126 void CSeqTableSetComment::SetString(CSeq_feat& feat, const string& value) const
127 {
128  feat.SetComment(value);
129 }
130 
131 
132 void CSeqTableSetDataImpKey::SetString(CSeq_feat& feat, const string& value) const
133 {
134  feat.SetData().SetImp().SetKey(value);
135 }
136 
137 
138 void CSeqTableSetDataRegion::SetString(CSeq_feat& feat, const string& value) const
139 {
140  feat.SetData().SetRegion(value);
141 }
142 
143 
145 {
146  if ( loc.IsPnt() ) {
147  loc.SetPnt().SetFuzz().SetLim(CInt_fuzz_Base::ELim(value));
148  }
149  else if ( loc.IsInt() ) {
150  loc.SetInt().SetFuzz_from().SetLim(CInt_fuzz_Base::ELim(value));
151  }
152  else {
153  NCBI_THROW_FMT(CAnnotException, eOtherError,
154  "Incompatible fuzz field");
155  }
156 }
157 
158 
160 {
161  if ( loc.IsInt() ) {
162  loc.SetInt().SetFuzz_to().SetLim(CInt_fuzz_Base::ELim(value));
163  }
164  else {
165  NCBI_THROW_FMT(CAnnotException, eOtherError,
166  "Incompatible fuzz field");
167  }
168 }
169 
170 
171 void CSeqTableSetQual::SetString(CSeq_feat& feat, const string& value) const
172 {
173  CRef<CGb_qual> qual(new CGb_qual);
174  qual->SetQual(name);
175  qual->SetVal(value);
176  feat.SetQual().push_back(qual);
177 }
178 
179 
181  : name(fullname.substr(2))
182 {
183  if ( name.find('.') != NPOS ) {
184  NStr::Split(name, ".", subfields);
185  name = subfields.back();
186  subfields.pop_back();
187  }
188 }
189 
190 
192 {
193  CUser_object::TData* data = &feat.SetExt().SetData();
194  ITERATE ( TSubfields, it, subfields ) {
195  CUser_object::TData* next_data = 0;
197  const CObject_id& id = (*it2)->GetLabel();
198  CUser_field::TData& data2 = (*it2)->SetData();
199  if ( data2.IsFields() && id.IsStr() && id.GetStr() == *it ) {
200  next_data = &data2.SetFields();
201  break;
202  }
203  }
204  if ( !next_data ) {
205  CRef<CUser_field> field(new CUser_field());
206  data->push_back(field);
207  field->SetLabel().SetStr(*it);
208  next_data = &field->SetData().SetFields();
209  }
210  data = next_data;
211  }
212  CRef<CUser_field> field(new CUser_field);
213  field->SetLabel().SetStr(name);
214  data->push_back(field);
215  return *field;
216 }
217 
218 
220 {
221  x_SetField(feat).SetData().SetInt(value);
222 }
223 
224 
226 {
227  // TODO: Int8 in User-field
228  x_SetField(feat).SetData().SetInt((int)value);
229 }
230 
231 
232 void CSeqTableSetExt::SetReal(CSeq_feat& feat, double value) const
233 {
234  x_SetField(feat).SetData().SetReal(value);
235 }
236 
237 
238 void CSeqTableSetExt::SetString(CSeq_feat& feat, const string& value) const
239 {
240  x_SetField(feat).SetData().SetStr(value);
241 }
242 
243 
244 void CSeqTableSetExt::SetBytes(CSeq_feat& feat, const vector<char>& value) const
245 {
246  x_SetField(feat).SetData().SetOs() = value;
247 }
248 
249 
251 {
252  CRef<CDbtag> dbtag(new CDbtag);
253  dbtag->SetDb(name);
254  dbtag->SetTag().SetId(value);
255  feat.SetDbxref().push_back(dbtag);
256 }
257 
258 
260 {
261  CRef<CDbtag> dbtag(new CDbtag);
262  dbtag->SetDb(name);
263  dbtag->SetTag().SetId8(value);
264  feat.SetDbxref().push_back(dbtag);
265 }
266 
267 
268 void CSeqTableSetDbxref::SetString(CSeq_feat& feat, const string& value) const
269 {
270  CRef<CDbtag> dbtag(new CDbtag);
271  dbtag->SetDb(name);
272  dbtag->SetTag().SetStr(value);
273  feat.SetDbxref().push_back(dbtag);
274 }
275 
276 
278 {
279  feat.SetExt().SetType().SetId(value);
280 }
281 
282 
284 {
285  feat.SetExt().SetType().SetId8(value);
286 }
287 
288 
289 void CSeqTableSetExtType::SetString(CSeq_feat& feat, const string& value) const
290 {
291  feat.SetExt().SetType().SetStr(value);
292 }
293 
294 
295 /////////////////////////////////////////////////////////////////////////////
296 // CSeqTableSetAnyField
297 /////////////////////////////////////////////////////////////////////////////
298 
299 
302 {
303  return obj.SetPointedObject();
304 }
305 
306 
309 {
310  return obj.AddNewPointedElement();
311 }
312 
313 
316 {
317  return obj.AddNewElement();
318 }
319 
320 
323 {
324  return obj.SetClassMember(m_MemberIndex);
325 }
326 
327 
330 {
331  return obj.SetChoiceVariant(m_VariantIndex);
332 }
333 
334 
337 {
338  CUser_field& field = *CType<CUser_field>::Get(obj);
339  field.SetLabel().SetStr(m_FieldName);
340  return obj;
341 }
342 
343 
345  CTempString field)
346  : m_SetFinalObject(false)
347 {
349  for ( ;; ) {
350  switch ( type.GetTypeFamily() ) {
351  default:
352  NCBI_THROW_FMT(CAnnotException, eOtherError,
353  "Incompatible field: "<<
354  type.GetTypeInfo()->GetName()<<" "<<field);
355  return;
356  case eTypeFamilyPointer:
357  next.Reset(new CSeqTableNextObjectPointer());
358  type = type.GetPointedType();
359  break;
361  type = type.GetElementType();
362  if ( type.GetTypeFamily() == eTypeFamilyPointer ) {
364  type = type.GetPointedType();
365  }
366  else {
367  next.Reset(new CSeqTableNextObjectElementNew());
368  }
369  break;
371  if ( !field.empty() ) {
372  NCBI_THROW_FMT(CAnnotException, eOtherError,
373  "Incompatible field: "<<
374  type.GetTypeInfo()->GetName()<<"."<<field);
375  return;
376  }
377  m_SetFinalObject = true;
378  return;
379  case eTypeFamilyClass:
380  case eTypeFamilyChoice:
381  if ( field.empty() ) {
382  // no fields to set in the class
383  return;
384  }
385  else {
386  size_t dot = field.find('.');
387  CTempString field_name = field;
388  CTempString next_field;
389  if ( dot != CTempString::npos ) {
390  field_name = field.substr(0, dot);
391  next_field = field.substr(dot+1);
392  }
393  field = next_field;
394  if ( type.GetTypeFamily() == eTypeFamilyClass ) {
395  TMemberIndex index = type.FindMemberIndex(field_name);
396  if ( index != kInvalidMember ) {
398  type = type.GetClassTypeInfo()->GetMemberInfo(index)
399  ->GetTypeInfo();
400  }
401  else if ( type == CType<CUser_field>() ) {
402  m_SetUserField = field_name;
403  return;
404  }
405  else {
406  NCBI_THROW_FMT(CAnnotException, eOtherError,
407  "Unknown field: "<<
408  type.GetTypeInfo()->GetName()<<"."<<
409  field_name);
410  return;
411  }
412  }
413  else {
414  TMemberIndex index = type.FindVariantIndex(field_name);
415  if ( index == kInvalidMember ) {
416  NCBI_THROW_FMT(CAnnotException, eOtherError,
417  "Unknown variant: "<<
418  type.GetTypeInfo()->GetName()<<"."<<
419  field_name);
420  return;
421  }
422  next.Reset(new CSeqTableNextObjectChoiceVariant(index));
423  type = type.GetChoiceTypeInfo()->GetVariantInfo(index)
424  ->GetTypeInfo();
425  }
426  }
427  break;
428  }
429  m_Nexters.push_back(next);
430  }
431 }
432 
433 
435  int value) const
436 {
437  ITERATE ( TNexters, it, m_Nexters ) {
438  obj = (*it)->GetNextObject(obj);
439  }
440  if ( !m_SetUserField.empty() ) {
441  CUser_field* field = CType<CUser_field>::Get(obj);
442  field->SetLabel().SetStr(m_SetUserField);
443  field->SetData().SetInt(value);
444  }
445  else if ( m_SetFinalObject ) {
447  }
448 }
449 
450 
452  Int8 value) const
453 {
454  ITERATE ( TNexters, it, m_Nexters ) {
455  obj = (*it)->GetNextObject(obj);
456  }
457  if ( !m_SetUserField.empty() ) {
458  CUser_field* field = CType<CUser_field>::Get(obj);
459  field->SetLabel().SetStr(m_SetUserField);
460  // TODO: Int8 in User-field
461  field->SetData().SetInt(int(value));
462  }
463  else if ( m_SetFinalObject ) {
465  }
466 }
467 
468 
470  double value) const
471 {
472  ITERATE ( TNexters, it, m_Nexters ) {
473  obj = (*it)->GetNextObject(obj);
474  }
475  if ( !m_SetUserField.empty() ) {
476  CUser_field* field = CType<CUser_field>::Get(obj);
477  field->SetLabel().SetStr(m_SetUserField);
478  field->SetData().SetReal(value);
479  }
480  else {
482  }
483 }
484 
485 
487  const string& value) const
488 {
489  ITERATE ( TNexters, it, m_Nexters ) {
490  obj = (*it)->GetNextObject(obj);
491  }
492  if ( !m_SetUserField.empty() ) {
493  CUser_field* field = CType<CUser_field>::Get(obj);
494  field->SetLabel().SetStr(m_SetUserField);
495  field->SetData().SetStr(value);
496  }
497  else {
499  }
500 }
501 
502 
504  const vector<char>& value) const
505 {
506  ITERATE ( TNexters, it, m_Nexters ) {
507  obj = (*it)->GetNextObject(obj);
508  }
509  if ( !m_SetUserField.empty() ) {
510  CUser_field* field = CType<CUser_field>::Get(obj);
511  field->SetLabel().SetStr(m_SetUserField);
512  field->SetData().SetOs() = value;
513  }
514  else {
516  }
517 }
518 
519 
521  : CSeqTableSetAnyObjField(CSeq_loc::GetTypeInfo(), field)
522 {
523 }
524 
525 
527 {
528  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
529 }
530 
531 
533 {
534  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
535 }
536 
537 
539 {
540  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
541 }
542 
543 
544 void CSeqTableSetAnyLocField::SetString(CSeq_loc& obj, const string& value) const
545 {
546  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
547 }
548 
549 
550 void CSeqTableSetAnyLocField::SetBytes(CSeq_loc& obj, const vector<char>& value) const
551 {
552  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
553 }
554 
555 
557  : CSeqTableSetAnyObjField(CSeq_feat::GetTypeInfo(), field)
558 {
559 }
560 
561 
563 {
564  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
565 }
566 
567 
569 {
570  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
571 }
572 
573 
575 {
576  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
577 }
578 
579 
580 void CSeqTableSetAnyFeatField::SetString(CSeq_feat& obj, const string& value) const
581 {
582  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
583 }
584 
585 
586 void CSeqTableSetAnyFeatField::SetBytes(CSeq_feat& obj, const vector<char>& value) const
587 {
588  SetObjectField(CObjectInfo(&obj, obj.GetTypeInfo()), value);
589 }
590 
591 
Annotation iterators exceptions.
CConstRef –.
Definition: ncbiobj.hpp:1266
Definition: Dbtag.hpp:53
@Gb_qual.hpp User-defined methods of the data storage class.
Definition: Gb_qual.hpp:61
CObjectInfo –.
Definition: objectinfo.hpp:597
CObjectTypeInfo –.
Definition: objectinfo.hpp:94
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual CObjectInfo GetNextObject(const CObjectInfo &obj) const
virtual void SetBytes(CSeq_feat &feat, const vector< char > &value) const
CSeqTableSetAnyFeatField(const CTempString &field)
virtual void SetReal(CSeq_feat &feat, double value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetInt8(CSeq_feat &feat, Int8 value) const
virtual void SetInt(CSeq_feat &feat, int value) const
virtual void SetString(CSeq_loc &loc, const string &value) const
virtual void SetReal(CSeq_loc &loc, double value) const
virtual void SetBytes(CSeq_loc &loc, const vector< char > &value) const
virtual void SetInt(CSeq_loc &loc, int value) const
CSeqTableSetAnyLocField(const CTempString &field)
virtual void SetInt8(CSeq_loc &loc, Int8 value) const
CSeqTableSetAnyObjField(CObjectTypeInfo type, CTempString field)
vector< CConstRef< CSeqTableNextObject > > TNexters
void SetObjectField(CObjectInfo obj, int value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetInt(CSeq_feat &feat, int value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetInt8(CSeq_feat &feat, Int8 value) const
virtual void SetInt8(CSeq_feat &feat, Int8 value) const
virtual void SetInt(CSeq_feat &feat, int value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetBytes(CSeq_feat &feat, const vector< char > &value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetInt8(CSeq_feat &feat, Int8 value) const
virtual void SetInt(CSeq_feat &feat, int value) const
vector< string > TSubfields
CUser_field & x_SetField(CSeq_feat &feat) const
virtual void SetReal(CSeq_feat &feat, double value) const
CSeqTableSetExt(const CTempString &name)
virtual void SetString(CSeq_feat &feat, const string &value) const
virtual void SetInt8(CSeq_feat &feat, Int8 value) const
virtual void SetBytes(CSeq_feat &feat, const vector< char > &value) const
virtual void SetReal(CSeq_feat &feat, double value) const
virtual void SetInt(CSeq_feat &feat, int value) const
virtual void SetInt8(CSeq_loc &loc, Int8 value) const
virtual void SetInt(CSeq_loc &loc, int value) const
virtual void SetReal(CSeq_loc &loc, double value) const
virtual void SetString(CSeq_loc &loc, const string &value) const
virtual void SetInt(CSeq_loc &loc, int value) const
virtual void SetInt(CSeq_loc &loc, int value) const
virtual void SetString(CSeq_feat &feat, const string &value) const
namespace ncbi::objects::
Definition: Seq_feat.hpp:58
CTempString implements a light-weight string on top of a storage buffer whose lifetime management is ...
Definition: tempstr.hpp:65
#define false
Definition: bool.h:36
static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)
Definition: dlist.tmpl.h:56
char data[12]
Definition: iconv.c:80
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
Definition: ncbimisc.hpp:815
#define NON_CONST_ITERATE(Type, Var, Cont)
Non constant version of ITERATE macro.
Definition: ncbimisc.hpp:822
#define NCBI_THROW_FMT(exception_class, err_code, message)
The same as NCBI_THROW but with message processed as output to ostream.
Definition: ncbiexpt.hpp:719
size_t TMemberIndex
Type used for indexing class members and choice variants.
Definition: serialdef.hpp:230
const TMemberIndex kInvalidMember
Special value returned from FindMember.
Definition: serialdef.hpp:237
@ eTypeFamilyClass
Definition: serialdef.hpp:140
@ eTypeFamilyContainer
Definition: serialdef.hpp:142
@ eTypeFamilyChoice
Definition: serialdef.hpp:141
@ eTypeFamilyPointer
Definition: serialdef.hpp:143
@ eTypeFamilyPrimitive
Definition: serialdef.hpp:139
void SetPnt(TPnt &v)
Definition: Seq_loc.hpp:985
void SetInt(TInt &v)
Definition: Seq_loc.hpp:983
static C * Get(const CTypesIterator &it)
Definition: objecttype.hpp:116
CObjectInfo AddNewPointedElement(void) const
add new pointer element, create new pointed object and return it
Definition: objectinfo.cpp:329
TObjectPtr GetObjectPtr(void) const
Get pointer to object.
const CPrimitiveTypeInfo * GetPrimitiveTypeInfo(void) const
Definition: objectinfo.cpp:49
CObjectInfo AddNewElement(void) const
Add and return new element object.
Definition: objectinfo.cpp:321
CObjectInfo SetChoiceVariant(TMemberIndex index) const
Select choice variant, if necessary, and return variant object.
Definition: objectinfo.cpp:355
CObjectInfo SetClassMember(TMemberIndex index) const
Create member if necessary and return member object.
Definition: objectinfo.cpp:345
CObjectInfo SetPointedObject(void) const
Create if necessary and return pointed object.
Definition: objectinfo.cpp:307
int64_t Int8
8-byte (64-bit) signed integer
Definition: ncbitype.h:104
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define END_SCOPE(ns)
End the previously defined scope.
Definition: ncbistl.hpp:75
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
#define BEGIN_SCOPE(ns)
Define a new scope.
Definition: ncbistl.hpp:72
static list< string > & Split(const CTempString str, const CTempString delim, list< string > &arr, TSplitFlags flags=0, vector< SIZE_TYPE > *token_pos=NULL)
Split a string using specified delimiters.
Definition: ncbistr.cpp:3461
#define NPOS
Definition: ncbistr.hpp:133
bool empty(void) const
Return true if the represented string is empty (i.e., the length is zero)
Definition: tempstr.hpp:334
CTempString substr(size_type pos) const
Obtain a substring from this string, beginning at a given offset.
Definition: tempstr.hpp:776
size_type find(const CTempString match, size_type pos=0) const
Find the first instance of the entire matching string within the current string, beginning at an opti...
Definition: tempstr.hpp:655
static const size_type npos
Definition: tempstr.hpp:72
void SetValueInt(TObjectPtr objectPtr, int value) const
virtual void SetValueInt8(TObjectPtr objectPtr, Int8 value) const
Definition: stdtypes.cpp:451
virtual void SetValueOctetString(TObjectPtr objectPtr, const vector< char > &value) const
Definition: stdtypes.cpp:519
virtual void SetValueDouble(TObjectPtr objectPtr, double value) const
Definition: stdtypes.cpp:475
virtual void SetValueString(TObjectPtr objectPtr, const string &value) const
Definition: stdtypes.cpp:507
TFields & SetFields(void)
Select the variant.
void SetTag(TTag &value)
Assign a value to Tag data member.
Definition: Dbtag_.cpp:66
bool IsFields(void) const
Check if variant Fields is selected.
ELim
some limit value
Definition: Int_fuzz_.hpp:209
void SetLabel(TLabel &value)
Assign a value to Label data member.
void SetData(TData &value)
Assign a value to Data data member.
void SetDb(const TDb &value)
Assign a value to Db data member.
Definition: Dbtag_.hpp:229
vector< CRef< CUser_field > > TData
void SetQual(const TQual &value)
Assign a value to Qual data member.
Definition: Gb_qual_.hpp:221
TDbxref & SetDbxref(void)
Assign a value to Dbxref data member.
Definition: Seq_feat_.hpp:1339
void SetComment(const TComment &value)
Assign a value to Comment data member.
Definition: Seq_feat_.hpp:1058
void SetExt(TExt &value)
Assign a value to Ext data member.
Definition: Seq_feat_.cpp:153
void SetData(TData &value)
Assign a value to Data data member.
Definition: Seq_feat_.cpp:94
void SetVal(const TVal &value)
Assign a value to Val data member.
Definition: Gb_qual_.hpp:268
TQual & SetQual(void)
Assign a value to Qual data member.
Definition: Seq_feat_.hpp:1153
bool IsInt(void) const
Check if variant Int is selected.
Definition: Seq_loc_.hpp:528
bool IsPnt(void) const
Check if variant Pnt is selected.
Definition: Seq_loc_.hpp:540
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1227
Definition: type.c:6
Modified on Sun Apr 14 05:27:59 2024 by modify_doxy.py rev. 669887