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

Go to the SVN repository for this file.

1 /* $Id: bioseq_info.cpp 99885 2023-05-18 17:59:55Z vasilche $
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: Aleksey Grichenko, Eugene Vasilchenko
27 *
28 * File Description:
29 * Bioseq info for data source
30 *
31 */
32 
33 
34 #include <ncbi_pch.hpp>
37 #include <objmgr/impl/tse_info.hpp>
39 
41 
42 #include <objmgr/seq_map.hpp>
43 
44 #include <objects/seq/Bioseq.hpp>
45 
46 #include <objects/seq/Seq_inst.hpp>
47 #include <objects/seq/Seq_data.hpp>
48 #include <objects/seq/Seq_hist.hpp>
49 #include <objects/seq/Seq_ext.hpp>
50 #include <objects/seq/Seg_ext.hpp>
54 #include <objects/seq/Ref_ext.hpp>
56 #include <objects/seq/Seqdesc.hpp>
59 
70 #include <algorithm>
71 
72 
75 
76 
77 ////////////////////////////////////////////////////////////////////
78 //
79 // CBioseq_Info::
80 //
81 // Structure to keep bioseq's parent seq-entry along with the list
82 // of seq-id synonyms for the bioseq.
83 //
84 
85 
87  : m_AssemblyChunk(-1),
88  m_FeatureFetchPolicy(-1),
89  m_IdChangeCounter(0)
90 {
91  x_SetObject(seq);
92 }
93 
94 
96  : TParent(info, copy_map),
97  m_Seq_dataChunks(info.m_Seq_dataChunks),
98  m_AssemblyChunk(info.m_AssemblyChunk),
99  m_FeatureFetchPolicy(info.m_FeatureFetchPolicy),
100  m_IdChangeCounter(0)
101 {
102  if ( !copy_map ) {
103  info.x_UpdateComplete();
104  m_DescrChunks.clear();
105  m_AnnotChunks.clear();
106  m_Seq_dataChunks.clear();
107  m_AssemblyChunk = -1;
108  }
109  x_SetObject(info, copy_map);
110 }
111 
112 
114 {
115  x_ResetSeqMap();
116 }
117 
118 
120 {
122  return m_Object;
123 }
124 
125 
127 {
128  x_UpdateCore();
129  return m_Object;
130 }
131 
132 
134 {
136 }
137 
138 
140 {
141  m_Seq_dataChunks.push_back(chunk_id);
143 }
144 
145 
147 {
149  _ASSERT(chunk_id >= 0);
150  m_AssemblyChunk = chunk_id;
152 }
153 
154 
156 {
157  if ( flags & fNeedUpdate_seq_data ) {
158  if ( !m_Seq_dataChunks.empty() ) {
160  }
162  if ( m_SeqMap ) {
163  m_SeqMap->x_UpdateSeq_inst(m_Object->SetInst());
164  }
165  }
166  if ( flags & fNeedUpdate_assembly ) {
167  TChunkId chunk = m_AssemblyChunk;
168  if ( chunk >= 0 ) {
169  x_LoadChunk(chunk);
170  }
171  }
173 }
174 
175 
177 {
179  x_DSMapObject(m_Object, ds);
180 }
181 
182 
184 {
187 }
188 
189 
191 {
192  ds.x_Map(obj, this);
193 }
194 
195 
197 {
198  ds.x_Unmap(obj, this);
199 }
200 
201 
203 {
205  SetBioObjectId(tse.x_IndexBioseq(this));
206  /*
207  x_RegisterRemovedIds(m_Object, *this);
208  ITERATE ( TId, it, m_Id ) {
209  tse.x_SetBioseqId(*it, this);
210  }
211  */
212 }
213 
214 
216 {
217  ITERATE ( TId, it, m_Id ) {
218  tse.x_ResetBioseqId(*it, this);
219  }
221 }
222 
223 
225 {
226  TParent::x_ParentAttach(parent);
227  CSeq_entry& entry = parent.x_GetObject();
228  entry.ParentizeOneLevel();
229 #ifdef _DEBUG
230  _ASSERT(&entry.GetSeq() == m_Object);
231  _ASSERT(m_Object->GetParentEntry() == &entry);
232 #endif
233 }
234 
235 
237 {
238  //m_Object->ResetParentEntry();
239  TParent::x_ParentDetach(parent);
240 }
241 
242 
244 {
245  if ( m_FeatureFetchPolicy == -1 ) {
246  int policy = -1;
247  if ( IsSetDescr() ) {
249  policy == -1 && !x_IsEndDesc(it);
250  it = x_GetNextDesc(it, 1<<CSeqdesc::e_User) ) {
251  const CSeqdesc& desc = **it;
252  if ( !desc.IsUser() ) {
253  continue;
254  }
255  const CUser_object& user = desc.GetUser();
256  const CObject_id& id = user.GetType();
257  if ( !id.IsStr() || id.GetStr() != "FeatureFetchPolicy" ) {
258  continue;
259  }
260  ITERATE ( CUser_object::TData, fit, user.GetData() ) {
261  const CUser_field& field = **fit;
262  const CObject_id& fid = field.GetLabel();
263  if ( !fid.IsStr() || fid.GetStr() != "Policy" ) {
264  continue;
265  }
266  if ( !field.GetData().IsStr() ) {
267  continue;
268  }
269  const string& str = field.GetData().GetStr();
270  if ( str == "OnlyNearFeatures" ) {
272  }
273  else if ( str == "AllowFarFeatures" ) {
275  }
276  else {
278  }
279  break;
280  }
281  }
282  }
283  if ( policy == -1 ) {
285  }
286  m_FeatureFetchPolicy = policy;
287  }
288  return m_FeatureFetchPolicy;
289 }
290 
291 
293 {
294  _ASSERT(!m_Object);
295 
296  m_Object.Reset(&obj);
297  if ( HasDataSource() ) {
299  }
300  if ( obj.IsSetId() ) {
301  ITERATE ( TObject::TId, it, obj.GetId() ) {
302  m_Id.push_back(CSeq_id_Handle::GetHandle(**it));
303  }
304  }
305  if ( obj.IsSetAnnot() ) {
306  x_SetAnnot();
307  }
309 }
310 
311 
313  TObjectCopyMap* copy_map)
314 {
315  _ASSERT(!m_Object);
316 
317  m_Object = sx_ShallowCopy(*info.m_Object);
318  if ( HasDataSource() ) {
320  }
321  m_Id = info.m_Id;
322  {{
323  CFastMutexGuard guard(info.m_SeqMap_Mtx);
324  if ( info.m_SeqMap ) {
326  m_SeqMap = info.m_SeqMap->CloneFor(*m_Object);
327  m_SeqMap->m_Bioseq = this;
328  }
329  }}
330  if ( info.IsSetAnnot() ) {
331  x_SetAnnot(info, copy_map);
332  }
333  m_FeatureFetchPolicy = info.m_FeatureFetchPolicy;
334 }
335 
336 
338 {
339  CRef<TObject> obj(new TObject);
340  if ( src.IsSetId() ) {
341  obj->SetId() = src.GetId();
342  }
343  if ( src.IsSetDescr() ) {
344  obj->SetDescr().Set() = src.GetDescr().Get();
345  }
346  if ( src.IsSetInst() ) {
347  CRef<TInst> inst = sx_ShallowCopy(src.GetInst());
348  obj->SetInst(*inst);
349  }
350  if ( src.IsSetAnnot() ) {
351  obj->SetAnnot() = src.GetAnnot();
352  }
353  return obj;
354 }
355 
356 
358 {
359  CRef<TInst> obj(new TInst);
360  if ( src.IsSetRepr() ) {
361  obj->SetRepr(src.GetRepr());
362  }
363  if ( src.IsSetMol() ) {
364  obj->SetMol(src.GetMol());
365  }
366  if ( src.IsSetLength() ) {
367  obj->SetLength(src.GetLength());
368  }
369  if ( src.IsSetFuzz() ) {
370  obj->SetFuzz(const_cast<TInst_Fuzz&>(src.GetFuzz()));
371  }
372  if ( src.IsSetTopology() ) {
373  obj->SetTopology(src.GetTopology());
374  }
375  if ( src.IsSetStrand() ) {
376  obj->SetStrand(src.GetStrand());
377  }
378  if ( src.IsSetSeq_data() ) {
379  obj->SetSeq_data(const_cast<TInst_Seq_data&>(src.GetSeq_data()));
380  }
381  if ( src.IsSetExt() ) {
382  obj->SetExt(const_cast<TInst_Ext&>(src.GetExt()));
383  }
384  if ( src.IsSetHist() ) {
385  obj->SetHist(const_cast<TInst_Hist&>(src.GetHist()));
386  }
387  return obj;
388 }
389 
390 
391 /////////////////////////////////////////////////////////////////////////////
392 // id
393 /////////////////////////////////////////////////////////////////////////////
394 
395 bool CBioseq_Info::IsSetId(void) const
396 {
397  return m_Object->IsSetId();
398 }
399 
400 
401 bool CBioseq_Info::CanGetId(void) const
402 {
403  return m_Object->CanGetId();
404 }
405 
406 
408 {
409  return m_Id;
410 }
411 
412 
414 {
415  ITERATE(TId, id, m_Id) {
416  GetTSE_Info().x_ResetBioseqId(*id,this);
417  }
418  m_Id.clear();
419  m_Object->ResetId();
420  SetBioObjectId(GetTSE_Info().x_RegisterBioObject(*this));
422 }
423 
424 
425 bool CBioseq_Info::HasId(const CSeq_id_Handle& id) const
426 {
427  return find(m_Id.begin(), m_Id.end(), id) != m_Id.end();
428 }
429 
430 
432 {
433  TId::iterator found = find(m_Id.begin(), m_Id.end(), id);
434  if ( found != m_Id.end() ) {
435  return false;
436  }
437  m_Id.push_back(id);
438  CRef<CSeq_id> seq_id(new CSeq_id);
439  seq_id->Assign(*id.GetSeqId());
440  m_Object->SetId().push_back(seq_id);
441  GetTSE_Info().x_SetBioseqId(id,this);
443  return true;
444 }
445 
446 
448 {
449  TId::iterator found = find(m_Id.begin(), m_Id.end(), id);
450  if ( found == m_Id.end() ) {
451  return false;
452  }
453  m_Id.erase(found);
454  NON_CONST_ITERATE ( TObject::TId, it, m_Object->SetId() ) {
455  if ( CSeq_id_Handle::GetHandle(**it) == id ) {
456  m_Object->SetId().erase(it);
457  break;
458  }
459  }
460  GetTSE_Info().x_ResetBioseqId(id,this);
461  if (GetBioObjectId() == CBioObjectId(id)) {
462  SetBioObjectId(GetTSE_Info().x_RegisterBioObject(*this));
463  }
465  return true;
466 }
467 
468 
469 /////////////////////////////////////////////////////////////////////////////
470 // descr
471 /////////////////////////////////////////////////////////////////////////////
472 
474 {
475  return m_Object->IsSetDescr();
476 }
477 
478 
480 {
481  return m_Object->CanGetDescr();
482 }
483 
484 
486 {
487  return m_Object->GetDescr();
488 }
489 
490 
492 {
493  return m_Object->SetDescr();
494 }
495 
496 
498 {
499  m_Object->SetDescr(v);
500 }
501 
502 
504 {
505  m_Object->ResetDescr();
506 }
507 
508 
509 /////////////////////////////////////////////////////////////////////////////
510 // annot
511 /////////////////////////////////////////////////////////////////////////////
512 
514 {
515  return m_Object->SetAnnot();
516 }
517 
518 
520 {
521  m_Object->ResetAnnot();
522 }
523 
524 
525 /////////////////////////////////////////////////////////////////////////////
526 // inst
527 /////////////////////////////////////////////////////////////////////////////
528 
529 bool CBioseq_Info::IsSetInst(void) const
530 {
531  return m_Object->IsSetInst();
532 }
533 
534 
535 bool CBioseq_Info::CanGetInst(void) const
536 {
537  return m_Object->CanGetInst();
538 }
539 
540 
542 {
544  return m_Object->GetInst();
545 }
546 
547 
549 {
550  x_ResetSeqMap();
551  m_Seq_dataChunks.clear();
552  m_Object->SetInst(v);
553 }
554 
556 {
557  if (IsSetInst()) {
558  x_ResetSeqMap();
559  m_Seq_dataChunks.clear();
560  m_Object->ResetInst();
561  }
562 }
563 
564 
566 {
568  if ( m_SeqMap ) {
569  m_SeqMap->m_Bioseq = 0;
570  m_SeqMap.Reset();
571  }
572 }
573 
574 
575 /////////////////////////////////////////////////////////////////////////////
576 // inst.repr
577 /////////////////////////////////////////////////////////////////////////////
578 
580 {
581  return IsSetInst() && m_Object->GetInst().IsSetRepr();
582 }
583 
584 
586 {
587  return CanGetInst() && m_Object->GetInst().CanGetRepr();
588 }
589 
590 
592 {
593  return m_Object->GetInst().GetRepr();
594 }
595 
596 
598 {
600  if ( m_SeqMap ) {
601  m_SeqMap->SetRepr(v);
602  }
603  m_Object->SetInst().SetRepr(v);
604 }
605 
607 {
608  if (IsSetInst_Repr()) {
610  if ( m_SeqMap ) {
611  m_SeqMap->ResetRepr();
612  }
613  m_Object->SetInst().ResetRepr();
614  }
615 }
616 
617 /////////////////////////////////////////////////////////////////////////////
618 // inst.mol
619 /////////////////////////////////////////////////////////////////////////////
620 
622 {
623  return IsSetInst() && m_Object->GetInst().IsSetMol();
624 }
625 
626 
628 {
629  return CanGetInst() && m_Object->GetInst().CanGetMol();
630 }
631 
632 
634 {
635  return m_Object->GetInst().GetMol();
636 }
637 
638 
640 {
642  if ( m_SeqMap ) {
643  m_SeqMap->SetMol(v);
644  }
645  m_Object->SetInst().SetMol(v);
646 }
647 
649 {
650  if (IsSetInst_Mol()) {
652  if ( m_SeqMap ) {
653  m_SeqMap->ResetMol();
654  }
655  m_Object->SetInst().ResetMol();
656  }
657 }
658 
659 
660 /////////////////////////////////////////////////////////////////////////////
661 // inst.length
662 /////////////////////////////////////////////////////////////////////////////
663 
665 {
666  return IsSetInst() && m_Object->GetInst().IsSetLength();
667 }
668 
669 
671 {
672  return CanGetInst() && m_Object->GetInst().CanGetLength();
673 }
674 
675 
677 {
679  if ( m_SeqMap ) {
680  return m_SeqMap->GetLength(0);
681  }
682  else {
683  return m_Object->GetInst().GetLength();
684  }
685 }
686 
687 
689 {
691  x_ResetSeqMap();
692  m_Object->SetInst().SetLength(v);
693 }
694 
696 {
697  if (IsSetInst_Length()) {
699  x_ResetSeqMap();
700  m_Object->SetInst().ResetLength();
701  }
702 }
703 
705 {
706  if ( IsSetInst_Length() ) {
707  return GetInst_Length();
708  }
709  else {
710  return x_CalcBioseqLength();
711  }
712 }
713 
714 
715 /////////////////////////////////////////////////////////////////////////////
716 // inst.fuzz
717 /////////////////////////////////////////////////////////////////////////////
718 
720 {
721  return IsSetInst() && m_Object->GetInst().IsSetFuzz();
722 }
723 
724 
726 {
727  return CanGetInst() && m_Object->GetInst().CanGetFuzz();
728 }
729 
730 
732 {
733  return m_Object->GetInst().GetFuzz();
734 }
735 
736 
738 {
739  m_Object->SetInst().SetFuzz(v);
740 }
741 
743 {
744  if (IsSetInst_Fuzz()) {
745  m_Object->SetInst().ResetFuzz();
746  }
747 }
748 
749 /////////////////////////////////////////////////////////////////////////////
750 // inst.topology
751 /////////////////////////////////////////////////////////////////////////////
752 
754 {
755  return IsSetInst() && m_Object->GetInst().IsSetTopology();
756 }
757 
758 
760 {
761  return CanGetInst() && m_Object->GetInst().CanGetTopology();
762 }
763 
764 
766 {
767  return m_Object->GetInst().GetTopology();
768 }
769 
770 
772 {
773  m_Object->SetInst().SetTopology(v);
774 }
775 
777 {
778  if (IsSetInst_Topology()) {
779  m_Object->SetInst().ResetTopology();
780  }
781 }
782 
783 /////////////////////////////////////////////////////////////////////////////
784 // inst.strand
785 /////////////////////////////////////////////////////////////////////////////
786 
788 {
789  return IsSetInst() && m_Object->GetInst().IsSetStrand();
790 }
791 
792 
794 {
795  return CanGetInst() && m_Object->GetInst().CanGetStrand();
796 }
797 
798 
800 {
801  return m_Object->GetInst().GetStrand();
802 }
803 
804 
806 {
807  m_Object->SetInst().SetStrand(v);
808 }
809 
811 {
812  if (IsSetInst_Strand()) {
813  m_Object->SetInst().ResetStrand();
814  }
815 }
816 
817 
818 /////////////////////////////////////////////////////////////////////////////
819 // inst.seq-data
820 /////////////////////////////////////////////////////////////////////////////
821 
823 {
824  if ( !IsSetInst() ) {
825  return false;
826  }
827  auto& inst = m_Object->GetInst();
828  return inst.IsSetSeq_data() ||
829  (!inst.IsSetExt() && x_NeedUpdate(fNeedUpdate_seq_data) && m_Seq_dataChunks.size() == 1);
830 }
831 
832 
834 {
835  return IsSetInst_Seq_data();
836 }
837 
838 
840 {
842  return m_Object->GetInst().GetSeq_data();
843 }
844 
845 
847 {
849  x_ResetSeqMap();
850  m_Seq_dataChunks.clear();
851  m_Object->SetInst().SetSeq_data(v);
852 }
853 
855 {
856  if (IsSetInst_Seq_data()) {
858  x_ResetSeqMap();
859  m_Seq_dataChunks.clear();
860  m_Object->SetInst().ResetSeq_data();
861  }
862 }
863 
864 
865 /////////////////////////////////////////////////////////////////////////////
866 // inst.ext
867 /////////////////////////////////////////////////////////////////////////////
868 
870 {
871  return IsSetInst() && m_Object->GetInst().IsSetExt();
872 }
873 
874 
876 {
877  return IsSetInst_Ext();
878 }
879 
880 
882 {
884  return m_Object->GetInst().GetExt();
885 }
886 
887 
889 {
891  x_ResetSeqMap();
892  m_Seq_dataChunks.clear();
893  m_Object->SetInst().SetExt(v);
894 }
895 
897 {
898  if (IsSetInst_Ext()) {
900  x_ResetSeqMap();
901  m_Seq_dataChunks.clear();
902  m_Object->SetInst().ResetExt();
903  }
904 }
905 
906 
907 /////////////////////////////////////////////////////////////////////////////
908 // inst.hist
909 /////////////////////////////////////////////////////////////////////////////
910 
912 {
913  return IsSetInst() && m_Object->GetInst().IsSetHist();
914 }
915 
916 
918 {
919  return CanGetInst() && m_Object->GetInst().CanGetHist();
920 }
921 
922 
924 {
926  return m_Object->GetInst().GetHist();
927 }
928 
929 
931 {
933  m_AssemblyChunk = -1;
934  m_Object->SetInst().SetHist(v);
935 }
936 
937 
939 {
940  if (IsSetInst_Hist()) {
942  m_AssemblyChunk = -1;
943  m_Object->SetInst().ResetHist();
944  }
945 }
946 
947 
948 /////////////////////////////////////////////////////////////////////////////
949 // inst.hist.assembly
950 /////////////////////////////////////////////////////////////////////////////
951 
953 {
954  return IsSetInst_Hist() &&
955  (m_AssemblyChunk >= 0||m_Object->GetInst().GetHist().IsSetAssembly());
956 }
957 
958 
960 {
961  return CanGetInst_Hist();
962 }
963 
964 
967 {
969  return m_Object->GetInst().GetHist().GetAssembly();
970 }
971 
972 
974 {
976  m_AssemblyChunk = -1;
977  m_Object->SetInst().SetHist().SetAssembly() = v;
978 }
979 
980 
981 /////////////////////////////////////////////////////////////////////////////
982 // inst.hist.replaces
983 /////////////////////////////////////////////////////////////////////////////
984 
986 {
987  return IsSetInst_Hist() && m_Object->GetInst().GetHist().IsSetReplaces();
988 }
989 
990 
992 {
993  return CanGetInst_Hist() && m_Object->GetInst().GetHist().CanGetReplaces();
994 }
995 
996 
999 {
1000  return m_Object->GetInst().GetHist().GetReplaces();
1001 }
1002 
1003 
1005 {
1006  m_Object->SetInst().SetHist().SetReplaces(v);
1007 }
1008 
1009 
1010 /////////////////////////////////////////////////////////////////////////////
1011 // inst.hist.replaced-by
1012 /////////////////////////////////////////////////////////////////////////////
1013 
1015 {
1016  return IsSetInst_Hist() &&
1017  m_Object->GetInst().GetHist().IsSetReplaced_by();
1018 }
1019 
1020 
1022 {
1023  return CanGetInst_Hist() &&
1024  m_Object->GetInst().GetHist().CanGetReplaced_by();
1025 }
1026 
1027 
1030 {
1031  return m_Object->GetInst().GetHist().GetReplaced_by();
1032 }
1033 
1034 
1036 {
1037  m_Object->SetInst().SetHist().SetReplaced_by(v);
1038 }
1039 
1040 
1041 /////////////////////////////////////////////////////////////////////////////
1042 // inst.hist.deleted
1043 /////////////////////////////////////////////////////////////////////////////
1044 
1046 {
1047  return IsSetInst_Hist() && m_Object->GetInst().GetHist().IsSetDeleted();
1048 }
1049 
1050 
1052 {
1053  return CanGetInst_Hist() && m_Object->GetInst().GetHist().CanGetDeleted();
1054 }
1055 
1056 
1059 {
1060  return m_Object->GetInst().GetHist().GetDeleted();
1061 }
1062 
1063 
1065 {
1066  m_Object->SetInst().SetHist().SetDeleted(v);
1067 }
1068 
1069 
1070 bool CBioseq_Info::IsNa(void) const
1071 {
1072  return m_Object->IsNa();
1073 }
1074 
1075 
1076 bool CBioseq_Info::IsAa(void) const
1077 {
1078  return m_Object->IsAa();
1079 }
1080 
1081 
1082 /////////////////////////////////////////////////////////////////////////////
1083 // calculate bioseq length if inst.length field is not set
1084 /////////////////////////////////////////////////////////////////////////////
1085 
1087 {
1088  return x_CalcBioseqLength(GetInst());
1089 }
1090 
1091 
1093 {
1094  if ( !inst.IsSetExt() ) {
1095  NCBI_THROW(CObjMgrException, eOtherError,
1096  "CBioseq_Info::x_CalcBioseqLength: "
1097  "failed: Seq-inst.ext is not set");
1098  }
1099  switch ( inst.GetExt().Which() ) {
1100  case CSeq_ext::e_Seg:
1101  return x_CalcBioseqLength(inst.GetExt().GetSeg());
1102  case CSeq_ext::e_Ref:
1103  return x_CalcBioseqLength(inst.GetExt().GetRef().Get());
1104  case CSeq_ext::e_Delta:
1105  return x_CalcBioseqLength(inst.GetExt().GetDelta());
1106  default:
1107  NCBI_THROW(CObjMgrException, eOtherError,
1108  "CBioseq_Info::x_CalcBioseqLength: "
1109  "failed: bad Seg-ext type");
1110  }
1111 }
1112 
1113 
1115 {
1118  if ( !ref ) {
1119  NCBI_THROW(CObjMgrException, eOtherError,
1120  "CBioseq_Info::x_CalcBioseqLength: "
1121  "failed: external whole reference");
1122  }
1123  return ref->GetBioseqLength();
1124 }
1125 
1126 
1128 {
1129  TSeqPos ret = 0;
1130  ITERATE ( CPacked_seqint::Tdata, it, ints.Get() ) {
1131  ret += (*it)->GetLength();
1132  }
1133  return ret;
1134 }
1135 
1136 
1138 {
1139  switch ( seq_loc.Which() ) {
1140  case CSeq_loc::e_not_set:
1141  case CSeq_loc::e_Null:
1142  case CSeq_loc::e_Empty:
1143  return 0;
1144  case CSeq_loc::e_Whole:
1145  return x_CalcBioseqLength(seq_loc.GetWhole());
1146  case CSeq_loc::e_Int:
1147  return seq_loc.GetInt().GetLength();
1148  case CSeq_loc::e_Pnt:
1149  return 1;
1151  return x_CalcBioseqLength(seq_loc.GetPacked_int());
1153  return TSeqPos(seq_loc.GetPacked_pnt().GetPoints().size());
1154  case CSeq_loc::e_Mix:
1155  return x_CalcBioseqLength(seq_loc.GetMix());
1156  case CSeq_loc::e_Equiv:
1157  return x_CalcBioseqLength(seq_loc.GetEquiv());
1158  default:
1159  NCBI_THROW(CObjMgrException, eOtherError,
1160  "CBioseq_Info::x_CalcBioseqLength: "
1161  "failed: bad Seq-loc type");
1162  }
1163 }
1164 
1165 
1167 {
1168  TSeqPos ret = 0;
1169  ITERATE ( CSeq_loc_mix::Tdata, it, seq_mix.Get() ) {
1170  ret += x_CalcBioseqLength(**it);
1171  }
1172  return ret;
1173 }
1174 
1175 
1177 {
1178  TSeqPos ret = 0;
1179  ITERATE ( CSeq_loc_equiv::Tdata, it, seq_equiv.Get() ) {
1180  ret += x_CalcBioseqLength(**it);
1181  }
1182  return ret;
1183 }
1184 
1185 
1187 {
1188  TSeqPos ret = 0;
1189  ITERATE ( CSeg_ext::Tdata, it, seg_ext.Get() ) {
1190  ret += x_CalcBioseqLength(**it);
1191  }
1192  return ret;
1193 }
1194 
1195 
1197 {
1198  TSeqPos ret = 0;
1199  ITERATE ( CDelta_ext::Tdata, it, delta.Get() ) {
1200  ret += x_CalcBioseqLength(**it);
1201  }
1202  return ret;
1203 }
1204 
1205 
1207 {
1208  switch ( delta_seq.Which() ) {
1209  case CDelta_seq::e_Loc:
1210  return x_CalcBioseqLength(delta_seq.GetLoc());
1211  case CDelta_seq::e_Literal:
1212  return delta_seq.GetLiteral().GetLength();
1213  default:
1214  NCBI_THROW(CObjMgrException, eOtherError,
1215  "CBioseq_Info::x_CalcBioseqLength: "
1216  "failed: bad Delta-seq type");
1217  }
1218 }
1219 
1220 
1221 string CBioseq_Info::IdString(void) const
1222 {
1223  CNcbiOstrstream os;
1224  ITERATE ( TId, it, m_Id ) {
1225  if ( it != m_Id.begin() )
1226  os << " | ";
1227  os << it->AsString();
1228  }
1229  return CNcbiOstrstreamToString(os);
1230 }
1231 
1232 
1234 {
1236  if ( m_SeqMap || seq_map.m_Bioseq ) {
1237  NCBI_THROW(CObjMgrException, eAddDataError,
1238  "CBioseq_Info::AttachMap: bioseq already has SeqMap");
1239  }
1240  m_SeqMap.Reset(&seq_map);
1241  seq_map.m_Bioseq = this;
1242 }
1243 
1244 
1246 {
1248  if ( !m_SeqMap ) {
1250  m_SeqMap->m_Bioseq = const_cast<CBioseq_Info*>(this);
1251  }
1252  return *m_SeqMap;
1253 }
1254 
1255 
1257 {
1258  const COrg_ref* org_ref = 0;
1259  if ( const CSeqdesc* desc_src = x_SearchFirstDesc(1<<CSeqdesc::e_Source) ) {
1260  org_ref = &desc_src->GetSource().GetOrg();
1261  }
1262  else if ( const CSeqdesc* desc_org = x_SearchFirstDesc(1<<CSeqdesc::e_Org) ) {
1263  org_ref = &desc_org->GetOrg();
1264  }
1265  else {
1266  return ZERO_TAX_ID;
1267  }
1268  try {
1269  return org_ref->GetTaxId();
1270  }
1271  catch ( CException& /*ignored*/ ) {
1272  return ZERO_TAX_ID;
1273  }
1274 }
1275 
1276 
1278 {
1279  ITERATE ( TId, it, GetId() ) {
1280  switch ( it->Which() ) {
1281  case CSeq_id::e_Genbank:
1282  case CSeq_id::e_Embl:
1283  case CSeq_id::e_Ddbj:
1285  case CSeq_id::e_Other:
1287  case CSeq_id::e_Tpg:
1288  case CSeq_id::e_Tpe:
1289  case CSeq_id::e_Tpd:
1291  default:
1292  break;
1293  }
1294  }
1296 }
1297 
1298 
User-defined methods of the data storage class.
User-defined methods of the data storage class.
User-defined methods of the data storage class.
User-defined methods of the data storage class.
User-defined methods of the data storage class.
User-defined methods of the data storage class.
User-defined methods of the data storage class.
bool IsSetDescr(void) const
TDescList::const_iterator TDesc_CI
virtual void x_ParentAttach(CSeq_entry_Info &parent)
const CSeqdesc * x_SearchFirstDesc(TDescTypeMask type) const
virtual void x_TSEAttachContents(CTSE_Info &tse)
virtual void x_TSEDetachContents(CTSE_Info &tse)
TDesc_CI x_GetFirstDesc(TDescTypeMask types) const
virtual void x_ParentDetach(CSeq_entry_Info &parent)
virtual void x_DSDetachContents(CDataSource &ds)
void x_DoUpdate(TNeedUpdateFlags flags)
virtual void x_DSAttachContents(CDataSource &ds)
bool x_IsEndDesc(TDesc_CI iter) const
TDesc_CI x_GetNextDesc(TDesc_CI iter, TDescTypeMask types) const
bool x_CanGetDescr(void) const
bool CanGetId(void) const
TInst_Mol GetInst_Mol(void) const
const TInst_Fuzz & GetInst_Fuzz(void) const
TInst::THist::TReplaces TInst_Hist_Replaces
void x_ResetObjAnnot(void)
bool CanGetInst_Hist_Replaced_by(void) const
const TInst_Hist_Assembly & GetInst_Hist_Assembly(void) const
bool CanGetInst_Hist(void) const
void x_DoUpdate(TNeedUpdateFlags flags)
bool IsAa(void) const
bool IsSetInst_Fuzz(void) const
bool CanGetInst_Strand(void) const
bool HasId(const CSeq_id_Handle &id) const
void ResetInst_Ext()
void ResetInst_Length()
void SetInst_Length(TInst_Length v)
bool CanGetInst_Seq_data(void) const
int m_FeatureFetchPolicy
TObjAnnot & x_SetObjAnnot(void)
TInst_Topology GetInst_Topology(void) const
bool CanGetInst_Repr(void) const
CRef< CSeqMap > m_SeqMap
void x_DSDetachContents(CDataSource &ds)
bool RemoveId(const CSeq_id_Handle &id)
TInst_Repr GetInst_Repr(void) const
bool IsSetInst_Hist_Replaced_by(void) const
void x_TSEDetachContents(CTSE_Info &tse)
int GetFeatureFetchPolicy(void) const
int GetSequenceClass(void) const
const TDescr & x_GetDescr(void) const
bool CanGetInst(void) const
void ResetInst_Fuzz()
vector< CSeq_id_Handle > TId
Definition: bioseq_info.hpp:91
const CSeqMap & GetSeqMap(void) const
CRef< TObject > m_Object
bool IsSetInst_Hist_Deleted(void) const
void SetInst_Hist_Assembly(const TInst_Hist_Assembly &v)
bool IsSetInst_Ext(void) const
bool IsSetInst_Seq_data(void) const
TChunkIds m_Seq_dataChunks
bool x_IsSetDescr(void) const
TTaxId GetTaxId(void) const
bool IsSetInst_Topology(void) const
TInst::THist::TAssembly TInst_Hist_Assembly
void SetInst_Seq_data(TInst_Seq_data &v)
const TId & GetId(void) const
void x_ResetSeqMap(void)
void x_AddAssemblyChunkId(TChunkId chunk_id)
void SetInst_Mol(TInst_Mol v)
static CRef< TObject > sx_ShallowCopy(const TObject &obj)
void ResetId(void)
const TInst_Seq_data & GetInst_Seq_data(void) const
bool IsSetInst_Strand(void) const
CConstRef< TObject > GetCompleteBioseq(void) const
bool IsNa(void) const
void ResetInst_Mol()
void SetInst_Topology(TInst_Topology v)
TDescr & x_SetDescr(void)
void SetInst_Ext(TInst_Ext &v)
bool IsSetInst_Hist_Assembly(void) const
void SetInst_Hist(TInst_Hist &v)
void x_ParentDetach(CSeq_entry_Info &parent)
void SetInst_Strand(TInst_Strand v)
bool IsSetId(void) const
const TInst_Hist_Replaced_by & GetInst_Hist_Replaced_by(void) const
void x_TSEAttachContents(CTSE_Info &tse)
const TInst_Hist & GetInst_Hist(void) const
TInst_Length GetInst_Length(void) const
bool CanGetInst_Hist_Deleted(void) const
bool CanGetInst_Hist_Assembly(void) const
void x_ParentAttach(CSeq_entry_Info &parent)
bool IsSetInst_Repr(void) const
CBioseq_Info(const CBioseq_Info &src, TObjectCopyMap *copy_map)
Definition: bioseq_info.cpp:95
bool IsSetInst_Mol(void) const
TSeqPos GetBioseqLength(void) const
void SetInst_Repr(TInst_Repr v)
const TInst_Hist_Deleted & GetInst_Hist_Deleted(void) const
string IdString(void) const
void ResetInst()
bool CanGetInst_Mol(void) const
void x_AddSeq_dataChunkId(TChunkId chunk_id)
bool IsSetInst_Hist(void) const
bool CanGetInst_Hist_Replaces(void) const
const TInst_Hist_Replaces & GetInst_Hist_Replaces(void) const
void ResetInst_Seq_data()
bool CanGetInst_Topology(void) const
void ResetInst_Topology()
bool AddId(const CSeq_id_Handle &id)
void x_ResetDescr(void)
void SetInst(TInst &v)
void ResetInst_Repr()
bool CanGetInst_Length(void) const
void ResetInst_Strand()
TInst::TLength TInst_Length
CConstRef< TObject > GetBioseqCore(void) const
CFastMutex m_SeqMap_Mtx
TInst::THist::TReplaced_by TInst_Hist_Replaced_by
bool IsSetInst_Length(void) const
TInst_Strand GetInst_Strand(void) const
void SetInst_Hist_Replaced_by(TInst_Hist_Replaced_by &v)
void x_DSUnmapObject(CConstRef< TObject > obj, CDataSource &ds)
const TInst_Ext & GetInst_Ext(void) const
void x_SetChangedSeqMap(void)
const TInst & GetInst(void) const
virtual ~CBioseq_Info(void)
TSeqPos x_CalcBioseqLength(void) const
bool IsSetInst_Hist_Replaces(void) const
atomic< int > m_IdChangeCounter
bool IsSetInst(void) const
bool CanGetInst_Fuzz(void) const
void SetInst_Hist_Replaces(TInst_Hist_Replaces &v)
void SetInst_Fuzz(TInst_Fuzz &v)
TChunkId m_AssemblyChunk
void ResetInst_Hist()
void SetInst_Hist_Deleted(TInst_Hist_Deleted &v)
bool CanGetInst_Ext(void) const
void x_DSAttachContents(CDataSource &ds)
void x_AttachMap(CSeqMap &seq_map)
void x_DSMapObject(CConstRef< TObject > obj, CDataSource &ds)
void x_SetObject(TObject &obj)
TInst::THist::TDeleted TInst_Hist_Deleted
void x_Unmap(const CObject *obj, const CTSE_Info_Object *info)
void x_Map(const CObject *obj, const CTSE_Info_Object *info)
CDelta_seq –.
Definition: Delta_seq.hpp:66
CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:
Definition: ncbistre.hpp:802
Base class for all object manager exceptions.
TTaxId GetTaxId() const
Definition: Org_ref.cpp:72
CSeg_ext –.
Definition: Seg_ext.hpp:66
CSeqMap –.
Definition: seq_map.hpp:93
@Seq_descr.hpp User-defined methods of the data storage class.
Definition: Seq_descr.hpp:55
TObject & x_GetObject(void)
Definition: Seq_entry.hpp:56
void ParentizeOneLevel(void)
Definition: Seq_entry.cpp:89
CSeq_ext –.
Definition: Seq_ext.hpp:66
CSeq_hist –.
Definition: Seq_hist.hpp:66
TSeqPos GetLength(void) const
void x_UpdateCore(void) const
virtual void SetBioObjectId(const CBioObjectId &id)
void x_SetNeedUpdate(TNeedUpdateFlags flags)
CDataSource & GetDataSource(void) const
bool x_NeedUpdate(ENeedUpdate flag) const
void x_Update(TNeedUpdateFlags flags) const
void x_LoadChunks(const TChunkIds &chunk_ids) const
bool HasDataSource(void) const
void x_LoadChunk(TChunkId chunk_id) const
const CTSE_Info & GetTSE_Info(void) const
void x_UpdateComplete(void) const
virtual const CBioObjectId & GetBioObjectId(void) const
CConstRef< CBioseq_Info > FindMatchingBioseq(const CSeq_id_Handle &id) const
Definition: tse_info.cpp:776
CBioObjectId x_IndexBioseq(CBioseq_Info *)
Definition: tse_info.cpp:404
void x_ResetBioseqId(const CSeq_id_Handle &id, CBioseq_Info *info)
Definition: tse_info.cpp:918
void x_SetBioseqId(const CSeq_id_Handle &id, CBioseq_Info *info)
Definition: tse_info.cpp:870
Definition: map.hpp:338
static uch flags
static const char * str(char *buf, int n)
Definition: stats.c:84
#define ZERO_TAX_ID
Definition: ncbimisc.hpp:1115
unsigned int TSeqPos
Type for sequence locations and lengths.
Definition: ncbimisc.hpp:875
#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
SStrictId_Tax::TId TTaxId
Taxon id type.
Definition: ncbimisc.hpp:1048
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
Definition: ncbiexpt.hpp:704
virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)
Optimized implementation of CSerialObject::Assign, which is not so efficient.
Definition: Seq_id.cpp:318
static CSeq_id_Handle GetHandle(const CSeq_id &id)
Normal way of getting a handle, works for any seq-id.
CBioseq_Info * m_Bioseq
Definition: seq_map.hpp:380
void ResetMol(void)
Definition: seq_map.cpp:1625
bool x_UpdateSeq_inst(CSeq_inst &inst)
Definition: seq_map.hpp:506
void ResetRepr(void)
Definition: seq_map.cpp:1614
void SetRepr(CSeq_inst::TRepr repr)
Definition: seq_map.cpp:1609
static CRef< CSeqMap > CreateSeqMapForBioseq(const CBioseq &seq)
Definition: seq_map.cpp:1122
TSeqPos GetLength(CScope *scope) const
Definition: seq_map.hpp:482
void SetMol(CSeq_inst::TMol mol)
Definition: seq_map.cpp:1619
void Reset(void)
Reset reference object.
Definition: ncbiobj.hpp:773
#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
const TStr & GetStr(void) const
Get the variant data.
bool IsStr(void) const
Check if variant Str is selected.
Definition: Object_id_.hpp:291
const TData & GetData(void) const
Get the Data member data.
bool IsStr(void) const
Check if variant Str is selected.
const TStr & GetStr(void) const
Get the variant data.
Definition: Object_id_.hpp:297
const TData & GetData(void) const
Get the Data member data.
const TLabel & GetLabel(void) const
Get the Label member data.
const TType & GetType(void) const
Get the Type member data.
vector< CRef< CUser_field > > TData
list< CRef< CSeq_interval > > Tdata
const Tdata & Get(void) const
Get the member data.
const TWhole & GetWhole(void) const
Get the variant data.
Definition: Seq_loc_.cpp:172
list< CRef< CSeq_loc > > Tdata
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_loc_.hpp:475
const Tdata & Get(void) const
Get the member data.
const TPacked_pnt & GetPacked_pnt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:260
const Tdata & Get(void) const
Get the member data.
const TEquiv & GetEquiv(void) const
Get the variant data.
Definition: Seq_loc_.cpp:304
list< CRef< CSeq_loc > > Tdata
const TPoints & GetPoints(void) const
Get the Points member data.
const TInt & GetInt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:194
const TMix & GetMix(void) const
Get the variant data.
Definition: Seq_loc_.cpp:282
const TPacked_int & GetPacked_int(void) const
Get the variant data.
Definition: Seq_loc_.cpp:216
@ e_Other
for historical reasons, 'other' = 'refseq'
Definition: Seq_id_.hpp:104
@ e_Tpe
Third Party Annot/Seq EMBL.
Definition: Seq_id_.hpp:111
@ e_Tpd
Third Party Annot/Seq DDBJ.
Definition: Seq_id_.hpp:112
@ e_Ddbj
DDBJ.
Definition: Seq_id_.hpp:107
@ e_Tpg
Third Party Annot/Seq Genbank.
Definition: Seq_id_.hpp:110
@ e_not_set
No variant selected.
Definition: Seq_loc_.hpp:97
@ e_Null
not placed
Definition: Seq_loc_.hpp:98
@ e_Equiv
equivalent sets of locations
Definition: Seq_loc_.hpp:106
@ e_Empty
to NULL one Seq-id in a collection
Definition: Seq_loc_.hpp:99
@ e_Int
from to
Definition: Seq_loc_.hpp:101
@ e_Whole
whole sequence
Definition: Seq_loc_.hpp:100
const TSeq & GetSeq(void) const
Get the variant data.
Definition: Seq_entry_.cpp:102
TRepr GetRepr(void) const
Get the Repr member data.
Definition: Seq_inst_.hpp:565
const TSeg & GetSeg(void) const
Get the variant data.
Definition: Seq_ext_.cpp:114
const TUser & GetUser(void) const
Get the variant data.
Definition: Seqdesc_.cpp:384
bool IsSetSeq_data(void) const
the sequence Check if a value has been assigned to Seq_data data member.
Definition: Seq_inst_.hpp:805
TStrand GetStrand(void) const
Get the Strand member data.
Definition: Seq_inst_.hpp:777
ERepr
representation class
Definition: Seq_inst_.hpp:91
const TInst & GetInst(void) const
Get the Inst member data.
Definition: Bioseq_.hpp:336
TTopology GetTopology(void) const
Get the Topology member data.
Definition: Seq_inst_.hpp:733
bool IsSetAnnot(void) const
Check if a value has been assigned to Annot data member.
Definition: Bioseq_.hpp:354
bool IsSetRepr(void) const
Check if a value has been assigned to Repr data member.
Definition: Seq_inst_.hpp:546
bool IsSetMol(void) const
Check if a value has been assigned to Mol data member.
Definition: Seq_inst_.hpp:593
const TFuzz & GetFuzz(void) const
Get the Fuzz member data.
Definition: Seq_inst_.hpp:699
bool IsSetStrand(void) const
Check if a value has been assigned to Strand data member.
Definition: Seq_inst_.hpp:758
const TLiteral & GetLiteral(void) const
Get the variant data.
Definition: Delta_seq_.cpp:124
const TAnnot & GetAnnot(void) const
Get the Annot member data.
Definition: Bioseq_.hpp:366
const TId & GetId(void) const
Get the Id member data.
Definition: Bioseq_.hpp:290
bool IsSetHist(void) const
sequence history Check if a value has been assigned to Hist data member.
Definition: Seq_inst_.hpp:847
bool IsSetExt(void) const
extensions for special types Check if a value has been assigned to Ext data member.
Definition: Seq_inst_.hpp:826
const Tdata & Get(void) const
Get the member data.
Definition: Seq_descr_.hpp:166
bool IsSetInst(void) const
the sequence data Check if a value has been assigned to Inst data member.
Definition: Bioseq_.hpp:324
TLength GetLength(void) const
Get the Length member data.
Definition: Seq_inst_.hpp:659
TLength GetLength(void) const
Get the Length member data.
list< CRef< CSeq_id > > TId
Definition: Bioseq_.hpp:94
TMol GetMol(void) const
Get the Mol member data.
Definition: Seq_inst_.hpp:612
const CSeq_loc & Get(void) const
Definition: Ref_ext_.hpp:101
bool IsSetLength(void) const
length of sequence in residues Check if a value has been assigned to Length data member.
Definition: Seq_inst_.hpp:640
const THist & GetHist(void) const
Get the Hist member data.
Definition: Seq_inst_.hpp:859
const TExt & GetExt(void) const
Get the Ext member data.
Definition: Seq_inst_.hpp:838
E_Choice Which(void) const
Which variant is currently selected.
Definition: Delta_seq_.hpp:228
bool IsSetDescr(void) const
descriptors Check if a value has been assigned to Descr data member.
Definition: Bioseq_.hpp:303
ETopology
topology of molecule
Definition: Seq_inst_.hpp:121
EMol
molecule class in living organism
Definition: Seq_inst_.hpp:108
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_ext_.hpp:289
const TDelta & GetDelta(void) const
Get the variant data.
Definition: Seq_ext_.cpp:180
const TLoc & GetLoc(void) const
Get the variant data.
Definition: Delta_seq_.cpp:102
EStrand
strandedness in living organism
Definition: Seq_inst_.hpp:133
bool IsSetId(void) const
equivalent identifiers Check if a value has been assigned to Id data member.
Definition: Bioseq_.hpp:278
list< CRef< CSeq_annot > > TAnnot
Definition: Bioseq_.hpp:97
list< CRef< CDelta_seq > > Tdata
Definition: Delta_ext_.hpp:89
const Tdata & Get(void) const
Get the member data.
Definition: Seg_ext_.hpp:164
const TSeq_data & GetSeq_data(void) const
Get the Seq_data member data.
Definition: Seq_inst_.hpp:817
list< CRef< CSeq_loc > > Tdata
Definition: Seg_ext_.hpp:89
const TDescr & GetDescr(void) const
Get the Descr member data.
Definition: Bioseq_.hpp:315
const TRef & GetRef(void) const
Get the variant data.
Definition: Seq_ext_.cpp:136
bool IsSetTopology(void) const
Check if a value has been assigned to Topology data member.
Definition: Seq_inst_.hpp:708
bool IsSetFuzz(void) const
length uncertainty Check if a value has been assigned to Fuzz data member.
Definition: Seq_inst_.hpp:687
bool IsUser(void) const
Check if variant User is selected.
Definition: Seqdesc_.hpp:1122
@ e_Seg
segmented sequences
Definition: Seq_ext_.hpp:94
@ e_Ref
hot link to another sequence (a view)
Definition: Seq_ext_.hpp:95
@ e_Org
if all from one organism
Definition: Seqdesc_.hpp:116
@ e_User
user defined object
Definition: Seqdesc_.hpp:124
@ e_Source
source of materials, includes Org-ref
Definition: Seqdesc_.hpp:133
@ e_Literal
a piece of sequence
Definition: Delta_seq_.hpp:90
@ e_Loc
point to a sequence
Definition: Delta_seq_.hpp:89
where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is whole
static MDB_envinfo info
Definition: mdb_load.c:37
Int4 delta(size_t dimension_, const Int4 *score_)
static bool GetSeqId(const T &d, set< string > &labels, const string name="", bool detect=false, bool found=false)
#define _ASSERT
Modified on Sat May 25 14:21:55 2024 by modify_doxy.py rev. 669887