1 #include <ncbi_pch.hpp>
2 #include <objtools/readers/hgvs/semantic_actions.hpp>
3
4 BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)5 BEGIN_SCOPE(objects)
6
7 template <typename T>
8 CRef<T> MakeResult(CRef<T> result)
9 {
10 return Ref(new T());
11 }
12
13 template<class T>
CreateResultIfNull(CRef<T> result)14 CRef<T> CreateResultIfNull(CRef<T> result)
15 {
16 return result.IsNull() ? Ref(new T()) : result;
17 }
18
TagAsChimera(CRef<CSequenceVariant> seq_var)19 void TagAsChimera(CRef<CSequenceVariant> seq_var)
20 {
21 seq_var->SetComplex(CSequenceVariant::eComplex_chimera);
22 }
23
TagAsMosaic(CRef<CSequenceVariant> seq_var)24 void TagAsMosaic(CRef<CSequenceVariant> seq_var)
25 {
26 seq_var->SetComplex(CSequenceVariant::eComplex_mosaic);
27 }
28
AssignRefSeqIdentifier(const string & identifier,CRef<CVariantExpression> & result)29 void AssignRefSeqIdentifier(const string& identifier, CRef<CVariantExpression>& result)
30 {
31 result = CreateResultIfNull(result);
32 result->SetReference_id(identifier.substr(0,identifier.size()-1));
33 }
34
35
AssignSequenceVariant(CRef<CSequenceVariant> variant,CRef<CVariantExpression> & result)36 void AssignSequenceVariant(CRef<CSequenceVariant> variant, CRef<CVariantExpression>& result)
37 {
38 result = CreateResultIfNull(result);
39 result->SetSequence_variant(variant.GetNCObject());
40 }
41
42
AssignMissense(CRef<CAaSite> initial,const CProteinSub::TFinal & final,CRef<CSimpleVariant> & result)43 void AssignMissense(CRef<CAaSite> initial,
44 const CProteinSub::TFinal& final,
45 CRef<CSimpleVariant>& result)
46 {
47 result = CreateResultIfNull(result);
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
AssignSilent(CRef<CAaLocation> loc,CRef<CSimpleVariant> & result)56 void AssignSilent(CRef<CAaLocation> loc,
57 CRef<CSimpleVariant>& result)
58 {
59 result = CreateResultIfNull(result);
60 result->SetType().SetProt_silent(*loc);
61 }
62
63
AssignNonsense(CRef<CAaSite> initial,CRef<CSimpleVariant> & result)64 void AssignNonsense(CRef<CAaSite> initial, CRef<CSimpleVariant>& result)
65 {
66 result = CreateResultIfNull(result);
67
68 result->SetType().SetProt_sub().SetType(CProteinSub::eType_nonsense);
69 result->SetType().SetProt_sub().SetInitial(*initial);
70 }
71
72
AssignUnknownSub(CRef<CAaSite> initial,CRef<CSimpleVariant> & result)73 void AssignUnknownSub(CRef<CAaSite> initial, CRef<CSimpleVariant>& result)
74 {
75 result = CreateResultIfNull(result);
76
77 result->SetType().SetProt_sub().SetType(CProteinSub::eType_unknown);
78 result->SetType().SetProt_sub().SetInitial(*initial);
79 }
80
81
AssignAaDup(CRef<CAaLocation> aa_loc,CRef<CSimpleVariant> & result)82 void AssignAaDup(CRef<CAaLocation> aa_loc, CRef<CSimpleVariant>& result)
83 {
84 result = CreateResultIfNull(result);
85 result->SetType().SetDup().SetLoc().SetAaloc(*aa_loc);
86 }
87
88
AssignAaDel(CRef<CAaLocation> aa_loc,CRef<CSimpleVariant> & result)89 void AssignAaDel(CRef<CAaLocation> aa_loc, CRef<CSimpleVariant>& result)
90 {
91 result = CreateResultIfNull(result);
92 result->SetType().SetDel().SetLoc().SetAaloc(*aa_loc);
93 }
94
95
AssignNtermExtension(CRef<CAaSite> initial_start_site,CRef<CCount> new_start_site,CRef<CSimpleVariant> & result)96 void AssignNtermExtension(CRef<CAaSite> initial_start_site, CRef<CCount> new_start_site, CRef<CSimpleVariant>& result)
97 {
98 result = CreateResultIfNull(result);
99 result->SetType().SetProt_ext().SetNterm_ext().SetNewStart(*new_start_site);
100
101 }
102
AssignNtermExtension(CRef<CAaSite> initial_start_site,const string & new_aa,CRef<CCount> new_start_site,CRef<CSimpleVariant> & result)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
AssignCtermExtension(const string & reference_stop,const string & aa,CRef<CCount> length,CRef<CSimpleVariant> & result)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);
114 result = CreateResultIfNull(result);
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
AssignAaIntervalLocation(CRef<CAaInterval> aa_interval,CRef<CAaLocation> & result)123 void AssignAaIntervalLocation(CRef<CAaInterval> aa_interval, CRef<CAaLocation>& result)
124 {
125 result = CreateResultIfNull(result);
126 result->SetInt(*aa_interval);
127 }
128
129
AssignAaSiteLocation(CRef<CAaSite> aa_site,CRef<CAaLocation> & result)130 void AssignAaSiteLocation(CRef<CAaSite> aa_site, CRef<CAaLocation>& result)
131 {
132 result = CreateResultIfNull(result);
133 result->SetSite(*aa_site);
134 }
135
136
AssignAaInterval(CRef<CAaSite> start,CRef<CAaSite> & stop,CRef<CAaInterval> & result)137 void AssignAaInterval(CRef<CAaSite> start, CRef<CAaSite>& stop, CRef<CAaInterval>& result)
138 {
139 result = CreateResultIfNull(result);
140 result->SetStart(*start);
141 result->SetStop(*stop);
142 }
143
144
AssignAaSite(const string & aa,const string & pos,CRef<CAaSite> & result)145 void AssignAaSite(const string& aa, const string& pos, CRef<CAaSite>& result)
146 {
147 result = CreateResultIfNull(result);
148 auto index = NStr::StringToNumeric<CAaSite::TIndex>(pos);
149 // Try ... catch here?
150
151 result->SetAa(aa);
152 result->SetIndex(index);
153 }
154
155
AssignCount(const string & count,CRef<CCount> & result)156 void AssignCount(const string& count, CRef<CCount>& result)
157 {
158 result = CreateResultIfNull(result);
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
AssignFuzzyCount(const string & count,CRef<CCount> & result)170 void AssignFuzzyCount(const string& count, CRef<CCount>& result)
171 {
172 result = CreateResultIfNull(result);
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
AssignCountRange(const string & start,const string & stop,CRef<CCount> & result)179 void AssignCountRange(const string& start, const string& stop, CRef<CCount>& result)
180 {
181 result = CreateResultIfNull(result);
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
AssignAaSSR(CRef<CAaLocation> aa_loc,CRef<CCount> count,CRef<CSimpleVariant> & result)200 void AssignAaSSR(CRef<CAaLocation> aa_loc, CRef<CCount> count, CRef<CSimpleVariant>& result)
201 {
202 result = CreateResultIfNull(result);
203
204 auto& ssr = result->SetType().SetRepeat();
205
206 ssr.SetLoc().SetAaloc(*aa_loc);
207 ssr.SetCount(*count);
208 }
209
210
AssignAaInsertion(CRef<CAaInterval> aa_interval,const CInsertion::TSeqinfo::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)211 void AssignAaInsertion(CRef<CAaInterval> aa_interval,
212 const CInsertion::TSeqinfo::TRaw_seq& raw_seq,
213 CRef<CSimpleVariant>& result)
214 {
215 result = CreateResultIfNull(result);
216 result->SetType().SetIns().SetInt().SetAaint(*aa_interval);
217 result->SetType().SetIns().SetSeqinfo().SetRaw_seq(raw_seq);
218 }
219
220
AssignAaInsertionSize(CRef<CAaInterval> aa_interval,CRef<CCount> seq_size,CRef<CSimpleVariant> & result)221 void AssignAaInsertionSize(CRef<CAaInterval> aa_interval, CRef<CCount> seq_size, CRef<CSimpleVariant>& result)
222 {
223 result = CreateResultIfNull(result);
224
225 auto& insertion = result->SetType().SetIns();
226
227 insertion.SetInt().SetAaint(*aa_interval);
228 insertion.SetSeqinfo().SetCount(*seq_size);
229 }
230
231
AssignFrameshift(CRef<CAaSite> aa_site,CRef<CSimpleVariant> & result)232 void AssignFrameshift(CRef<CAaSite> aa_site, CRef<CSimpleVariant>& result)
233 {
234 result = CreateResultIfNull(result);
235 result->SetType().SetFrameshift().SetAasite(*aa_site);
236 }
237
238
AssignAaDelins(CRef<CAaLocation> aa_loc,const CInsertion::TSeqinfo::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)239 void AssignAaDelins(CRef<CAaLocation> aa_loc,
240 const CInsertion::TSeqinfo::TRaw_seq& raw_seq,
241 CRef<CSimpleVariant>& result)
242 {
243 result = CreateResultIfNull(result);
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
AssignAaDelinsSize(CRef<CAaLocation> aa_loc,CRef<CCount> seq_size,CRef<CSimpleVariant> & result)252 void AssignAaDelinsSize(CRef<CAaLocation> aa_loc, CRef<CCount> seq_size, CRef<CSimpleVariant>& result)
253 {
254 result = CreateResultIfNull(result);
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>
AssignFuzzy(CRef<T> input,CRef<T> & result)263 void AssignFuzzy(CRef<T> input, CRef<T>& result)
264 {
265 result = input;
266 result->SetFuzzy();
267 }
268
269
AssignFuzzyLocalVariation(CRef<CSimpleVariant> input,CRef<CSimpleVariant> & result)270 void AssignFuzzyLocalVariation(CRef<CSimpleVariant> input, CRef<CSimpleVariant>& result)
271 {
272 AssignFuzzy(input, result);
273 }
274
275
AssignSimpleVariant(CRef<CSimpleVariant> simple_var,CRef<CVariant> & result)276 void AssignSimpleVariant(CRef<CSimpleVariant> simple_var, CRef<CVariant>& result)
277 {
278 result = CreateResultIfNull(result);
279 result->SetSimple(*simple_var);
280 }
281
282
AssignSpecialVariant(ESpecialVariant special_variant,CRef<CVariant> & result)283 void AssignSpecialVariant(ESpecialVariant special_variant, CRef<CVariant>& result)
284 {
285 result = CreateResultIfNull(result);
286 result->SetSpecial() = special_variant;
287 }
288
289
AssignSingleVariation(CRef<CVariant> variant,CRef<CSequenceVariant> & result)290 void AssignSingleVariation(CRef<CVariant> variant, CRef<CSequenceVariant>& result)
291 {
292 result = CreateResultIfNull(result);
293 result->SetSubvariants().push_back(variant);
294 }
295
296
AssignSequenceType(CRef<CSequenceVariant> & result)297 void AssignSequenceType(CRef<CSequenceVariant>& result)
298 {
299 result = CreateResultIfNull(result);
300 result->SetSeqtype(eVariantSeqType_p);
301 }
302
303
304 // Nucleotide-specific functions
AssignSimpleNtSite(const string & site_index,CRef<CNtSite> & result)305 void AssignSimpleNtSite(const string& site_index, CRef<CNtSite>& result)
306 {
307 result = CreateResultIfNull(result);
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
AssignFuzzyNtSite(CRef<CNtSite> center_site,CRef<CNtSite> & result)317 void AssignFuzzyNtSite(CRef<CNtSite> center_site, CRef<CNtSite>& result)
318 {
319 result = center_site;
320 result->ResetFuzzy();
321 }
322
323
AssignFuzzySimpleNtSite(const string & site_index,CRef<CNtSite> & result)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
AssignIntronSite(const string & base,const string & offset,CRef<CNtSite> & result)336 void AssignIntronSite(const string& base, const string& offset, CRef<CNtSite>& result)
337 {
338 result = CreateResultIfNull(result);
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
Assign5primeUTRSite(CRef<CNtSite> nt_site,CRef<CNtSite> & result)375 void Assign5primeUTRSite(CRef<CNtSite> nt_site, CRef<CNtSite>& result)
376 {
377 result = Ref(nt_site.GetPointer());
378 result->SetUtr().SetFive_prime();
379 }
380
381
Assign3primeUTRSite(CRef<CNtSite> nt_site,CRef<CNtSite> & result)382 void Assign3primeUTRSite(CRef<CNtSite> nt_site, CRef<CNtSite>& result)
383 {
384 result = Ref(nt_site.GetPointer());
385 result->SetUtr().SetThree_prime();
386 }
387
388
AssignNtSiteRange(CRef<CNtSite> start,CRef<CNtSite> stop,CRef<CNtLocation> & result)389 void AssignNtSiteRange(CRef<CNtSite> start, CRef<CNtSite> stop, CRef<CNtLocation>& result)
390 {
391 result = CreateResultIfNull(result);
392 result->SetRange().SetStart(*start);
393 result->SetRange().SetStop(*stop);
394 }
395
AssignNtSite(CRef<CNtSite> nt_site,CRef<CNtLocation> & result)396 void AssignNtSite(CRef<CNtSite> nt_site, CRef<CNtLocation>& result)
397 {
398 result = CreateResultIfNull(result);
399 result->SetSite(*nt_site);
400 }
401
AssignNtInterval(CRef<CNtLocation> start,CRef<CNtLocation> stop,CRef<CNtLocation> & result)402 void AssignNtInterval(CRef<CNtLocation> start, CRef<CNtLocation> stop, CRef<CNtLocation>& result)
403 {
404 result = CreateResultIfNull(result);
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
s_SetSequenceInfo(CRef<CNtLocation> & nt_loc,const string & identifier,const EVariantSeqType & seq_type)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
s_GetSeqType(const string & type_string)462 EVariantSeqType s_GetSeqType(const string& type_string)
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
AssignNtRemoteLocation(const string & identifier,const string & type_string,CRef<CNtLocation> & nt_loc,CRef<CNtLocation> & result)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
AssignNtSSR(CRef<CNtLocation> nt_loc,CRef<CCount> count,CRef<CSimpleVariant> & result)502 void AssignNtSSR(CRef<CNtLocation> nt_loc, CRef<CCount> count, CRef<CSimpleVariant>& result)
503 {
504 result = CreateResultIfNull(result);
505 result->SetType().SetRepeat().SetLoc().SetNtloc(*nt_loc);
506 result->SetType().SetRepeat().SetCount(*count);
507 }
508
509
AssignNtSSR(CRef<CNtLocation> nt_loc,const CRepeat::TRaw_seq & raw_seq,CRef<CCount> count,CRef<CSimpleVariant> & result)510 void AssignNtSSR(CRef<CNtLocation> nt_loc, const CRepeat::TRaw_seq& raw_seq, CRef<CCount> count, CRef<CSimpleVariant>& result)
511 {
512 result = CreateResultIfNull(result);
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
AssignNtInv(CRef<CNtLocation> nt_loc,const CInversion::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)522 void AssignNtInv(CRef<CNtLocation> nt_loc, const CInversion::TRaw_seq& raw_seq, CRef<CSimpleVariant>& result)
523 {
524 result = CreateResultIfNull(result);
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
AssignNtInv(CRef<CNtLocation> nt_loc,CRef<CSimpleVariant> & result)534 void AssignNtInv(CRef<CNtLocation> nt_loc, CRef<CSimpleVariant>& result)
535 {
536 result = CreateResultIfNull(result);
537 result->SetType().SetInv().SetNtint(nt_loc->SetInt());
538 }
539
540
AssignNtInvSize(CRef<CNtLocation> nt_loc,string size,CRef<CSimpleVariant> & result)541 void AssignNtInvSize(CRef<CNtLocation> nt_loc, string size, CRef<CSimpleVariant>& result)
542 {
543 AssignNtInv(nt_loc, result);
544 result->SetType().SetInv().SetSize(NStr::StringToNumeric<CInversion::TSize>(size));
545 }
546
547
AssignNtConversion(CRef<CNtLocation> nt_loc,CRef<CNtLocation> origin,CRef<CSimpleVariant> & result)548 void AssignNtConversion(CRef<CNtLocation> nt_loc, CRef<CNtLocation> origin, CRef<CSimpleVariant>& result)
549 {
550 result = CreateResultIfNull(result);
551 result->SetType().SetConv().SetLoc(nt_loc.GetNCObject());
552 result->SetType().SetConv().SetOrigin(origin.GetNCObject());
553 }
554
555
556
AssignNtInsertion(CRef<CNtLocation> nt_loc,const CInsertion::TSeqinfo::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)557 void AssignNtInsertion(CRef<CNtLocation> nt_loc, const CInsertion::TSeqinfo::TRaw_seq& raw_seq, CRef<CSimpleVariant>& result)
558 {
559 result = CreateResultIfNull(result);
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
AssignNtDeletion(CRef<CNtLocation> nt_loc,CRef<CSimpleVariant> & result)569 void AssignNtDeletion(CRef<CNtLocation> nt_loc, CRef<CSimpleVariant>& result)
570 {
571 result = CreateResultIfNull(result);
572 result->SetType().SetDel().SetLoc().SetNtloc(*nt_loc);
573 }
574
575
AssignNtDeletion(CRef<CNtLocation> nt_loc,const CDeletion::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)576 void AssignNtDeletion(CRef<CNtLocation> nt_loc, const CDeletion::TRaw_seq& raw_seq, CRef<CSimpleVariant>& result)
577 {
578 result = CreateResultIfNull(result);
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
AssignNtDelins(CRef<CNtLocation> nt_loc,const CInsertion::TSeqinfo::TRaw_seq & inserted_seq,CRef<CSimpleVariant> & result)587 void AssignNtDelins(CRef<CNtLocation> nt_loc, const CInsertion::TSeqinfo::TRaw_seq& inserted_seq, CRef<CSimpleVariant>& result)
588 {
589 result = CreateResultIfNull(result);
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
AssignNtDelins(CRef<CNtLocation> nt_loc,const CDeletion::TRaw_seq & deleted_seq,const CInsertion::TSeqinfo::TRaw_seq & inserted_seq,CRef<CSimpleVariant> & result)598 void AssignNtDelins(CRef<CNtLocation> nt_loc,
599 const CDeletion::TRaw_seq& deleted_seq,
600 const CInsertion::TSeqinfo::TRaw_seq& inserted_seq,
601 CRef<CSimpleVariant>& result)
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
AssignNtDup(CRef<CNtLocation> nt_loc,CRef<CSimpleVariant> & result)612 void AssignNtDup(CRef<CNtLocation> nt_loc, CRef<CSimpleVariant>& result)
613 {
614 result = CreateResultIfNull(result);
615 result->SetType().SetDup().SetLoc().SetNtloc(*nt_loc);
616 }
617
618
AssignNtDup(CRef<CNtLocation> nt_loc,const CDuplication::TRaw_seq & raw_seq,CRef<CSimpleVariant> & result)619 void AssignNtDup(CRef<CNtLocation> nt_loc, const CDuplication::TRaw_seq& raw_seq, CRef<CSimpleVariant>& result)
620 {
621 result = CreateResultIfNull(result);
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
AssignNtSub(CRef<CNtLocation> nt_loc,const CNaSub::TInitial & initial_nt,const CNaSub::TFinal & final_nt,CRef<CSimpleVariant> & result)630 void AssignNtSub(CRef<CNtLocation> nt_loc,
631 const CNaSub::TInitial& initial_nt,
632 const CNaSub::TFinal& final_nt,
633 CRef<CSimpleVariant>& result)
634 {
635 result = CreateResultIfNull(result);
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
AssignNtIdentity(CRef<CNtLocation> nt_loc,const CNaIdentity::TNucleotide & nucleotide,CRef<CSimpleVariant> & result)642 void AssignNtIdentity(CRef<CNtLocation> nt_loc,
643 const CNaIdentity::TNucleotide& nucleotide,
644 CRef<CSimpleVariant>& result)
645 {
646 result = CreateResultIfNull(result);
647 result->SetType().SetNa_identity().SetLoc(*nt_loc);
648 result->SetType().SetNa_identity().SetNucleotide(nucleotide);
649 }
650
651
AssignNtIdentity(CRef<CNtLocation> nt_loc,CRef<CSimpleVariant> & result)652 void AssignNtIdentity(CRef<CNtLocation> nt_loc,
653 CRef<CSimpleVariant>& result)
654 {
655 result = CreateResultIfNull(result);
656 result->SetType().SetNa_identity().SetLoc(*nt_loc);
657 }
658
659
AssignSequenceType(const string & type_string,CRef<CSequenceVariant> & result)660 void AssignSequenceType(const string& type_string, CRef<CSequenceVariant>& result)
661 {
662 result = CreateResultIfNull(result);
663 auto seq_type = s_GetSeqType(type_string);
664 result->SetSeqtype(seq_type);
665 }
666
667 END_SCOPE(objects)
668 END_NCBI_SCOPE
669
670
671