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

Go to the SVN repository for this file.

1 #include <ncbi_pch.hpp>
3 
6 
7 template <typename T>
9 {
10  return Ref(new T());
11 }
12 
13 template<class T>
15 {
16  return result.IsNull() ? Ref(new T()) : result;
17 }
18 
20 {
22 }
23 
25 {
27 }
28 
29 void AssignRefSeqIdentifier(const string& identifier, CRef<CVariantExpression>& result)
30 {
32  result->SetReference_id(identifier.substr(0,identifier.size()-1));
33 }
34 
35 
37 {
39  result->SetSequence_variant(variant.GetNCObject());
40 }
41 
42 
44  const CProteinSub::TFinal& final,
46 {
48  auto& sub = result->SetType().SetProt_sub();
49 
50  sub.SetType(CProteinSub::eType_missense);
51  sub.SetInitial(*initial);
52  sub.SetFinal(final);
53 }
54 
55 
58 {
60  result->SetType().SetProt_silent(*loc);
61 }
62 
63 
65 {
67 
68  result->SetType().SetProt_sub().SetType(CProteinSub::eType_nonsense);
69  result->SetType().SetProt_sub().SetInitial(*initial);
70 }
71 
72 
74 {
76 
77  result->SetType().SetProt_sub().SetType(CProteinSub::eType_unknown);
78  result->SetType().SetProt_sub().SetInitial(*initial);
79 }
80 
81 
83 {
85  result->SetType().SetDup().SetLoc().SetAaloc(*aa_loc);
86 }
87 
88 
90 {
92  result->SetType().SetDel().SetLoc().SetAaloc(*aa_loc);
93 }
94 
95 
97 {
99  result->SetType().SetProt_ext().SetNterm_ext().SetNewStart(*new_start_site);
100 
101 }
102 
103 void AssignNtermExtension(CRef<CAaSite> initial_start_site, const string& new_aa, CRef<CCount> new_start_site, CRef<CSimpleVariant>& result)
104 {
105  AssignNtermExtension(initial_start_site, new_start_site, result);
106  result->SetType().SetProt_ext().SetNterm_ext().SetNewAa(new_aa);
107 }
108 
109 
110 void AssignCtermExtension(const string& reference_stop, const string& aa, CRef<CCount> length, CRef<CSimpleVariant>& result)
111 {
112 
113  const auto index = NStr::StringToNumeric<TSeqPos>(reference_stop);
115 
116  auto& cterm_ext = result->SetType().SetProt_ext().SetCterm_ext();
117  cterm_ext.SetRefStop(index);
118  cterm_ext.SetNewAa(aa);
119  cterm_ext.SetLength(*length);
120 }
121 
122 
124 {
126  result->SetInt(*aa_interval);
127 }
128 
129 
131 {
133  result->SetSite(*aa_site);
134 }
135 
136 
138 {
140  result->SetStart(*start);
141  result->SetStop(*stop);
142 }
143 
144 
145 void AssignAaSite(const string& aa, const string& pos, CRef<CAaSite>& result)
146 {
148  auto index = NStr::StringToNumeric<CAaSite::TIndex>(pos);
149  // Try ... catch here?
150 
151  result->SetAa(aa);
152  result->SetIndex(index);
153 }
154 
155 
156 void AssignCount(const string& count, CRef<CCount>& result)
157 {
159 
160  if ( count == "?" ) {
161  result->SetUnknown(); // LCOV_EXCL_LINE - Don't know how to represent this in ASN.1
162  }
163  else {
164  const auto val = NStr::StringToNumeric<CCount::TVal>(count);
165  result->SetVal(val);
166  }
167 }
168 
169 
170 void AssignFuzzyCount(const string& count, CRef<CCount>& result)
171 {
173  const auto len = count.size();
174  const auto c = NStr::StringToNumeric<CCount::TVal>(count.substr(1,len-2));
175  result->SetFuzzy_val(c);
176 }
177 
178 
179 void AssignCountRange(const string& start, const string& stop, CRef<CCount>& result)
180 {
182  if ( start == "?" ) {
183  result->SetRange().SetStart().SetUnknown(); // LCOV_EXCL_LINE - No ASN.1 representation
184  }
185  else {
186  const auto start_val = NStr::StringToNumeric<CCount::TVal>(start);
187  result->SetRange().SetStart().SetVal(start_val);
188  }
189 
190  if ( stop == "?" ) {
191  result->SetRange().SetStop().SetUnknown();
192  }
193  else {
194  const auto stop_val = NStr::StringToNumeric<CCount::TVal>(stop);
195  result->SetRange().SetStop().SetVal(stop_val);
196  }
197 }
198 
199 
201 {
203 
204  auto& ssr = result->SetType().SetRepeat();
205 
206  ssr.SetLoc().SetAaloc(*aa_loc);
207  ssr.SetCount(*count);
208 }
209 
210 
212  const CInsertion::TSeqinfo::TRaw_seq& raw_seq,
214 {
216  result->SetType().SetIns().SetInt().SetAaint(*aa_interval);
217  result->SetType().SetIns().SetSeqinfo().SetRaw_seq(raw_seq);
218 }
219 
220 
222 {
224 
225  auto& insertion = result->SetType().SetIns();
226 
227  insertion.SetInt().SetAaint(*aa_interval);
228  insertion.SetSeqinfo().SetCount(*seq_size);
229 }
230 
231 
233 {
235  result->SetType().SetFrameshift().SetAasite(*aa_site);
236 }
237 
238 
240  const CInsertion::TSeqinfo::TRaw_seq& raw_seq,
242 {
244 
245  auto& delins = result->SetType().SetDelins();
246 
247  delins.SetLoc().SetAaloc(*aa_loc);
248  delins.SetInserted_seq_info().SetRaw_seq(raw_seq);
249 }
250 
251 
253 {
255 
256  auto& delins = result->SetType().SetDelins();
257  delins.SetLoc().SetAaloc(*aa_loc);
258  delins.SetInserted_seq_info().SetCount(*seq_size);
259 }
260 
261 
262 template <typename T>
264 {
265  result = input;
266  result->SetFuzzy();
267 }
268 
269 
271 {
273 }
274 
275 
277 {
279  result->SetSimple(*simple_var);
280 }
281 
282 
284 {
286  result->SetSpecial() = special_variant;
287 }
288 
289 
291 {
293  result->SetSubvariants().push_back(variant);
294 }
295 
296 
298 {
300  result->SetSeqtype(eVariantSeqType_p);
301 }
302 
303 
304 // Nucleotide-specific functions
305 void AssignSimpleNtSite(const string& site_index, CRef<CNtSite>& result)
306 {
308  if (site_index == "?") {
309  result->SetBase().SetUnknown();
310  return;
311  }
312  const auto base_val = NStr::StringToNumeric<CNtSite::TBase::TVal>(site_index);
313  result->SetBase().SetVal(base_val);
314 }
315 
316 
318 {
319  result = center_site;
320  result->ResetFuzzy();
321 }
322 
323 
324 void AssignFuzzySimpleNtSite(const string& site_index, CRef<CNtSite>& result)
325 {
326  auto center_site = site_index;
327 
328  NStr::ReplaceInPlace(center_site, "(", "");
329  NStr::ReplaceInPlace(center_site, ")", "");
330 
331  AssignSimpleNtSite(center_site, result);
332  result->SetFuzzy();
333 }
334 
335 
336 void AssignIntronSite(const string& base, const string& offset, CRef<CNtSite>& result)
337 {
339 
340  if (base == "?") {
341  result->SetBase().SetUnknown(); // LCOV_EXCL_LINE - Does not parse
342  }
343  else {
344  const auto base_val = NStr::StringToNumeric<CNtSite::TBase::TVal>(base);
345  result->SetBase().SetVal(base_val);
346  }
347 
348  if (offset == "+?") {
349  result->SetOffset().SetPlus_unknown();
350  return;
351  }
352 
353  if (offset == "-?") {
354  result->SetOffset().SetMinus_unknown();
355  return;
356  }
357 
358 
359  if (base.front() == '(' && offset.back() == ')') {
360  result->SetFuzzy(); // LCOV_EXCL_LINE - not represented in ASN.1 Generates the same representation as x+(y)
361  }
362  else if (offset.size() >= 2 &&
363  offset[1] == '('
364  && offset.back() == ')') {
365  result->SetFuzzy_offset();
366  }
367 
368  auto offset_value = offset;
369  NStr::ReplaceInPlace(offset_value, "(", "");
370  NStr::ReplaceInPlace(offset_value, ")", "");
371  result->SetOffset().SetVal(NStr::StringToNumeric<CNtSite::TOffset::TVal>(offset_value));
372 }
373 
374 
376 {
377  result = Ref(nt_site.GetPointer());
378  result->SetUtr().SetFive_prime();
379 }
380 
381 
383 {
384  result = Ref(nt_site.GetPointer());
385  result->SetUtr().SetThree_prime();
386 }
387 
388 
390 {
392  result->SetRange().SetStart(*start);
393  result->SetRange().SetStop(*stop);
394 }
395 
397 {
399  result->SetSite(*nt_site);
400 }
401 
403 {
405  if (start->IsSite()) {
406  result->SetInt().SetStart().SetSite(start->SetSite());
407  }
408  else if (start->IsRange()) {
409  result->SetInt().SetStart().SetRange(start->SetRange());
410  }
411  if (stop->IsSite()) {
412  result->SetInt().SetStop().SetSite(stop->SetSite());
413  }
414  else if (stop->IsRange()) {
415  result->SetInt().SetStop().SetRange(stop->SetRange());
416  }
417 }
418 
419 
420 void s_SetSequenceInfo(CRef<CNtLocation>& nt_loc, const string& identifier, const EVariantSeqType& seq_type)
421 {
422  if (nt_loc->IsSite()) {
423  bool is_minus_strand = (identifier[0] == 'o');
424  const string seq_id = is_minus_strand ? identifier.substr(1) : identifier;
425  nt_loc->SetSite().SetSeqid(seq_id);
426  nt_loc->SetSite().SetSeqtype(seq_type);
427  nt_loc->SetSite().SetStrand_minus(is_minus_strand);
428  }
429  else if (nt_loc->IsRange()) {
430  auto start_loc = Ref(new CNtLocation());
431  start_loc->SetSite(nt_loc->SetRange().SetStart());
432  s_SetSequenceInfo(start_loc, identifier, seq_type);
433 
434  auto stop_loc = Ref(new CNtLocation());
435  stop_loc->SetSite(nt_loc->SetRange().SetStop());
436  s_SetSequenceInfo(stop_loc, identifier, seq_type);
437  }
438  else if (nt_loc->IsInt()) {
439  auto start_loc = Ref(new CNtLocation());
440  if (nt_loc->GetInt().GetStart().IsSite()) {
441  start_loc->SetSite(nt_loc->SetInt().SetStart().SetSite());
442  }
443  else {
444  start_loc->SetRange(nt_loc->SetInt().SetStart().SetRange());
445  }
446  s_SetSequenceInfo(start_loc, identifier, seq_type);
447 
448  auto stop_loc = Ref(new CNtLocation());
449  if (nt_loc->GetInt().GetStop().IsSite()) {
450  stop_loc->SetSite(nt_loc->SetInt().SetStop().SetSite());
451  }
452  else {
453  stop_loc->SetRange(nt_loc->SetInt().SetStop().SetRange());
454  }
455  s_SetSequenceInfo(stop_loc, identifier, seq_type);
456  }
457 
458  return;
459 }
460 
461 
463 {
464  if (type_string == "g.") {
465  return eVariantSeqType_g;
466  }
467 
468  if (type_string == "c.") {
469  return eVariantSeqType_c;
470  }
471 
472  if (type_string == "p.") { // LCOV_EXCL_START - currently, this function is only used on genomic sequences
473  return eVariantSeqType_p;
474  } // LCOV_EXCL_STOP
475 
476  if (type_string == "r.") {
477  return eVariantSeqType_r;
478  }
479 
480  if (type_string == "m.") {
481  return eVariantSeqType_m;
482  }
483 
484  if (type_string == "n.") {
485  return eVariantSeqType_n;
486  }
487 
488  return eVariantSeqType_u; // LCOV_EXCL_LINE - unknown type not not occur
489 }
490 
491 
492 void AssignNtRemoteLocation(const string& identifier, const string& type_string, CRef<CNtLocation>& nt_loc, CRef<CNtLocation>& result)
493 {
494  result = Ref(nt_loc.GetPointer());
495  const string seq_id = identifier.substr(0,identifier.size()-1);
496  const EVariantSeqType seq_type = s_GetSeqType(type_string);
497 
498  s_SetSequenceInfo(result, seq_id, seq_type);
499 }
500 
501 
503 {
505  result->SetType().SetRepeat().SetLoc().SetNtloc(*nt_loc);
506  result->SetType().SetRepeat().SetCount(*count);
507 }
508 
509 
511 {
513  result->SetType().SetRepeat().SetLoc().SetNtloc(*nt_loc);
514  result->SetType().SetRepeat().SetCount(*count);
515  if (raw_seq.empty()) {
516  return;
517  }
518  result->SetType().SetRepeat().SetRaw_seq(raw_seq);
519 }
520 
521 
523 {
525  result->SetType().SetInv().SetNtint(nt_loc->SetInt());
526 
527  if (raw_seq.empty()) {
528  return;
529  }
530  result->SetType().SetInv().SetRaw_seq(raw_seq);
531 }
532 
533 
535 {
537  result->SetType().SetInv().SetNtint(nt_loc->SetInt());
538 }
539 
540 
542 {
543  AssignNtInv(nt_loc, result);
544  result->SetType().SetInv().SetSize(NStr::StringToNumeric<CInversion::TSize>(size));
545 }
546 
547 
549 {
551  result->SetType().SetConv().SetLoc(nt_loc.GetNCObject());
552  result->SetType().SetConv().SetOrigin(origin.GetNCObject());
553 }
554 
555 
556 
558 {
560  result->SetType().SetIns().SetInt().SetNtint(nt_loc->SetInt());
561 
562  if (raw_seq.empty()) {
563  return;
564  }
565  result->SetType().SetIns().SetSeqinfo().SetRaw_seq(raw_seq);
566 }
567 
568 
570 {
572  result->SetType().SetDel().SetLoc().SetNtloc(*nt_loc);
573 }
574 
575 
577 {
579  result->SetType().SetDel().SetLoc().SetNtloc(*nt_loc);
580  if (raw_seq.empty()) {
581  return;
582  }
583  result->SetType().SetDel().SetRaw_seq(raw_seq);
584 }
585 
586 
588 {
590  result->SetType().SetDelins().SetLoc().SetNtloc(*nt_loc);
591  if (inserted_seq.empty()) {
592  return;
593  }
594  result->SetType().SetDelins().SetInserted_seq_info().SetRaw_seq(inserted_seq);
595 }
596 
597 
599  const CDeletion::TRaw_seq& deleted_seq,
600  const CInsertion::TSeqinfo::TRaw_seq& inserted_seq,
602 {
603  AssignNtDelins(nt_loc, inserted_seq, result);
604 
605  if (deleted_seq.empty()) {
606  return;
607  }
608  result->SetType().SetDelins().SetDeleted_raw_seq(deleted_seq);
609 }
610 
611 
613 {
615  result->SetType().SetDup().SetLoc().SetNtloc(*nt_loc);
616 }
617 
618 
620 {
622  result->SetType().SetDup().SetLoc().SetNtloc(*nt_loc);
623  if (raw_seq.empty()) {
624  return;
625  }
626  result->SetType().SetDup().SetRaw_seq(raw_seq);
627 }
628 
629 
631  const CNaSub::TInitial& initial_nt,
632  const CNaSub::TFinal& final_nt,
634 {
636  result->SetType().SetNa_sub().SetLoc(*nt_loc);
637  result->SetType().SetNa_sub().SetInitial(initial_nt);
638  result->SetType().SetNa_sub().SetFinal(final_nt);
639 }
640 
641 
643  const CNaIdentity::TNucleotide& nucleotide,
645 {
647  result->SetType().SetNa_identity().SetLoc(*nt_loc);
648  result->SetType().SetNa_identity().SetNucleotide(nucleotide);
649 }
650 
651 
654 {
656  result->SetType().SetNa_identity().SetLoc(*nt_loc);
657 }
658 
659 
661 {
663  auto seq_type = s_GetSeqType(type_string);
664  result->SetSeqtype(seq_type);
665 }
666 
669 
670 
CNtLocation –.
Definition: NtLocation.hpp:66
#define T(s)
Definition: common.h:230
int offset
Definition: replacements.h:160
CRef< C > Ref(C *object)
Helper functions to get CRef<> and CConstRef<> objects.
Definition: ncbiobj.hpp:2015
TObjectType * GetPointer(void) THROWS_NONE
Get pointer,.
Definition: ncbiobj.hpp:998
TObjectType & GetNCObject(void) const
Get object.
Definition: ncbiobj.hpp:1187
#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 string & ReplaceInPlace(string &src, const string &search, const string &replace, SIZE_TYPE start_pos=0, SIZE_TYPE max_replace=0, SIZE_TYPE *num_replace=0)
Replace occurrences of a substring within a string.
Definition: ncbistr.cpp:3405
ESpecialVariant
Access to ESpecialVariant's attributes (values, names) as defined in spec.
string TRaw_seq
Definition: Deletion_.hpp:90
EVariantSeqType
Access to EVariantSeqType's attributes (values, names) as defined in spec.
const TStart & GetStart(void) const
Get the Start member data.
void SetStrand_minus(TStrand_minus value)
Assign a value to Strand_minus data member.
Definition: NtSite_.hpp:1251
TInt & SetInt(void)
Select the variant.
void SetSeqtype(TSeqtype value)
Assign a value to Seqtype data member.
Definition: NtSite_.hpp:1129
bool IsSite(void) const
Check if variant Site is selected.
const TInt & GetInt(void) const
Get the variant data.
bool IsInt(void) const
Check if variant Int is selected.
void SetStart(TStart &value)
Assign a value to Start data member.
Definition: NtInterval_.cpp:60
string TFinal
Definition: NaSub_.hpp:91
bool IsRange(void) const
Check if variant Range is selected.
void SetComplex(TComplex value)
Assign a value to Complex data member.
TRange & SetRange(void)
Select the variant.
void SetStop(TStop &value)
Assign a value to Stop data member.
bool IsSite(void) const
Check if variant Site is selected.
TSite & SetSite(void)
Select the variant.
void SetStop(TStop &value)
Assign a value to Stop data member.
Definition: NtInterval_.cpp:74
string TRaw_seq
Definition: Repeat_.hpp:92
void SetStart(TStart &value)
Assign a value to Start data member.
string TInitial
Definition: NaSub_.hpp:90
const TStop & GetStop(void) const
Get the Stop member data.
void SetSeqid(const TSeqid &value)
Assign a value to Seqid data member.
Definition: NtSite_.hpp:1075
@ eVariantSeqType_n
non-coding rna
@ eVariantSeqType_p
protein
@ eVariantSeqType_g
genomic
@ eVariantSeqType_m
mitochondrial
@ eVariantSeqType_c
coding
@ eVariantSeqType_r
rna
@ eVariantSeqType_u
unknown
static int input()
int len
const struct ncbi::grid::netcache::search::fields::SIZE size
static const GLdouble origin[]
void AssignAaIntervalLocation(CRef< CAaInterval > aa_interval, CRef< CAaLocation > &result)
void AssignNtInterval(CRef< CNtLocation > start, CRef< CNtLocation > stop, CRef< CNtLocation > &result)
void TagAsMosaic(CRef< CSequenceVariant > seq_var)
void AssignFuzzyCount(const string &count, CRef< CCount > &result)
void AssignUnknownSub(CRef< CAaSite > initial, CRef< CSimpleVariant > &result)
CRef< T > MakeResult(CRef< T > result)
void AssignSequenceVariant(CRef< CSequenceVariant > variant, CRef< CVariantExpression > &result)
void AssignFuzzySimpleNtSite(const string &site_index, CRef< CNtSite > &result)
void AssignFrameshift(CRef< CAaSite > aa_site, CRef< CSimpleVariant > &result)
void AssignSingleVariation(CRef< CVariant > variant, CRef< CSequenceVariant > &result)
void AssignMissense(CRef< CAaSite > initial, const CProteinSub::TFinal &final, CRef< CSimpleVariant > &result)
void AssignNtDeletion(CRef< CNtLocation > nt_loc, CRef< CSimpleVariant > &result)
void AssignAaInsertion(CRef< CAaInterval > aa_interval, const CInsertion::TSeqinfo::TRaw_seq &raw_seq, CRef< CSimpleVariant > &result)
void AssignAaSiteLocation(CRef< CAaSite > aa_site, CRef< CAaLocation > &result)
void AssignNtSSR(CRef< CNtLocation > nt_loc, CRef< CCount > count, CRef< CSimpleVariant > &result)
void AssignNtInv(CRef< CNtLocation > nt_loc, const CInversion::TRaw_seq &raw_seq, CRef< CSimpleVariant > &result)
void AssignNtermExtension(CRef< CAaSite > initial_start_site, CRef< CCount > new_start_site, CRef< CSimpleVariant > &result)
void AssignCountRange(const string &start, const string &stop, CRef< CCount > &result)
void AssignIntronSite(const string &base, const string &offset, CRef< CNtSite > &result)
void AssignCount(const string &count, CRef< CCount > &result)
void AssignAaDup(CRef< CAaLocation > aa_loc, CRef< CSimpleVariant > &result)
void AssignSimpleVariant(CRef< CSimpleVariant > simple_var, CRef< CVariant > &result)
void AssignRefSeqIdentifier(const string &identifier, CRef< CVariantExpression > &result)
void AssignNtDelins(CRef< CNtLocation > nt_loc, const CInsertion::TSeqinfo::TRaw_seq &inserted_seq, CRef< CSimpleVariant > &result)
void AssignAaInterval(CRef< CAaSite > start, CRef< CAaSite > &stop, CRef< CAaInterval > &result)
void AssignFuzzyNtSite(CRef< CNtSite > center_site, CRef< CNtSite > &result)
void Assign3primeUTRSite(CRef< CNtSite > nt_site, CRef< CNtSite > &result)
void AssignNtInsertion(CRef< CNtLocation > nt_loc, const CInsertion::TSeqinfo::TRaw_seq &raw_seq, CRef< CSimpleVariant > &result)
void AssignNtRemoteLocation(const string &identifier, const string &type_string, CRef< CNtLocation > &nt_loc, CRef< CNtLocation > &result)
void AssignSilent(CRef< CAaLocation > loc, CRef< CSimpleVariant > &result)
void AssignSpecialVariant(ESpecialVariant special_variant, CRef< CVariant > &result)
void AssignAaDel(CRef< CAaLocation > aa_loc, CRef< CSimpleVariant > &result)
EVariantSeqType s_GetSeqType(const string &type_string)
void AssignNtSite(CRef< CNtSite > nt_site, CRef< CNtLocation > &result)
void AssignAaInsertionSize(CRef< CAaInterval > aa_interval, CRef< CCount > seq_size, CRef< CSimpleVariant > &result)
void AssignNtDup(CRef< CNtLocation > nt_loc, CRef< CSimpleVariant > &result)
void AssignNtConversion(CRef< CNtLocation > nt_loc, CRef< CNtLocation > origin, CRef< CSimpleVariant > &result)
void AssignNtSub(CRef< CNtLocation > nt_loc, const CNaSub::TInitial &initial_nt, const CNaSub::TFinal &final_nt, CRef< CSimpleVariant > &result)
void AssignNtIdentity(CRef< CNtLocation > nt_loc, const CNaIdentity::TNucleotide &nucleotide, CRef< CSimpleVariant > &result)
void AssignNtSiteRange(CRef< CNtSite > start, CRef< CNtSite > stop, CRef< CNtLocation > &result)
void AssignAaDelinsSize(CRef< CAaLocation > aa_loc, CRef< CCount > seq_size, CRef< CSimpleVariant > &result)
void Assign5primeUTRSite(CRef< CNtSite > nt_site, CRef< CNtSite > &result)
void AssignAaDelins(CRef< CAaLocation > aa_loc, const CInsertion::TSeqinfo::TRaw_seq &raw_seq, CRef< CSimpleVariant > &result)
void AssignAaSite(const string &aa, const string &pos, CRef< CAaSite > &result)
CRef< T > CreateResultIfNull(CRef< T > result)
void TagAsChimera(CRef< CSequenceVariant > seq_var)
void AssignFuzzy(CRef< T > input, CRef< T > &result)
void AssignSequenceType(CRef< CSequenceVariant > &result)
void AssignCtermExtension(const string &reference_stop, const string &aa, CRef< CCount > length, CRef< CSimpleVariant > &result)
void AssignAaSSR(CRef< CAaLocation > aa_loc, CRef< CCount > count, CRef< CSimpleVariant > &result)
void s_SetSequenceInfo(CRef< CNtLocation > &nt_loc, const string &identifier, const EVariantSeqType &seq_type)
void AssignNonsense(CRef< CAaSite > initial, CRef< CSimpleVariant > &result)
void AssignFuzzyLocalVariation(CRef< CSimpleVariant > input, CRef< CSimpleVariant > &result)
void AssignSimpleNtSite(const string &site_index, CRef< CNtSite > &result)
void AssignNtInvSize(CRef< CNtLocation > nt_loc, string size, CRef< CSimpleVariant > &result)
else result
Definition: token2.c:20
Modified on Sat May 18 11:40:59 2024 by modify_doxy.py rev. 669887