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

Go to the SVN repository for this file.

1 /* $Id: label.cpp 46222 2021-02-08 14:57:45Z shkeda $
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  * Authors: Mike DiCuccio
27  *
28  * File Description:
29  *
30  */
31 
32 #include <ncbi_pch.hpp>
33 
34 #include <serial/enumvalues.hpp>
35 
36 #include <gui/objutils/label.hpp>
37 #include <gui/objutils/user_type.hpp>
38 #include <gui/objutils/taxid_sel_set.hpp>
39 #include <gui/objutils/tooltip.hpp>
40 #include <gui/objutils/snp_gui.hpp>
41 #include <gui/utils/string_utils.hpp>
42 #include <map>
43 #include <corelib/ncbimtx.hpp>
44 #include <util/static_map.hpp>
45 
46 #include <objects/seq/Bioseq.hpp>
47 #include <objects/seq/Seq_annot.hpp>
48 #include <objects/seq/Annot_descr.hpp>
49 #include <objects/seq/Annotdesc.hpp>
50 #include <objects/seq/Seq_descr.hpp>
51 #include <objects/seq/Seqdesc.hpp>
52 
53 #include <objects/seqalign/Seq_align.hpp>
54 #include <objects/seqalign/Seq_align_set.hpp>
55 #include <objects/seqalign/Score.hpp>
56 #include <objects/seqalign/Dense_seg.hpp>
57 #include <objects/seqalign/Spliced_seg.hpp>
58 
59 #include <objects/seqfeat/Gene_ref.hpp>
60 #include <objects/seqfeat/Gb_qual.hpp>
61 #include <objects/seqfeat/BioSource.hpp>
62 #include <objects/seqfeat/Org_ref.hpp>
63 #include <objects/seqfeat/Imp_feat.hpp>
64 #include <objects/seqfeat/Variation_ref.hpp>
65 #include <objects/seqfeat/Variation_inst.hpp>
66 #include <objects/seqfeat/Delta_item.hpp>
67 
68 #include <objects/seqfeat/Clone_ref.hpp>
69 #include <objects/seqfeat/Clone_seq_set.hpp>
70 #include <objects/seqfeat/Clone_seq.hpp>
71 #include <objects/seqfeat/VariantProperties.hpp>
72 #include <objects/seqfeat/Phenotype.hpp>
73 #include <objects/seqfeat/SubSource.hpp>
74 #include <objects/seq/Seq_literal.hpp>
75 
76 #include <objects/seqloc/Seq_id.hpp>
77 #include <objects/seqloc/Seq_loc.hpp>
78 #include <objects/seqloc/Seq_interval.hpp>
79 #include <objects/seqloc/Seq_point.hpp>
80 
81 #include <objects/seqset/Seq_entry.hpp>
82 #include <objects/seqset/Bioseq_set.hpp>
83 
84 #include <objects/general/User_object.hpp>
85 #include <objects/general/User_field.hpp>
86 #include <objects/general/Dbtag.hpp>
87 #include <objects/general/Object_id.hpp>
88 
89 #include <objects/valerr/ValidError.hpp>
90 #include <objects/valerr/ValidErrItem.hpp>
91 
92 #include <objects/biotree/BioTreeContainer.hpp>
93 #include <objects/biotree/DistanceMatrix.hpp>
94 #include <objects/genomecoll/GC_AssemblyDesc.hpp>
95 
96 #include <objects/entrezgene/Entrezgene.hpp>
97 #include <objects/entrezgene/Entrezgene_Set.hpp>
98 
99 #include <objects/variation/Variation.hpp>
100 #include <objects/gbproj/GBProject_ver2.hpp>
101 #include <objects/gbproj/ProjectDescr.hpp>
102 #include <objects/gbproj/ProjectFolder.hpp>
103 #include <objects/gbproj/ProjectItem.hpp>
104 
105 #include <objmgr/util/sequence.hpp>
106 #include <objmgr/util/create_defline.hpp>
107 #include <objmgr/bioseq_set_handle.hpp>
108 #include <objmgr/align_ci.hpp>
109 
110 #include <serial/iterator.hpp>
111 #include <algo/align/util/score_builder.hpp>
112 
113 #include <objtools/snputil/snp_bitfield.hpp>
114 #include <objtools/snputil/snp_utils.hpp>
115 
116 
117 BEGIN_NCBI_SCOPE
118 USING_SCOPE(objects);
119 
120 
121 void CLabel::SetLabelByData(objects::CProjectItem& item, objects::CScope* scope)
122 {
123  string label = "No data";
124  if (item.IsSetItem()) {
125  const CSerialObject* obj = item.GetObject();
126  if(obj) {
127  label.clear();
128  GetLabel(*obj, &label, CLabel::eDefault, scope);
129  }
130  }
131  item.SetLabel(label);
132 }
133 
134 
135 DEFINE_STATIC_MUTEX(sm_Mutex);
136 CLabel::TLabelMap CLabel::sm_LabelMap;
137 CLabel::TAliasMap CLabel::sm_AliasMap;
138 
139 
140 void CLabel::GetLabel(
141  const CObject& obj, string* label, ELabelType type
142 ){
143  const CSerialObject* so = dynamic_cast<const CSerialObject*>(&obj);
144  if( so ){
145  TTypeInfo type_info = so->GetThisTypeInfo();
146  _ASSERT(type_info != CSeq_id::GetTypeInfo());
147  _ASSERT(type_info != CSeq_loc::GetTypeInfo());
148  _ASSERT(type_info != CSeq_entry::GetTypeInfo());
149  _ASSERT(type_info != CBioseq::GetTypeInfo());
150  _ASSERT(type_info != CBioseq_set::GetTypeInfo());
151  }
152 
153  CLabel::GetLabel( obj, label, type, NULL );
154 }
155 
156 void CLabel::GetLabel(
157  const CObject& obj, string* label, ELabelType type, CScope* scope
158 ){
159  if( !label ){
160  return;
161  }
162 
163  try {
164  const CSerialObject* so = dynamic_cast<const CSerialObject*>(&obj);
165  if (so) {
166  TLabelMap::const_iterator iter =
167  sm_LabelMap.find(so->GetThisTypeInfo()->GetName());
168  if (iter != sm_LabelMap.end()) {
169  iter->second->GetLabel(obj, label, type, scope);
170  } else {
171  *label = "[" + so->GetThisTypeInfo()->GetName() + "]";
172  }
173  } else {
174  TLabelMap::const_iterator iter =
175  sm_LabelMap.find(typeid(obj).name());
176  if (iter != sm_LabelMap.end()) {
177  iter->second->GetLabel(obj, label, type, scope);
178  } else {
179  *label = "[" + string(typeid(obj).name()) + "]";
180  }
181  }
182  } catch( CException& e ){
183  LOG_POST(Error << "CLabel::GetLabel(): error: " << e.GetMsg());
184  }
185 }
186 
187 void CLabel::TruncateLabel(string* label,
188  unsigned length_limit,
189  unsigned length_tolerance)
190 {
191  if (!label) return;
192  if (label->empty()) return;
193  size_t len = label->length();
194  if (len <= length_limit) return; // nothing to do
195 
196  // scan the label to find the nearest meaningful truncate point
197  bool point_found = false;
198  size_t i = length_limit;
199  size_t max_len = min(len, size_t(length_limit + length_tolerance));
200  for (; i < max_len; ++i) {
201  char c = (*label)[i];
202  if (c == ';' || c == '.') {
203  point_found = true;
204  break;
205  }
206  } // for
207 
208  if ( !point_found ) {
209  i = length_limit;
210  for (;i < max_len; ++i) {
211  char c = (*label)[i];
212  if (c == ' ' || c == ',') {
213  point_found = true;
214  break;
215  }
216  } // for
217  }
218 
219  if ( !point_found ) {
220  i = length_limit;
221  }
222 
223  label->erase(i);
224  label->append("...");
225 }
226 
227 
228 
229 void CLabel::RegisterLabelHandler( const string& type, ILabelHandler& handler )
230 {
231  CMutexGuard LOCK(sm_Mutex);
232  sm_LabelMap[type] = CRef<ILabelHandler>(&handler);
233 }
234 
235 
236 void CLabel::RegisterLabelHandler( const CTypeInfo& type, ILabelHandler& handler )
237 {
238  CMutexGuard LOCK(sm_Mutex);
239  sm_LabelMap[type.GetName()] = CRef<ILabelHandler>(&handler);
240 }
241 
242 
243 bool CLabel::HasHandler( const CTypeInfo& type )
244 {
245  return HasHandler( type.GetName() );
246 }
247 
248 
249 bool CLabel::HasHandler( const string& type )
250 {
251  CMutexGuard LOCK(sm_Mutex);
252  TLabelMap::const_iterator iter = sm_LabelMap.find(type);
253  return (iter != sm_LabelMap.end());
254 }
255 
256 
257 void CLabel::RegisterTypeIcon(const string& user_type,
258  const string& user_subtype,
259  const string& icon_alias)
260 {
261  string key = user_type + "&" + user_subtype;
262 
263  CMutexGuard LOCK(sm_Mutex);
264  sm_AliasMap[key] = icon_alias;
265 }
266 
267 
268 string CLabel::GetTypeIconAlias(const string& user_type, const string& user_subtype)
269 {
270  string key = user_type + "&" + user_subtype;
271 
272  CMutexGuard LOCK(sm_Mutex);
273 
274  TAliasMap::const_iterator it = sm_AliasMap.find(key);
275  if(it != sm_AliasMap.end()) {
276  return it->second;
277  } else if( ! user_subtype.empty()) {
278  // ignore subtype
279  key = user_type;
280  key += "&";
281  it = sm_AliasMap.find(key);
282  if(it != sm_AliasMap.end()) {
283  return it->second;
284  }
285  }
286  return "";
287 }
288 
289 
290 string CLabel::GetTypeIconAlias(const string& user_type)
291 {
292  string key = user_type + "&";
293 
294  CMutexGuard LOCK(sm_Mutex);
295  TAliasMap::const_iterator it = sm_AliasMap.find(key);
296  return (it != sm_AliasMap.end()) ? it->second : "";
297 }
298 
299 
300 void CLabel::GetIconAlias(const CObject& obj, string* alias,
301  objects::CScope* scope)
302 {
303  if(alias) {
304  string type, subtype;
305  GetLabel(obj, &type, eUserType, scope);
306  GetLabel(obj, &subtype, eUserSubtype, scope);
307  *alias = GetTypeIconAlias(type, subtype);
308  }
309 }
310 
311 ///////////////////////////////////////////////////////////////////////////////
312 // Description cache (singleton)
313 
314 class CLabelDescriptionCacheImpl
315 {
316 public:
317  typedef map<TIntId, string> TGi2DescriptionMap;
318 public:
319  CLabelDescriptionCacheImpl() {}
320 
321  string GetLabel(TGi gi) const
322  {
323  CFastMutexGuard lock(m_Lock);
324  TGi2DescriptionMap::const_iterator it = m_DescrCache.find(GI_TO(TIntId, gi));
325  if (it == m_DescrCache.end()) {
326  return kEmptyStr;
327  }
328  return it->second;
329  }
330  void GetLabel(TGi gi, string* label) const
331  {
332  CFastMutexGuard lock(m_Lock);
333  TGi2DescriptionMap::const_iterator it = m_DescrCache.find(GI_TO(TIntId, gi));
334  if (it == m_DescrCache.end()) {
335  label->clear();
336  return;
337  }
338  *label = it->second;
339  }
340  bool HasLabel(TGi gi) const
341  {
342  CFastMutexGuard lock(m_Lock);
343  TGi2DescriptionMap::const_iterator it = m_DescrCache.find(GI_TO(TIntId, gi));
344  if (it == m_DescrCache.end()) {
345  return false;
346  }
347  return true;
348  }
349 
350  void SetLabel(TGi gi, const string& label)
351  {
352  CFastMutexGuard lock(m_Lock);
353  m_DescrCache[GI_TO(TIntId, gi)] = label;
354  }
355 
356  void AddCaches(const map<TGi, string>& caches)
357  {
358  CFastMutexGuard lock(m_Lock);
359  map<TGi, string>::const_iterator iter = caches.begin();
360  for (; iter != caches.end(); ++iter) {
361  m_DescrCache[GI_TO(TIntId, iter->first)] = iter->second;
362  }
363  }
364 
365 private:
366  mutable CFastMutex m_Lock;
367  TGi2DescriptionMap m_DescrCache;
368 };
369 
370 static std::unique_ptr<CLabelDescriptionCacheImpl> s_DescrCachePtr;
371 
372 void CLabelDescriptionCache::InitCache()
373 {
374  if (s_DescrCachePtr.get() != 0) {
375  return; // double initialization
376  }
377  s_DescrCachePtr.reset(new CLabelDescriptionCacheImpl());
378 }
379 
380 void CLabelDescriptionCache::StopCache()
381 {
382  s_DescrCachePtr.reset(0);
383 }
384 
385 
386 static
387 TGi s_GetGi( const CSeq_id& id, CScope* scope )
388 {
389  // check: scope is NEEDED [protected]
390 
391  TGi gi = ZERO_GI;
392  try {
393  if( id.IsLocal() ) return gi;
394 
395  if( id.IsGi() ){
396  gi = id.GetGi();
397  }
398  if( (gi == ZERO_GI) && scope ){
399  CSeq_id_Handle bsh = sequence::GetId( id, *scope );
400  bsh = sequence::GetId( bsh, *scope, sequence::eGetId_ForceGi );
401  if( bsh ){
402  gi = bsh.GetGi();
403  }
404  }
405  } catch( std::exception& ){
406  gi = ZERO_GI;
407  }
408 
409  return gi;
410 }
411 
412 static CFastMutex s_DFLock;
413 static sequence::CDeflineGenerator s_DefGen; ///< This class seems to be non-thread safe even as a stack var
414 
415 static
416 inline void s_GetDefline( const CSeq_id& id, CScope* scope, string* label )
417 {
418  // check: scope is NEEDED [protected]
419 
420  if( scope ){
421  CBioseq_Handle bsh = scope->GetBioseqHandle( id );
422  if( bsh ){
423  CFastMutexGuard lock(s_DFLock);
424  *label = s_DefGen.GenerateDefline( bsh );
425  }
426  }
427 }
428 
429 static
430 void s_GetCachedDescription( const CSeq_id& id, CScope* scope, string* label )
431 {
432  // check: scope is NEEDED [indirectly protected]
433 
434  TGi gi = ZERO_GI;
435 
436  if( s_DescrCachePtr.get() != 0 ){ // check if cache is ON
437  gi = s_GetGi( id, scope );
438  if( gi != ZERO_GI ){ // gi labels get cached
439  s_DescrCachePtr->GetLabel( gi, label );
440  if( !label->empty() ){
441  return;
442  }
443  }
444  }
445 
446  // no cache, try sequence defline first
447  s_GetDefline( id, scope, label );
448 
449  if( label->empty() ){
450  // use regular label
451  id.GetLabel( label, CSeq_id::eBoth, CSeq_id::fLabel_Default );
452  }
453 
454  if( gi != ZERO_GI ){
455  s_DescrCachePtr->SetLabel(gi, *label);
456  }
457 }
458 
459 void CLabelDescriptionCache::CacheSeqId(const CSeq_id& id, CScope* scope)
460 {
461  // check: scope is NEEDED [indirectly protected]
462 
463  string fastaLabel;
464 
465  try {
466  if( s_DescrCachePtr.get() != 0 ){ // check if cache is ON
467  fastaLabel = id.AsFastaString();
468  TGi gi = s_GetGi( id, scope );
469  if( (gi != ZERO_GI) && !s_DescrCachePtr->HasLabel(gi) ){
470  string label;
471  s_GetDefline( id, scope, &label );
472  if( !label.empty() ){
473  s_DescrCachePtr->SetLabel( gi, label );
474  }
475  }
476  }
477  } NCBI_CATCH("Failed to load Seq-id: " + fastaLabel + ".");
478 }
479 
480 void CLabelDescriptionCache::AddCaches(const map<TGi, string>& caches)
481 {
482  if (s_DescrCachePtr.get() != 0) { // check if cache is ON
483  s_DescrCachePtr->AddCaches(caches);
484  }
485 }
486 
487 ///////////////////////////////////////////////////////////////////////////////
488 // Label Handlers
489 
490 // default format function for a seq-id
491 // this is used by seq-id and seq-loc formatting
492 static inline void s_GetSeqLabel(const CSeq_id& id, string* label,
493  CScope* scope, CLabel::ELabelType type)
494 {
495  // check: scope is NEEDED [protected]
496 
497  CConstRef<CSeq_id> id_ptr(&id);
498  if( scope && id_ptr->IsGi() ){
499  CSeq_id_Handle sih = sequence::GetId(id, *scope, sequence::eGetId_Best);
500  if( sih ){
501  id_ptr = sih.GetSeqId();
502  }
503  }
504 
505  switch( type ){
506  case CLabel::eUserType:
507  *label += CGUIUserType::sm_Tp_Sequence_ID;
508  break;
509 
510  case CLabel::eUserSubtype:
511  {{
512  CSeq_id::EAccessionInfo info = id_ptr->IdentifyAccession();
513  if( info & CSeq_id::fAcc_nuc ){
514  *label += CGUIUserType::sm_SbTp_DNA;
515 
516  } else if( info & CSeq_id::fAcc_prot ){
517  *label += CGUIUserType::sm_SbTp_Protein;
518  }
519  }}
520  break;
521 
522  case CLabel::eType:
523  *label += id_ptr->GetThisTypeInfo()->GetName();
524  break;
525 
526  default:
527  case CLabel::eContent:
528  id_ptr->GetLabel(label, CSeq_id::eContent, CSeq_id::fLabel_Default);
529  break;
530 
531  case CLabel::eUserTypeAndContent:
532  id_ptr->GetLabel(label, CSeq_id::eBoth, CSeq_id::fLabel_Default);
533  break;
534 
535  case CLabel::eDescriptionBrief:
536  *label += id_ptr->GetSeqIdString();
537  break;
538  case CLabel::eDescription:
539  s_GetCachedDescription(*id_ptr, scope, label);
540  break;
541 
542  case CLabel::eGi:
543  TGi gi = s_GetGi(id, scope);
544  if (gi != ZERO_GI) {
545  *label+="gi|";
546  *label+=NStr::NumericToString(gi);
547  }
548 
549  break;
550  }
551 }
552 
553 
554 //
555 // process a seq-interval
556 //
557 static inline
558 void s_GetSeq_intervalLabel(const CSeq_interval& interval, string* label,
559  CScope* scope, CLabel::ELabelType type,
560  const CSeq_id* last_id = NULL)
561 {
562  // check: scope is NEEDED [indirectly protected]
563 
564  switch (type) {
565  case CLabel::eUserType:
566  case CLabel::eUserSubtype:
567  break;
568 
569  case CLabel::eType:
570  *label += interval.GetThisTypeInfo()->GetName();
571  break;
572 
573  default:
574  case CLabel::eContent:
575  case CLabel::eUserTypeAndContent:
576  if ( !last_id || !interval.GetId().Match(*last_id)) {
577  if ( !label->empty() ) {
578  *label += "; ";
579  }
580  s_GetSeqLabel(interval.GetId(), label, scope, type);
581  *label += ": ";
582  }
583 
584  *label += NStr::IntToString(interval.GetFrom() + 1, NStr::fWithCommas);
585  *label += "-";
586  *label += NStr::IntToString(interval.GetTo() + 1, NStr::fWithCommas);
587 
588  *label += " [";
589  *label += NStr::IntToString(interval.GetLength(), NStr::fWithCommas);
590  *label += "]";
591 
592  if (interval.IsSetStrand()) {
593  switch (interval.GetStrand()) {
594  case eNa_strand_plus:
595  *label += " (+)";
596  break;
597  case eNa_strand_minus:
598  *label += " (-)";
599  break;
600  default:
601  *label += " (+)";
602  break;
603  }
604  }
605  break;
606  }
607 }
608 
609 static inline
610 void s_GetSeq_TotalRangeLabel(const CSeq_loc& loc, string* label,
611  CScope* scope, CLabel::ELabelType type)
612 {
613  // check: scope is NEEDED [indirectly protected]
614 
615  switch (type) {
616  case CLabel::eUserType:
617  *label += CGUIUserType::sm_Tp_Location;
618  break;
619 
620  case CLabel::eUserSubtype:
621  break;
622 
623  case CLabel::eType:
624  *label += loc.GetThisTypeInfo()->GetName();
625  break;
626 
627  default:
628  case CLabel::eContent:
629  case CLabel::eUserTypeAndContent:
630  {{
631  const CSeq_id& id = sequence::GetId(loc, scope);
632  TSeqRange range = loc.GetTotalRange();
633  s_GetSeqLabel(id, label, scope, type);
634  *label += ": ";
635  *label += NStr::IntToString(range.GetFrom() + 1, NStr::fWithCommas);
636  *label += "-";
637  *label += NStr::IntToString(range.GetTo() + 1, NStr::fWithCommas);
638 
639  *label += " [";
640  *label += NStr::IntToString(range.GetLength(), NStr::fWithCommas);
641  *label += "]";
642 
643  string extra_info = kEmptyStr;
644  ENa_strand strand = sequence::GetStrand(loc, scope);
645  switch (strand) {
646  case eNa_strand_minus:
647  extra_info = "-";
648  break;
649  case eNa_strand_unknown:
650  break;
651  case eNa_strand_plus:
652  default:
653  extra_info = "+";
654  break;
655  }
656 
657  size_t intervals = 0;
658  switch (loc.Which()) {
659  case CSeq_loc::e_Int:
660  intervals = 1;
661  break;
662 
663  case CSeq_loc::e_Packed_int:
664  intervals = loc.GetPacked_int().Get().size();
665  break;
666 
667  case CSeq_loc::e_Packed_pnt:
668  intervals = loc.GetPacked_pnt().GetPoints().size();
669  break;
670 
671  case CSeq_loc::e_Mix:
672  /// FIXME: this may not always be correct -
673  /// a mix may be a mix of complex intervals
674  intervals = loc.GetMix().Get().size();
675  break;
676 
677  default:
678  break;
679  }
680 
681  if (intervals != 0) {
682  if ( !extra_info.empty() )
683  *label += ", ";
684  extra_info += NStr::SizetToString(intervals);
685  extra_info += " interval";
686  if (intervals != 1) {
687  extra_info += "s";
688  }
689  }
690  if ( !extra_info.empty() ) {
691  *label += " (";
692  *label += extra_info;
693  *label += ")";
694  }
695  }}
696  break;
697  }
698 }
699 
700 static void s_BreakSeq_loc(const CSeq_loc& loc, vector<CRef<CSeq_loc> >& locs, CScope* scope)
701 {
702  // check: scope is NEEDED [indirectly protected]
703 
704  for (CSeq_loc_CI it(loc, CSeq_loc_CI::eEmpty_Allow); it; ++it) {
705  const CSeq_id& id = it.GetSeq_id();
706 
707  if (id.Which() == CSeq_id::e_not_set) {
708  continue;
709  }
710 
711  unsigned int i;
712  for (i = 0; i < locs.size(); ++i) {
713  if (sequence::IsSameBioseq(*locs[i]->GetId(), it.GetSeq_id(), scope, CScope::eGetBioseq_All))
714  break;
715  }
716 
717  if (i == locs.size()) {
718  locs.push_back(CRef<CSeq_loc>(new CSeq_loc()));
719  }
720 
721  locs[i]->Add(*it.GetRangeAsSeq_loc());
722  }
723 }
724 
725 //
726 // internal processing of seq-loc labels
727 // seq-locs frequently refer to GIs only - we need to use sequence accessions
728 // to make a more friendly label
729 //
730 static inline
731 const CSeq_id* s_GetLabel(const CSeq_loc& loc, string* label,
732  CScope* scope, CLabel::ELabelType type,
733  const CSeq_id* last_id = NULL)
734 {
735  // check: scope is NEEDED [indirectly protected]
736 
737  switch (type) {
738  case CLabel::eType:
739  *label += loc.GetThisTypeInfo()->GetName();
740  switch (loc.Which()) {
741  case CSeq_loc::e_Int:
742  *label += ".int";
743  break;
744  case CSeq_loc::e_Packed_int:
745  *label += ".packed-int";
746  break;
747  case CSeq_loc::e_Mix:
748  *label += ".mix";
749  break;
750  case CSeq_loc::e_Whole:
751  *label += ".whole";
752  break;
753  case CSeq_loc::e_Null:
754  *label += ".null";
755  break;
756 
757  default:
758  break;
759  }
760  return last_id;
761 
762  case CLabel::eUserType:
763  *label += CGUIUserType::sm_Tp_Location;
764  return last_id;
765 
766  case CLabel::eUserSubtype:
767  /*switch (loc.Which()) {
768  case CSeq_loc::e_Int:
769  *label += "Interval";
770  break;
771  case CSeq_loc::e_Packed_int:
772  *label += "Intervals";
773  break;
774  case CSeq_loc::e_Mix:
775  *label += "Mixed Location";
776  break;
777  case CSeq_loc::e_Whole:
778  *label += "Location";
779  break;
780 
781  default:
782  *label += "Location";
783  break;
784  }*/
785  return last_id;
786 
787  default:
788  break;
789  }
790 
791  switch (loc.Which()) {
792  case CSeq_loc::e_Whole:
793  s_GetSeqLabel(loc.GetWhole(), label, scope, type);
794  return &loc.GetWhole();
795 
796  case CSeq_loc::e_Int:
797  s_GetSeq_intervalLabel(loc.GetInt(), label, scope, type, last_id);
798  return &loc.GetInt().GetId();
799 
800  case CSeq_loc::e_Packed_int:
801  switch (type) {
802  case CLabel::eDescription:
803  case CLabel::eDescriptionBrief:
804  {{
805  CConstRef<CSeq_id> id(last_id);
806  string str;
807  ITERATE (CSeq_loc::TPacked_int::Tdata, iter,
808  loc.GetPacked_int().Get()) {
809  const CSeq_interval& ival = **iter;
810  if ( !str.empty() ) {
811  str += ", ";
812  }
813  s_GetSeq_intervalLabel(ival, &str, scope, type, id.GetPointer());
814  id.Reset(&ival.GetId());
815  }
816  *label += str;
817  return id.GetPointer();
818  }}
819 
820  default:
821  s_GetSeq_TotalRangeLabel(loc, label, scope, type);
822  return last_id;
823  }
824 
825  case CSeq_loc::e_Pnt:
826  {{
827  string str = NStr::IntToString(loc.GetPnt().GetPoint() + 1, NStr::fWithCommas);
828  if ( !last_id || !loc.GetPnt().GetId().Match(*last_id) ) {
829  if ( !label->empty() ) {
830  *label += "; ";
831  }
832  s_GetSeqLabel(loc.GetPnt().GetId(), label, scope, type);
833  *label += ": ";
834  } else if ( !label->empty() ) {
835  *label += ", ";
836  }
837  *label += str;
838  return &loc.GetPnt().GetId();
839  }}
840 
841  case CSeq_loc::e_Packed_pnt:
842  switch (type) {
843  case CLabel::eDescription:
844  case CLabel::eDescriptionBrief:
845  {{
846  string str;
847  ITERATE (CSeq_loc::TPacked_pnt::TPoints, iter,
848  loc.GetPacked_pnt().GetPoints()) {
849  if ( !str.empty() ) {
850  str += ", ";
851  }
852  str += NStr::IntToString(*iter, NStr::fWithCommas);
853  }
854 
855  if ( !last_id || !loc.GetPnt().GetId().Match(*last_id) ) {
856  if ( !label->empty() ) {
857  *label += "; ";
858  }
859  s_GetSeqLabel(loc.GetPnt().GetId(), label, scope, type);
860  *label += ": ";
861  } else if ( !label->empty() ) {
862  *label += ", ";
863  }
864  *label += str;
865  return &loc.GetPnt().GetId();
866  }}
867 
868  default:
869  s_GetSeq_TotalRangeLabel(loc, label, scope, type);
870  return last_id;
871  }
872 
873  case CSeq_loc::e_Mix:
874  switch (type) {
875  case CLabel::eDescription:
876  case CLabel::eDescriptionBrief:
877  {{
878  string str;
879  ITERATE (CSeq_loc::TMix::Tdata, iter, loc.GetMix().Get()) {
880  if ( !str.empty() ) {
881  str += ", ";
882  }
883  last_id = s_GetLabel(**iter, &str, scope, type, last_id);
884  }
885  *label += str;
886  return last_id;
887  }}
888 
889  default:
890  if (sequence::IsOneBioseq(loc, scope)) {
891  s_GetSeq_TotalRangeLabel(loc, label, scope, type);
892  } else {
893  vector<CRef<CSeq_loc> > locs;
894  s_BreakSeq_loc(loc, locs, scope);
895 
896  for (unsigned int i = 0; i < locs.size(); ++i) {
897  if (i > 0)
898  *label += ";";
899  s_GetSeq_TotalRangeLabel(*locs[i], label, scope, type);
900  }
901  }
902  return last_id;
903  }
904 
905  default:
906  loc.GetLabel(label);
907  return NULL;
908  }
909 }
910 
911 
912 //
913 //
914 // seq-id handler
915 //
916 //
917 class CSeq_idHandler : public ILabelHandler
918 {
919 public:
920  void GetLabel(const CObject& obj, string* label,
921  CLabel::ELabelType type, CScope* scope) const
922  {
923  const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
924  if (id) {
925  s_GetSeqLabel(*id, label, scope, type);
926  }
927  }
928 };
929 
930 
931 //
932 //
933 // seq-loc handler
934 //
935 //
936 class CSeq_locHandler : public ILabelHandler
937 {
938 public:
939  void GetLabel(const CObject& obj, string* label,
940  CLabel::ELabelType type, CScope* scope) const
941  {
942  const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
943  if (loc) {
944  string s;
945  s_GetLabel(*loc, &s, scope, type);
946  *label += s;
947  }
948  }
949 };
950 
951 
952 
953 //
954 //
955 // bioseq handler
956 //
957 //
958 class CBioseqHandler : public ILabelHandler
959 {
960 public:
961  void GetLabel(const CObject& obj, string* label,
962  CLabel::ELabelType type, CScope* /*scope*/) const
963  {
964  const CBioseq* bioseq = dynamic_cast<const CBioseq*>(&obj);
965  if (bioseq) {
966  switch (type) {
967  case CLabel::eUserType:
968  *label += CGUIUserType::sm_Tp_Sequence;
969  break;
970 
971  case CLabel::eUserSubtype:
972  if(bioseq->IsNa()) {
973  *label += CGUIUserType::sm_SbTp_DNA;
974  } else if(bioseq->IsAa()) {
975  *label += CGUIUserType::sm_SbTp_Protein;
976  }
977  break;
978 
979  case CLabel::eType:
980  bioseq->GetLabel(label, CBioseq::eType);
981  break;
982  case CLabel::eContent:
983  bioseq->GetLabel(label, CBioseq::eContent);
984  break;
985 
986  default:
987  case CLabel::eUserTypeAndContent:
988  case CLabel::eDescription:
989  case CLabel::eDescriptionBrief:
990  bioseq->GetLabel(label, CBioseq::eBoth);
991  break;
992  }
993  }
994  }
995 };
996 
997 //
998 //
999 // CVcfVariant handler
1000 //
1001 //
1002 class CVcfVariantHandler : public ILabelHandler
1003 {
1004 public:
1005  void GetLabel(const CObject& obj, string* label,
1006  CLabel::ELabelType type, CScope* scope) const
1007  {
1008  const CVcfVariant* vcf_variant = dynamic_cast<const CVcfVariant*>(&obj);
1009  if (vcf_variant) {
1010  string s;
1011  vcf_variant->GetLabel(s, type);
1012  *label += s;
1013  }
1014  }
1015 };
1016 
1017 
1018 //
1019 // Bioseq_set handler
1020 //
1021 static void s_GetBioseq_setType(const CBioseq_set& bst, string* label)
1022 {
1023  // NB: This table should be kept in synch with CBioseq_set::EClass values
1024  typedef SStaticPair<CBioseq_set::TClass, const char*> TPair;
1025  static const TPair sc_Types[] = {
1026  {CBioseq_set::eClass_not_set, "not determined"},
1027  {CBioseq_set::eClass_nuc_prot, "nuc-prot"},
1028  {CBioseq_set::eClass_segset, "segmented"},
1029  {CBioseq_set::eClass_conset, "constructed"},
1030  {CBioseq_set::eClass_parts, "parts"},
1031  {CBioseq_set::eClass_gibb, "geninfo backbone"},
1032  {CBioseq_set::eClass_gi, "geninfo"},
1033  {CBioseq_set::eClass_genbank, "genbank"},
1034  {CBioseq_set::eClass_pir, "pir"},
1035  {CBioseq_set::eClass_pub_set, "publication"},
1036  {CBioseq_set::eClass_equiv, "equivalent maps or seqs"},
1037  {CBioseq_set::eClass_swissprot, "swissprot"},
1038  {CBioseq_set::eClass_pdb_entry, "pdb"},
1039  {CBioseq_set::eClass_mut_set, "mutations"},
1040  {CBioseq_set::eClass_pop_set, "population study"},
1041  {CBioseq_set::eClass_phy_set, "phylogenetic study"},
1042  {CBioseq_set::eClass_eco_set, "ecological sample study"},
1043  {CBioseq_set::eClass_gen_prod_set, "genomic products"},
1044  {CBioseq_set::eClass_wgs_set, "wgs project"},
1045  {CBioseq_set::eClass_other, "other"},
1046  };
1047  typedef CStaticArrayMap<CBioseq_set::TClass, const char*> TBioseq_setTypes;
1048  DEFINE_STATIC_ARRAY_MAP(TBioseq_setTypes, sc_Bioseq_setTypes, sc_Types);
1049 
1050  TBioseq_setTypes::const_iterator i = sc_Bioseq_setTypes.find(bst.GetClass());
1051  *label += (i != sc_Bioseq_setTypes.end()) ?
1052  sc_Bioseq_setTypes.find(bst.GetClass())->second :
1053  CBioseq_set::ENUM_METHOD_NAME(EClass)()->FindName(bst.GetClass(), true);
1054 }
1055 
1056 
1057 static void s_GetIdLabel(const CBioseq_set& bst, string* label, CScope* scope)
1058 {
1059  if (bst.GetSeq_set().empty()) {
1060  return;
1061  }
1062  const CBioseq* lcl = NULL;
1063  vector<string> ids;
1064 
1065  ITERATE (CBioseq_set::TSeq_set, it, bst.GetSeq_set()) {
1066  const CBioseq* bsp = NULL;
1067  if ((*it)->IsSeq()) {
1068  bsp = &(*it)->GetSeq();
1069  } else if ((*it)->IsSet()) {
1070  const CBioseq_set& bss = (*it)->GetSet();
1071  try {
1072  switch (bss.GetClass()) {
1073  case CBioseq_set::eClass_nuc_prot:
1074  bsp = &bss.GetNucFromNucProtSet();
1075  break;
1076  case CBioseq_set::eClass_segset:
1077  bsp = &bss.GetMasterFromSegSet();
1078  break;
1079  default:
1080  break;
1081  }
1082  } catch (CException&) {
1083  bsp = NULL;
1084  }
1085  }
1086  if (bsp != NULL) {
1087  CRef<CSeq_id> id = FindBestChoice(bsp->GetId(), CSeq_id::Score);
1088  const CTextseq_id* tsip = id->GetTextseq_Id();
1089  if (tsip != NULL && tsip->IsSetAccession()) {
1090  ids.push_back(tsip->GetAccession());
1091  } else if (id->IsLocal() && id->GetLocal().IsStr()) {
1092  if (lcl == NULL) {
1093  lcl = bsp;
1094  }
1095  }
1096  }
1097  }
1098 
1099  sort(ids.begin(), ids.end());
1100  vector<string>::iterator new_end = unique(ids.begin(), ids.end());
1101  if (new_end != ids.end()) {
1102  ids.erase(new_end);
1103  }
1104 
1105  if (!ids.empty()) {
1106  *label += ids.front();
1107  if (ids.size() > 1) {
1108  *label += '-';
1109  *label += ids.back();
1110  }
1111  } else if (lcl != NULL) {
1112  CLabel::GetLabel(*lcl, label, CLabel::eContent, scope);
1113  }
1114 }
1115 
1116 
1117 static void s_GetNucProtContent(const CBioseq_set& bst, string* label, CScope* scope)
1118 {
1119  _ASSERT(bst.GetClass() == CBioseq_set::eClass_nuc_prot);
1120 
1121  try {
1122  const CBioseq& seq = bst.GetNucFromNucProtSet();
1123  CLabel::GetLabel(seq, label, CLabel::eContent, scope);
1124  } catch (CException&) {}
1125 }
1126 
1127 
1128 static void s_GetSegsetContent(const CBioseq_set& bst, string* label, CScope* scope)
1129 {
1130  _ASSERT(bst.GetClass() == CBioseq_set::eClass_segset);
1131 
1132  try {
1133  const CBioseq& seq = bst.GetMasterFromSegSet();
1134  CLabel::GetLabel(seq, label, CLabel::eContent, scope);
1135  } catch (CException&) {}
1136 }
1137 
1138 static void s_GetGenProdContent(const CBioseq_set& bst, string* label, CScope* scope)
1139 {
1140  _ASSERT(bst.GetClass() == CBioseq_set::eClass_gen_prod_set);
1141 
1142  try {
1143  const CBioseq& seq = bst.GetGenomicFromGenProdSet();
1144  CLabel::GetLabel(seq, label, CLabel::eContent, scope);
1145  } catch (CException&) {}
1146 }
1147 
1148 static void s_GetBioseq_setContent(const CBioseq_set& bst, string* label, CScope* scope)
1149 {
1150  switch(bst.GetClass()) {
1151  case CBioseq_set::eClass_nuc_prot:
1152  s_GetNucProtContent(bst, label, scope);
1153  break;
1154 
1155  case CBioseq_set::eClass_segset:
1156  s_GetSegsetContent(bst, label, scope);
1157  break;
1158 
1159  case CBioseq_set::eClass_mut_set:
1160  case CBioseq_set::eClass_pop_set:
1161  case CBioseq_set::eClass_phy_set:
1162  case CBioseq_set::eClass_eco_set:
1163  s_GetIdLabel(bst, label, scope);
1164  break;
1165 
1166  case CBioseq_set::eClass_gen_prod_set:
1167  s_GetGenProdContent(bst, label, scope);
1168  break;
1169 
1170  case CBioseq_set::eClass_genbank:
1171  // if just a wrapper return the label of the wrapped Seq-entry
1172  if (bst.GetSeq_set().size() == 1) {
1173  CLabel::GetLabel(*bst.GetSeq_set().front(), label, CLabel::eContent, scope);
1174  } else {
1175  bst.GetLabel(label, CBioseq_set::eContent);
1176  }
1177  break;
1178 
1179  default:
1180  bst.GetLabel(label, CBioseq_set::eContent);
1181  break;
1182  };
1183 }
1184 
1185 static bool s_HasAlignment(const CBioseq_set& bst, CScope* scope)
1186 {
1187  // check: scope is NEEDED [protected]
1188 
1189  if( scope ){
1190  CBioseq_set_Handle bsh = scope->GetBioseq_setHandle(bst);
1191  if( bsh ){
1192  CSeq_entry_Handle tse = bsh.GetTopLevelEntry();
1193 
1194  SAnnotSelector sel;
1195  sel.SetMaxSize(1);
1196  sel.SetLimitTSE(tse);
1197  CAlign_CI align_it(tse, sel);
1198  if (align_it.GetSize() != 0) {
1199  return true;
1200  }
1201  }
1202  }
1203  return false;
1204 }
1205 
1206 
1207 class CBioseq_setHandler : public ILabelHandler
1208 {
1209 public:
1210  void GetLabel(const CObject& obj, string* label,
1211  CLabel::ELabelType type, CScope* scope) const
1212  {
1213  // check: scope is NEEDED [indirectly protected]
1214 
1215  if( !label ) return;
1216 
1217 
1218  const CBioseq_set* bioseq_set = dynamic_cast<const CBioseq_set*>(&obj);
1219  if (bioseq_set) {
1220  switch (type) {
1221  case CLabel::eUserType:
1222  *label += CGUIUserType::sm_Tp_Sequence_Set;
1223  break;
1224 
1225  case CLabel::eUserSubtype: {
1226  switch(bioseq_set->GetClass()) {
1227  case CBioseq_set::eClass_nuc_prot:
1228  *label += CGUIUserType::sm_SbTp_NucProt;
1229  break;
1230  case CBioseq_set::eClass_segset:
1231  *label += CGUIUserType::sm_SbTp_SegSeq;
1232  break;
1233  case CBioseq_set::eClass_gen_prod_set:
1234  *label += CGUIUserType::sm_SbTp_GenProdSet;
1235  break;
1236  case CBioseq_set::eClass_pop_set: {
1237  bool aln = s_HasAlignment(*bioseq_set, scope);
1238  *label += aln ? CGUIUserType::sm_SbTp_PopSet_Aln
1239  : CGUIUserType::sm_SbTp_PopSet;
1240  break;
1241  }
1242  case CBioseq_set::eClass_phy_set: {
1243  bool aln = s_HasAlignment(*bioseq_set, scope);
1244  *label += aln ? CGUIUserType::sm_SbTp_PhySet_Aln
1245  : CGUIUserType::sm_SbTp_PhySet;
1246  break;
1247  }
1248  case CBioseq_set::eClass_eco_set: {
1249  bool aln = s_HasAlignment(*bioseq_set, scope);
1250  *label += aln ? CGUIUserType::sm_SbTp_EcoSet_Aln
1251  : CGUIUserType::sm_SbTp_EcoSet;
1252  break;
1253  }
1254  case CBioseq_set::eClass_mut_set: {
1255  bool aln = s_HasAlignment(*bioseq_set, scope);
1256  *label += aln ? CGUIUserType::sm_SbTp_MutSet_Aln
1257  : CGUIUserType::sm_SbTp_MutSet;
1258  break;
1259  }
1260  default:
1261  break;
1262  }
1263  break;
1264  }
1265  case CLabel::eType:
1266  s_GetBioseq_setType(*bioseq_set, label);
1267  break;
1268  case CLabel::eContent:
1269  s_GetBioseq_setContent(*bioseq_set, label, scope);
1270  break;
1271 
1272  default:
1273  case CLabel::eUserTypeAndContent:
1274  case CLabel::eDescriptionBrief:
1275  case CLabel::eDescription:
1276  GetLabel(*bioseq_set, label, CLabel::eType, scope);
1277  *label += ": ";
1278  GetLabel(*bioseq_set, label, CLabel::eContent, scope);
1279  break;
1280  }
1281  }
1282  }
1283 };
1284 
1285 /// handler specific for User-object features
1286 class CUserFeatHandler : public ILabelHandler
1287 {
1288 public:
1289  void GetLabel(const CObject& obj_in, string* label,
1290  CLabel::ELabelType type, CScope* scope) const
1291  {
1292  if (label == NULL) {
1293  return;
1294  }
1295 
1296  const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(&obj_in);
1297  if (feat) {
1298  _ASSERT(feat->GetData().IsUser());
1299  const CUser_object& obj = feat->GetData().GetUser();
1300  const CObject_id& id = obj.GetType();
1301 
1302  switch (type) {
1303  case CLabel::eUserType:
1304  *label += CGUIUserType::sm_Tp_Feature;
1305  break;
1306 
1307  case CLabel::eUserSubtype:
1308  if (id.IsStr()) {
1309  *label += id.GetStr();
1310  break;
1311  } else if (obj.IsSetClass()) {
1312  *label += obj.GetClass();
1313  break;
1314  }
1315  break;
1316 
1317  case CLabel::eType:
1318  if (id.IsStr()) {
1319  *label += id.GetStr();
1320  break;
1321  } else if (obj.IsSetClass()) {
1322  *label += obj.GetClass();
1323  break;
1324  }
1325  break;
1326 
1327  case CLabel::eUserTypeAndContent:
1328  case CLabel::eDescriptionBrief:
1329  case CLabel::eDescription:
1330  case CLabel::eContent:
1331  default:
1332  /// for content, we use the product seq-id, if it
1333  /// is available; otherwise, we use the standard text
1334  if (id.IsStr() && id.GetStr() == "clone placement") {
1335  *label += '[';
1336  *label += id.GetStr();
1337  *label += ']';
1338  ///
1339  /// clone placement user objects
1340  ///
1341  CConstRef<CUser_field> field;
1342 
1343  field = obj.GetFieldRef("clone placement.name");
1344  if (field) {
1345  if ( !label->empty() ) {
1346  *label += ' ';
1347  }
1348  *label += "/name=";
1349  *label += field->GetData().GetStr();
1350  }
1351 
1352  field = obj.GetFieldRef("clone placement.type");
1353  if (field) {
1354  if ( !label->empty() ) {
1355  *label += ' ';
1356  }
1357  *label += "/type=";
1358  *label += field->GetData().GetStr();
1359  }
1360 
1361  field = obj.GetFieldRef("clone placement.concordant");
1362  if (field) {
1363  if ( !label->empty() ) {
1364  *label += ' ';
1365  }
1366  *label += "/concordant=";
1367  *label += field->GetData().GetBool() ? "true" : "false";
1368  }
1369  } else if (id.IsStr() &&
1370  NStr::EqualNocase(id.GetStr(), "Display Data") &&
1371  obj.GetFieldRef("name")) {
1372  *label += obj.GetFieldRef("name")->GetData().GetStr();
1373  } else {
1374  /// default handler - the above steps exit early
1375  feature::GetLabel(*feat, label, feature::fFGL_Content, scope);
1376  }
1377  break;
1378  }
1379  }
1380  }
1381 };
1382 
1383 
1384 static int s_GetChildNum(const objects::CSeq_feat& feat)
1385 {
1386  string num_str = feat.GetNamedQual("Child Count");
1387  if ( !num_str.empty() ) {
1388  try {
1389  return NStr::StringToInt(num_str);
1390  } catch (CException&) {
1391  // ingore it
1392  }
1393  }
1394  return -1;
1395 }
1396 
1397 
1398 static bool s_IsLOH(const CVariation_ref& var)
1399 {
1400  if (var.CanGetConsequence()) {
1401  ITERATE (CVariation_ref::TConsequence, iter, var.GetConsequence()) {
1402  if ((*iter)->IsLoss_of_heterozygosity()) {
1403  return true;
1404  }
1405  }
1406  }
1407  return false;
1408 }
1409 
1410 
1411 static bool s_IsCopyNumberMethod(const CVariation_ref::TMethod& method)
1412 {
1413  ITERATE (CVariation_ref::TMethod, iter, method) {
1414  switch (*iter) {
1415  case CVariation_ref::eMethod_E_unknown:
1416  case CVariation_ref::eMethod_E_sequencing:
1417  case CVariation_ref::eMethod_E_maph:
1418  case CVariation_ref::eMethod_E_mcd_analysis:
1419  case CVariation_ref::eMethod_E_optical_mapping:
1420  return true;
1421  default:
1422  break;
1423  }
1424  }
1425 
1426  return false;
1427 }
1428 
1429 // seq-feat handler
1430 class CSeq_featHandler : public ILabelHandler
1431 {
1432 public:
1433  void GetLabel(const CObject& obj, string* label,
1434  CLabel::ELabelType type, CScope* scope) const
1435  {
1436  if (label == NULL) {
1437  return;
1438  }
1439 
1440  const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(&obj);
1441  if ( !feat ) {
1442  return;
1443  }
1444  if (feat->GetData().IsUser()) {
1445  m_UserHandler.GetLabel(obj, label, type, scope);
1446  return;
1447  }
1448 
1449  switch (type) {
1450  case CLabel::eUserType:
1451  *label += CGUIUserType::sm_Tp_Feature;
1452  break;
1453 
1454  case CLabel::eUserSubtype:
1455  switch (feat->GetData().GetSubtype()) {
1456  case CSeqFeatData::eSubtype_variation:
1457  *label += "SNP";
1458  break;
1459 
1460  case CSeqFeatData::eSubtype_exon:
1461  *label += "exon";
1462  break;
1463  case CSeqFeatData::eSubtype_intron:
1464  *label += "[intron]";
1465  break;
1466 
1467  default:
1468  feature::GetLabel(*feat, label, feature::fFGL_Type, scope);
1469  break;
1470  }
1471  break;
1472 
1473  case CLabel::eType:
1474  /// for type, we just used the standard text
1475  switch (feat->GetData().GetSubtype()) {
1476  case CSeqFeatData::eSubtype_intron:
1477  *label += "[intron]";
1478  break;
1479  case CSeqFeatData::eSubtype_exon:
1480  case CSeqFeatData::eSubtype_imp:
1481  feature::GetLabel(*feat, label, feature::fFGL_Type, scope);
1482  break;
1483 
1484  default:
1485  *label += feat->GetThisTypeInfo()->GetName();
1486  break;
1487  }
1488  break;
1489 
1490  case CLabel::eContentAndProduct:
1491  if (feat->IsSetProduct()) {
1492  try {
1493  string s;
1494  const CSeq_id& id = sequence::GetId(feat->GetProduct(), scope);
1495  s_GetSeqLabel(id, &s, scope, CLabel::eContent);
1496  // For proteins, show both the accession and the protein product name.
1497  if (CSeqFeatData::eSubtype_cdregion == feat->GetData().GetSubtype()) {
1498  string product_str;
1499  feature::GetLabel(*feat, &product_str, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1500  string type_str;
1501  feature::GetLabel(*feat, &type_str, feature::fFGL_Type, scope);
1502  // Do not append the product if it contains type information only
1503  if (product_str != type_str) {
1504  s += ": ";
1505  s += product_str;
1506  }
1507  }
1508  *label += s;
1509  }
1510  catch (CException&) {
1511  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1512  }
1513  }
1514  break;
1515 
1516  case CLabel::eContent:
1517  if (x_UseCustomLabel(*feat)) {
1518  x_GetCustomLabel(*feat, *label);
1519  }
1520  /// for content, we use the product seq-id, if it
1521  /// is available; otherwise, we use the standard text
1522  else if (feat->IsSetProduct()) {
1523  try {
1524  const CSeq_id& id = sequence::GetId(feat->GetProduct(), scope);
1525  s_GetSeqLabel(id, label, scope, CLabel::eContent);
1526  }
1527  catch (CException&) {
1528  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1529  }
1530  } else {
1531  switch (feat->GetData().GetSubtype()) {
1532  case CSeqFeatData::eSubtype_imp:
1533  {{ // logic borrowed from misc_feature
1534  bool got_label = false;
1535  if (feat->IsSetQual()) {
1536  ITERATE(CSeq_feat::TQual, it, feat->GetQual()) {
1537  if (NStr::EqualNocase((*it)->GetQual(),"Name") ||
1538  NStr::EqualNocase((*it)->GetQual(),"ID")) {
1539  *label = (*it)->GetVal();
1540  got_label = true;
1541  if (NStr::EqualNocase((*it)->GetQual(),"Name"))
1542  break;
1543  }
1544  }
1545  }
1546  if (!got_label) {
1547  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoComments | feature::fFGL_NoQualifiers, scope);
1548  *label += " ";
1549  if (feat->GetData().GetImp().IsSetDescr()) {
1550  *label += feat->GetData().GetImp().GetDescr();
1551  }
1552  }
1553  if (label->size() > 30) *label = label->substr(0, 30) + "...";
1554  }}
1555  break;
1556 
1557  case CSeqFeatData::eSubtype_site:
1558  if (feat->GetData().GetSite() == CSeqFeatData::eSite_other &&
1559  feat->IsSetComment()) {
1560  *label += feat->GetComment();
1561  } else {
1562  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1563  }
1564  break;
1565 
1566  case CSeqFeatData::eSubtype_exon:
1567  {{
1568  *label += "exon";
1569  const string& q = feat->GetNamedQual("number");
1570  if ( !q.empty() ) {
1571  *label += " ";
1572  *label += q;
1573  }
1574  }}
1575  break;
1576  case CSeqFeatData::eSubtype_intron:
1577  {{
1578  *label += "[intron]";
1579  }}
1580  break;
1581  case CSeqFeatData::eSubtype_variation:
1582  {{
1583  /// RSID first
1584  NSnp::TRsid Rsid(NSnp::GetRsid(*feat));
1585  if(Rsid) {
1586  *label += "rs";
1587  *label += NStr::NumericToString(Rsid);
1588  }
1589  else {
1590  if (label->empty() && feat->IsSetComment()) {
1591  *label += feat->GetComment();
1592  }
1593  }
1594  }}
1595  break;
1596 
1597  case CSeqFeatData::eSubtype_variation_ref:
1598  {{
1599  const CVariation_ref& var = feat->GetData().GetVariation();
1600  if (var.CanGetId()) {
1601  if (var.GetId().GetTag().IsId()) {
1602  *label += var.GetId().GetDb() + "|";
1603  *label += NStr::IntToString(var.GetId().GetTag().GetId());
1604  } else {
1605  *label += var.GetId().GetTag().GetStr();
1606  }
1607  } else {
1608  if (feat->CanGetLocation()) {
1609  const CSeq_loc& loc = feat->GetLocation();
1610  s_GetSeq_TotalRangeLabel(loc, label, scope, CLabel::eContent);
1611  }
1612 
1613  //feature::GetLabel(*feat, label, feature::fFGL_Both, scope);
1614  }
1615  }}
1616  break;
1617 
1618  case CSeqFeatData::eSubtype_misc_feature:
1619  {{
1620  bool got_label = false;
1621  if (feat->IsSetQual()) {
1622  ITERATE(CSeq_feat::TQual, it, feat->GetQual()) {
1623  if (NStr::EqualNocase((*it)->GetQual(),"Name") ||
1624  NStr::EqualNocase((*it)->GetQual(),"ID")) {
1625  *label += (*it)->GetVal();
1626  got_label = true;
1627  break;
1628  }
1629  }
1630  }
1631  if ( !got_label ) {
1632  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1633  }
1634  }}
1635  break;
1636 
1637  case CSeqFeatData::eSubtype_clone:
1638  {{
1639  const CSeqFeatData::TClone& clone = feat->GetData().GetClone();
1640  if (clone.IsSetName()) {
1641  *label += clone.GetName();
1642  } else {
1643  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1644  }
1645  }}
1646  break;
1647 
1648  case CSeqFeatData::eSubtype_seq:
1649  {{
1650  if (feat->CanGetTitle()) {
1651  *label += feat->GetTitle();
1652  } else {
1653  s_GetSeq_TotalRangeLabel(feat->GetData().GetSeq(), label, scope, type);
1654  }
1655  }}
1656  break;
1657 
1658  default:
1659  feature::GetLabel(*feat, label, feature::fFGL_Content, scope);
1660  break;
1661  }
1662  }
1663  break;
1664 
1665  case CLabel::eDescriptionBrief:
1666  case CLabel::eDescription:
1667  /// the brief description contains:
1668  /// - the label containing both type and content
1669  /// - a line showing feature lengths
1670  switch (feat->GetData().GetSubtype()) {
1671  case CSeqFeatData::eSubtype_variation_ref:
1672  {{
1673  const CVariation_ref& var = feat->GetData().GetVariation();
1674  string validation = "Not Tested";
1675  if (var.IsSetValidated()) {
1676  if (var.GetValidated()) {
1677  validation = "Yes";
1678  } else {
1679  validation = "Fail";
1680  }
1681  } else if (var.IsSetVariant_prop() && var.GetVariant_prop().IsSetOther_validation()) {
1682  if (var.GetVariant_prop().GetOther_validation()) {
1683  validation = "Yes";
1684  } else {
1685  validation = "Fail";
1686  }
1687  }
1688 
1689  // phenotype and clinical-significance
1690  string phenotype = "";
1691  string clinical_sig = "";
1692  if (var.CanGetPhenotype()) {
1693  ITERATE (CVariation_ref::TPhenotype, pnt_iter, var.GetPhenotype()) {
1694  if (clinical_sig.empty() && (*pnt_iter)->CanGetClinical_significance()) {
1695  clinical_sig = NSnp::ClinSigAsString((*pnt_iter)->GetClinical_significance());
1696  }
1697 
1698  if (phenotype.empty() && (*pnt_iter)->CanGetTerm()) {
1699  phenotype = (*pnt_iter)->GetTerm();
1700  }
1701  }
1702  }
1703 
1704  string sample_sex = "";
1705  if (var.CanGetSomatic_origin()) {
1706  ITERATE (CVariation_ref::TSomatic_origin, so_iter, var.GetSomatic_origin()) {
1707  if ((*so_iter)->CanGetSource() &&
1708  (*so_iter)->GetSource().GetSubtype() == CSubSource::eSubtype_sex) {
1709  sample_sex = (*so_iter)->GetSource().GetName();
1710  break;
1711  }
1712  }
1713  }
1714 
1715  bool is_sv = (var.IsSetId() && var.GetId().GetTag().IsStr() &&
1716  var.GetId().GetTag().GetStr().find("sv") == 1);
1717 
1718  // allele type
1719  string variant_type;
1720  if (s_IsLOH(var)) {
1721  variant_type = "LOH";
1722  } else if (var.IsComplex()) {
1723  variant_type = "Complex";
1724  } else if (var.IsUniparentalDisomy()) {
1725  variant_type = "UPD";
1726  } else if (var.IsInsertion()) {
1727  variant_type = "Insertion";
1728  } else if (var.IsGain()) {
1729  if (var.CanGetMethod() && s_IsCopyNumberMethod(var.GetMethod())) {
1730  variant_type = "Copy number gain";
1731  } else {
1732  variant_type = "Duplication";
1733  }
1734  } else if (var.IsLoss()) {
1735  if (var.CanGetMethod() && s_IsCopyNumberMethod(var.GetMethod())) {
1736  variant_type = "Copy number loss";
1737  } else {
1738  variant_type = "Deletion";
1739  }
1740  } else if (var.IsDeletion()) {
1741  if (var.CanGetMethod() && s_IsCopyNumberMethod(var.GetMethod())) {
1742  variant_type = "Copy number loss";
1743  } else {
1744  variant_type = "Deletion";
1745  }
1746  } else if (var.IsInversion()) {
1747  variant_type = "Inversion";
1748  } else if (var.IsEversion()) {
1749  variant_type = "Tandem duplication";
1750  } else if (var.IsTranslocation()) {
1751  variant_type = "Translocation";
1752  } else if (var.IsDeletionInsertion()) {
1753  variant_type = "Indel";
1754  } else if (var.IsUnknown()) {
1755  variant_type = "Unknown";
1756  } else if (var.IsCNV()) {
1757  variant_type = "Copy number variation";
1758  } else {
1759  variant_type = "Other";
1760  }
1761 
1762  if (is_sv) {
1763  int child_num = s_GetChildNum(*feat);
1764  if (child_num == 0) {
1765  // sv, but treated as ssv
1766  is_sv = false;
1767  } else {
1768  if (child_num > 0) {
1769  *label += "Number of Supporting Variant Calls: ";
1770  *label += NStr::IntToString(child_num);
1771  *label += "\n";
1772  }
1773  *label += "Variant Region Type: ";
1774  *label += variant_type;
1775  if ( !phenotype.empty() ) {
1776  *label += "\nPhenotype: " + phenotype;
1777  }
1778  if ( !clinical_sig.empty() ) {
1779  *label += "\nClinical Interpretation: ";
1780  *label += clinical_sig;
1781  }
1782  if ( !sample_sex.empty() ) {
1783  *label += "\nGender: ";
1784  *label += sample_sex;
1785  }
1786  *label += "\nValidation Status: " + validation;
1787  *label += "\nTotal Length: ";
1788  *label += NStr::IntToString(
1789  feat->GetLocation().GetTotalRange().GetLength(),
1790  NStr::fWithCommas);
1791  }
1792  }
1793 
1794  if ( !is_sv ) {
1795  if (var.CanGetParent_id()) {
1796  *label += "Parent Variant Region: ";
1797  if (var.GetParent_id().GetTag().IsId()) {
1798  *label += NStr::IntToString(var.GetParent_id().GetTag().GetId());
1799  } else {
1800  *label += var.GetParent_id().GetTag().GetStr();
1801  }
1802  *label += "\n";
1803  }
1804 
1805 
1806  *label += "Variant Call Type: ";
1807  *label += variant_type;
1808 
1809  if ( !phenotype.empty() ) {
1810  *label += "\nPhenotype: " + phenotype;
1811  }
1812  if ( !clinical_sig.empty() ) {
1813  *label += "\nClinical Interpretation: ";
1814  *label += clinical_sig;
1815  }
1816  if ( !sample_sex.empty() ) {
1817  *label += "\nGender: ";
1818  *label += sample_sex;
1819  }
1820 
1821  // inheritance
1822  CVariation_ref::TAllele_origin org = -1;
1823  if (var.IsSetAllele_origin()) {
1824  org = var.GetAllele_origin();
1825  } else if (var.IsSetVariant_prop() && var.GetVariant_prop().IsSetAllele_origin()) {
1826  org = var.GetVariant_prop().GetAllele_origin();
1827  }
1828 
1829  if (org > 0) {
1830  string inh;
1831  if (org & CVariation_ref::eAllele_origin_somatic) {
1832  inh += "somatic ";
1833  }
1834  if (org & CVariation_ref::eAllele_origin_inherited) {
1835  inh += "inherited ";
1836  }
1837  if (org & CVariation_ref::eAllele_origin_paternal) {
1838  inh += "paternal ";
1839  }
1840  if (org & CVariation_ref::eAllele_origin_maternal) {
1841  inh += "maternal ";
1842  }
1843  if (org & CVariation_ref::eAllele_origin_de_novo) {
1844  inh += "de_novo ";
1845  }
1846  if (org & CVariation_ref::eAllele_origin_biparental) {
1847  inh += "biparental ";
1848  }
1849  if (org & CVariation_ref::eAllele_origin_uniparental) {
1850  inh += "uniparental ";
1851  }
1852  if (org & CVariation_ref::eAllele_origin_not_tested) {
1853  inh += "not-tested ";
1854  }
1855  if (org & CVariation_ref::eAllele_origin_tested_inconclusive) {
1856  inh += "tested-inconclusive ";
1857  }
1858  if (org & CVariation_ref::eAllele_origin_other) {
1859  inh += "other";
1860  }
1861 
1862  if (org == CVariation_ref::eAllele_origin_unknown) {
1863  inh = "unknown";
1864  }
1865 
1866  *label += "\nInheritance: " + inh;
1867  }
1868 
1869  // validation status
1870  *label += "\nValidation Status: " + validation;
1871 
1872  if (feat->CanGetComment()) {
1873  *label += "\n" + feat->GetComment();
1874  }
1875  }
1876 
1877  int allele_len = -1;
1878  if (var.GetData().IsInstance() && var.GetData().GetInstance().IsSetDelta()) {
1879  const CVariation_inst::TDelta& delta = var.GetData().GetInstance().GetDelta();
1880  ITERATE (CVariation_inst::TDelta, iter, delta) {
1881  if ((*iter)->IsSetSeq() && (*iter)->GetSeq().IsLiteral()) {
1882  allele_len = (*iter)->GetSeq().GetLiteral().GetLength();
1883  break;
1884  }
1885  }
1886  }
1887  if (allele_len > -1) {
1888  *label += "\nAllele length: " + NStr::NumericToString(allele_len, NStr::fWithCommas);
1889  }
1890 
1891  }}
1892  break;
1893 
1894  case CSeqFeatData::eSubtype_clone:
1895  {{
1896  const CSeqFeatData::TClone& clone = feat->GetData().GetClone();
1897  *label += "Length: ";
1898  *label += NStr::IntToString(feat->GetLocation().GetTotalRange().GetLength(),
1899  NStr::fWithCommas);
1900  *label += "\nStart: ";
1901  *label += NStr::IntToString(feat->GetLocation().GetStart(
1902  eExtreme_Positional) + 1, NStr::fWithCommas);
1903  *label += ", Stop: ";
1904  *label += NStr::IntToString(feat->GetLocation().GetStop(
1905  eExtreme_Positional) + 1, NStr::fWithCommas);
1906  if (clone.IsSetPlacement_method()) {
1907  const CEnumeratedTypeValues* type_val =
1908  CClone_ref::GetTypeInfo_enum_EPlacement_method();
1909  if (type_val) {
1910  string method = type_val->FindName(clone.GetPlacement_method(), true);
1911  if ( !method.empty() ) {
1912  *label += "\nPlacement method: " + method;
1913  }
1914  }
1915  }
1916  if (clone.IsSetConcordant()) {
1917  *label += "\nClone placement: ";
1918  *label += clone.GetConcordant() ? "concordant" : "discordant";
1919  }
1920  if (clone.IsSetUnique()) {
1921  *label += "\nClone placement: ";
1922  *label += clone.GetUnique() ? "unique" : "multiple";
1923  }
1924  if (clone.IsSetClone_seq()) {
1925  typedef map<int, vector<string> > TEndMap;
1926  TEndMap end_map;
1927  const CClone_ref::TClone_seq::Tdata& ends = clone.GetClone_seq().Get();
1928  ITERATE (CClone_ref::TClone_seq::Tdata, e_iter, ends) {
1929  const CClone_seq& seq = **e_iter;
1930  if (seq.CanGetSeq() && seq.CanGetSupport()) {
1931  const CSeq_id* id = seq.GetSeq().GetId();
1932  if( id ){
1933  CSeq_id_Handle idh;
1934  string id_str;
1935  if( scope ){
1936  idh = sequence::GetId( *id, *scope );
1937  if( idh ){
1938  CSeq_id_Handle idhb = sequence::GetId(idh, *scope, sequence::eGetId_Best);
1939  if( idhb ){
1940  idh = idhb;
1941  }
1942  }
1943  }
1944  if( idh ){
1945  CConstRef<CSeq_id> seq_id_ref = idh.GetSeqId();
1946  seq_id_ref->GetLabel( &id_str, CSeq_id::eContent );
1947  } else {
1948  id->GetLabel(&id_str);
1949  }
1950  end_map[seq.GetSupport()].push_back(id_str);
1951  }
1952  }
1953  }
1954 
1955  if (end_map.count(CClone_seq::eSupport_prototype) > 0) {
1956  *label += "\nPrototype: " + CStringUtil::ConcatenateStrings(end_map[CClone_seq::eSupport_prototype]);
1957  }
1958 
1959  if (end_map.count(CClone_seq::eSupport_supporting) > 0) {
1960  *label += "\nSupporting (" +
1961  NStr::NumericToString(end_map[CClone_seq::eSupport_supporting].size()) +
1962  "): ";
1963  *label += CStringUtil::FormatStringsOccurrences(end_map[CClone_seq::eSupport_supporting]);
1964  }
1965 
1966  if (end_map.count(CClone_seq::eSupport_non_supporting) > 0) {
1967  *label += "\nNon-supporting (" +
1968  NStr::NumericToString(end_map[CClone_seq::eSupport_non_supporting].size()) +
1969  "): ";
1970  *label += CStringUtil::FormatStringsOccurrences(end_map[CClone_seq::eSupport_non_supporting]);
1971  }
1972 
1973  if (end_map.count(CClone_seq::eSupport_supports_other) > 0) {
1974  *label += "\nSupports other (" +
1975  NStr::NumericToString(end_map[CClone_seq::eSupport_supports_other].size()) +
1976  "): ";
1977  *label += CStringUtil::FormatStringsOccurrences(end_map[CClone_seq::eSupport_supports_other]);
1978  }
1979  }
1980  }}
1981  break;
1982 
1983  case CSeqFeatData::eSubtype_variation:
1984  GetLabel(obj, label, CLabel::eUserTypeAndContent, scope);
1985  break;
1986 
1987  case CSeqFeatData::eSubtype_imp:
1988  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
1989  *label += " ";
1990  if (feat->GetData().GetImp().IsSetDescr()) {
1991  *label += feat->GetData().GetImp().GetDescr();
1992  }
1993  break;
1994 
1995  case CSeqFeatData::eSubtype_exon:
1996  case CSeqFeatData::eSubtype_intron:
1997  GetLabel(obj, label, CLabel::eContent, scope);
1998  break;
1999 
2000  case CSeqFeatData::eSubtype_region:
2001  {{
2002  feature::GetLabel(*feat, label, feature::fFGL_Type, scope);
2003  *label += " ";
2004  *label += CGUIUserType::sm_Tp_Feature + " : ";
2005  GetLabel(obj, label, CLabel::eUserTypeAndContent, scope);
2006  if (feat->IsSetQual()) {
2007  ITERATE(CSeq_feat::TQual, it, feat->GetQual()) {
2008  *label += "\n" + (*it)->GetQual() + ": " + (*it)->GetVal();
2009  }
2010  }
2011  }}
2012  break;
2013 
2014  case CSeqFeatData::eSubtype_seq:
2015  {{
2016  *label += "Refers to: ";
2017  if (feat->CanGetTitle()) {
2018  *label += feat->GetTitle();
2019  } else {
2020  s_GetSeq_TotalRangeLabel(feat->GetData().GetSeq(), label, scope, type);
2021  }
2022  if (feat->IsSetQual()) {
2023  ITERATE(CSeq_feat::TQual, it, feat->GetQual()) {
2024  *label += "\n" + (*it)->GetQual() + ": " + (*it)->GetVal();
2025  }
2026  }
2027  }}
2028  break;
2029 
2030  case CSeqFeatData::eSubtype_site:
2031  if (feat->GetData().GetSite() == CSeqFeatData::eSite_other &&
2032  feat->IsSetComment()) {
2033  *label += "[Site] ";
2034  *label += feat->GetComment();
2035  } else {
2036  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2037  }
2038  break;
2039 
2040  default:
2041  feature::GetLabel(*feat, label, feature::fFGL_Type, scope);
2042  *label += " ";
2043  *label += CGUIUserType::sm_Tp_Feature + " : ";
2044  GetLabel(obj, label, CLabel::eUserTypeAndContent, scope);
2045  break;
2046  }
2047  break;
2048 
2049  case CLabel::eUserTypeAndContent:
2050  default:
2051  if (x_UseCustomLabel(*feat)) {
2052  x_GetCustomLabel(*feat, *label);
2053  }
2054  /// for both, we use a modified construct of the base text
2055  else if (feat->IsSetProduct()) {
2056  try {
2057  string s;
2058  const CSeq_id& id = sequence::GetId(feat->GetProduct(), scope);
2059  s_GetSeqLabel(id, &s, scope, CLabel::eContent);
2060  if (!feat->GetData().IsRna()) {
2061  string product_str;
2062  string type_str;
2063  feature::GetLabel(*feat, &product_str, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2064  feature::GetLabel(*feat, &type_str, feature::fFGL_Type, scope);
2065  // Do not append the product if it contains type information only
2066  if (product_str != type_str) {
2067  s += ": ";
2068  s += product_str;
2069  }
2070 
2071  }
2072  *label += s;
2073  }
2074  catch (CException&) {
2075  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2076  }
2077  } else {
2078  switch (feat->GetData().GetSubtype()) {
2079  case CSeqFeatData::eSubtype_gene:
2080  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2081  break;
2082 
2083  case CSeqFeatData::eSubtype_imp:
2084  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2085  *label += " ";
2086  if (feat->GetData().GetImp().IsSetDescr()) {
2087  *label += feat->GetData().GetImp().GetDescr();
2088  }
2089  break;
2090 
2091  case CSeqFeatData::eSubtype_exon:
2092  case CSeqFeatData::eSubtype_intron:
2093  GetLabel(obj, label, CLabel::eContent, scope);
2094  break;
2095 
2096  case CSeqFeatData::eSubtype_region:
2097  feature::GetLabel(*feat, label,
2098  feature::fFGL_Type |
2099  feature::fFGL_Content |
2100  feature::fFGL_NoQualifiers, scope);
2101  if (feat->IsSetQual()) {
2102  ITERATE(CSeq_feat::TQual, it, feat->GetQual()) {
2103  *label += "\n" + (*it)->GetQual() + ": " + (*it)->GetVal();
2104  }
2105  }
2106  break;
2107 
2108  case CSeqFeatData::eSubtype_site:
2109  if (feat->GetData().GetSite() == CSeqFeatData::eSite_other &&
2110  feat->IsSetComment()) {
2111  *label += "[Site] ";
2112  *label += feat->GetComment();
2113  } else {
2114  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2115  }
2116 
2117  break;
2118 
2119  case CSeqFeatData::eSubtype_variation:
2120  {{
2121  CSnpBitfield bf_interp(*feat);
2122  if (bf_interp.isGood()) {
2123  string tag(bf_interp.GetVariationClassString());
2124  *label += tag;
2125  *label += " rs";
2126  *label += NStr::NumericToString(NSnp::GetRsid(*feat));
2127  } else {
2128  feature::GetLabel(*feat, label,
2129  feature::fFGL_Type |
2130  feature::fFGL_Content |
2131  feature::fFGL_NoQualifiers, scope);
2132  }
2133 
2134  if (feat->IsSetQual()) {
2135  ///
2136  /// alleles come next
2137  NSnp::TAlleles Alleles;
2138  NSnp::GetAlleles(*feat, Alleles);
2139  if(!Alleles.empty()) {
2140  if ( !label->empty() ) {
2141  *label += "; ";
2142  }
2143  *label += "Alleles: ";
2144  *label += NStr::Join(Alleles, "/");
2145  /// Add length of allele for insertion/deletion types
2146  ///
2147  if (bf_interp.isGood() && (bf_interp.IsTrue(CSnpBitfield::eDips) || bf_interp.IsTrue(CSnpBitfield::eDeletion))) {
2148  int length = NSnp::GetLength(*feat);
2149  *label += "; deletion length=";
2150  *label += NStr::IntToString(length);
2151 
2152  }
2153  }
2154  }
2155  }}
2156  break;
2157 
2158  case CSeqFeatData::eSubtype_variation_ref:
2159  {{
2160  const CVariation_ref& var = feat->GetData().GetVariation();
2161  if (var.CanGetId()) {
2162  *label += "[" + var.GetId().GetDb() + "] ";
2163  if (var.GetId().GetTag().IsId()) {
2164  *label += NStr::IntToString(var.GetId().GetTag().GetId());
2165  } else {
2166  *label += var.GetId().GetTag().GetStr();
2167  }
2168  }
2169  ITERATE (CSeq_feat::TQual, iter, feat->GetQual()) {
2170  const CGb_qual& qual = **iter;
2171  *label += " " + qual.GetQual();
2172  if ( !qual.GetVal().empty() ) {
2173  *label += "=" + qual.GetVal();
2174  }
2175  }
2176  }}
2177  break;
2178 
2179  case CSeqFeatData::eSubtype_clone:
2180  {{
2181  const CSeqFeatData::TClone& clone = feat->GetData().GetClone();
2182  if (clone.IsSetName()) {
2183  *label += clone.GetName();
2184  } else {
2185  feature::GetLabel(*feat, label, feature::fFGL_Content | feature::fFGL_NoQualifiers, scope);
2186  }
2187  }}
2188  break;
2189 
2190  case CSeqFeatData::eSubtype_seq:
2191  {{
2192  if (feat->CanGetTitle()) {
2193  *label += feat->GetTitle();
2194  } else {
2195  s_GetSeq_TotalRangeLabel(feat->GetData().GetSeq(), label, scope, type);
2196  }
2197  }}
2198  break;
2199 
2200  default:
2201  feature::GetLabel(*feat, label,
2202  feature::fFGL_Type |
2203  feature::fFGL_Content |
2204  feature::fFGL_NoQualifiers, scope);
2205  break;
2206  }
2207  }
2208  break;
2209  }
2210  }
2211 protected:
2212  bool x_UseCustomLabel(const objects::CSeq_feat &feat) const;
2213  void x_GetCustomLabel(const objects::CSeq_feat &feat, string& label) const;
2214  void x_LabelFromQualifiers(const objects::CSeq_feat &feat, string& label) const;
2215  bool x_IncludeFeatureTypeInLabel(const objects::CSeq_feat &feat) const;
2216 private:
2217  CUserFeatHandler m_UserHandler;
2218 };
2219 
2220 
2221 bool CSeq_featHandler::x_UseCustomLabel(const CSeq_feat &feat) const
2222 {
2223  static set<CSeqFeatData::ESubtype> subtypes{ CSeqFeatData::eSubtype_misc_feature, CSeqFeatData::eSubtype_misc_recomb, CSeqFeatData::eSubtype_misc_structure, CSeqFeatData::eSubtype_mobile_element,
2224  CSeqFeatData::eSubtype_oriT, CSeqFeatData::eSubtype_protein_bind, CSeqFeatData::eSubtype_region, CSeqFeatData::eSubtype_regulatory, CSeqFeatData::eSubtype_rep_origin,
2225  CSeqFeatData::eSubtype_repeat_region, CSeqFeatData::eSubtype_stem_loop };
2226 
2227  return subtypes.end() != subtypes.find(feat.GetData().GetSubtype());
2228 }
2229 
2230 void CSeq_featHandler::x_GetCustomLabel(const CSeq_feat &feat, string& label) const
2231 {
2232  CSeqFeatData::ESubtype subtype = feat.GetData().GetSubtype();
2233  if (x_IncludeFeatureTypeInLabel(feat) && ((subtype != CSeqFeatData::eSubtype_misc_feature) && (subtype != CSeqFeatData::eSubtype_region))) // Add the subtype only for features that do not have specific qualifiers
2234  label = CSeqFeatData::SubtypeValueToName(subtype);
2235  string second_part;
2236  if (feat.GetData().IsRegion()) {
2237  second_part = feat.GetData().GetRegion();
2238  }
2239  else {
2240  x_LabelFromQualifiers(feat, second_part);
2241  }
2242  if (second_part.empty() && feat.IsSetComment()) {
2243  second_part = feat.GetComment();
2244  size_t pos = second_part.find(';');
2245  if (pos != string::npos)
2246  second_part = second_part.substr(0, pos);
2247  }
2248  if (!second_part.empty()) {
2249  if (!label.empty())
2250  label += ": ";
2251  label += second_part;
2252  }
2253  if (label.empty())
2254  label = CSeqFeatData::SubtypeValueToName(subtype);
2255 }
2256 
2257 void CSeq_featHandler::x_LabelFromQualifiers(const CSeq_feat &feat, string& label) const
2258 {
2259  static vector<string> quals{ "regulatory_class", "recombination_class", "feat_class", "bound_moiety", "mobile_element_type", "mobile_element", "rpt_type",
2260  "satellite", "rpt_family", "mod_base", "operon", "standard_name", "allele" };
2261 
2262  for (const auto &qual_name : quals) {
2263  const string &value = feat.GetNamedQual(qual_name);
2264  if (value.empty())
2265  continue;
2266 
2267  label = value;
2268  break;
2269  }
2270 }
2271 
2272 bool CSeq_featHandler::x_IncludeFeatureTypeInLabel(const objects::CSeq_feat &feat) const
2273 {
2274  static vector<string> class_quals{ "feat_class", "regulatory_class", "recombination_class", "mobile_element_type", "mobile_element", "rpt_type", "satellite", "rpt_family" };
2275  for (const auto &qual_name : class_quals) {
2276  const string &value = feat.GetNamedQual(qual_name);
2277  if (!value.empty())
2278  return false;
2279  }
2280  return true;
2281 }
2282 
2283 //
2284 //
2285 // seq-entry handler
2286 //
2287 //
2288 class CSeq_entryHandler : public ILabelHandler
2289 {
2290 public:
2291  void GetLabel(const CObject& obj, string* label,
2292  CLabel::ELabelType type, CScope* scope) const
2293  {
2294  const CSeq_entry* entry = dynamic_cast<const CSeq_entry*>(&obj);
2295  if (entry) {
2296  if (entry->IsSet()) {
2297  CLabel::GetLabel(entry->GetSet(), label, type, scope);
2298  } else {
2299  CLabel::GetLabel(entry->GetSeq(), label, type, scope);
2300  }
2301  }
2302  }
2303 };
2304 
2305 
2306 static void s_GetAlignmentType(const CSeq_align& align, string* label)
2307 {
2308  switch (align.GetSegs().Which()) {
2309  default:
2310  case CSeq_align::TSegs::e_not_set:
2311  *label += "[Unknown]";
2312  break;
2313  case CSeq_align::TSegs::e_Denseg:
2314  *label += "[Dense-seg]";
2315  break;
2316  case CSeq_align::TSegs::e_Dendiag:
2317  *label += "[Dense-diag]";
2318  break;
2319  case CSeq_align::TSegs::e_Std:
2320  *label += "[Standard-seg]";
2321  break;
2322  case CSeq_align::TSegs::e_Packed:
2323  *label += "[Packed-seg]";
2324  break;
2325  case CSeq_align::TSegs::e_Disc:
2326  *label += "[Discontinuous]";
2327  break;
2328  }
2329 }
2330 
2331 
2332 static void s_GetAlignmentContent(const CSeq_align& align, string* label,
2333  CScope* scope)
2334 {
2335  const CSeq_align::TSegs& asegs = align.GetSegs();
2336  CSeq_align::TSegs::E_Choice asegs_type = asegs.Which();
2337  switch (asegs_type) {
2338  default:
2339  case CSeq_align::TSegs::e_not_set:
2340  *label += "unknown contents";
2341  break;
2342  case CSeq_align::TSegs::e_Spliced:
2343  {{
2344  const CSeq_align::TSegs::TSpliced& spliced = asegs.GetSpliced();
2345  if (spliced.CanGetProduct_id()) {
2346  const CSeq_id& product_id = spliced.GetProduct_id();
2347  string str;
2348  s_GetSeqLabel(product_id, &str, scope, CLabel::eContent);
2349  *label += str;
2350  *label += " x ";
2351  }
2352  if (spliced.CanGetGenomic_id()) {
2353  const CSeq_id& genomic_id = spliced.GetGenomic_id();
2354  string str;
2355  s_GetSeqLabel(genomic_id, &str, scope, CLabel::eContent);
2356  *label += str;
2357  }
2358  }}
2359  break;
2360  case CSeq_align::TSegs::e_Denseg:
2361  {{
2362  string str;
2363  size_t seqs = align.GetSegs().GetDenseg().GetIds().size();
2364  if (seqs < 4) {
2365  set<CSeq_id_Handle> handle_set;
2366  ITERATE (CDense_seg::TIds, id_iter, align.GetSegs().GetDenseg().GetIds()) {
2367  CSeq_id_Handle sih = CSeq_id_Handle::GetHandle(**id_iter);
2368  if ( !handle_set.insert(sih).second ) {
2369  continue;
2370  }
2371 
2372  if ( !str.empty() ) {
2373  str += " x ";
2374  }
2375  s_GetSeqLabel(*sih.GetSeqId(), &str, scope, CLabel::eContent);
2376  }
2377 
2378  if( handle_set.size() == 1 ){
2379  str += " x " + str;
2380  }
2381 
2382  } else {
2383  str = NStr::SizetToString(seqs, NStr::fWithCommas) + " sequences.";
2384  }
2385 
2386  *label += str;
2387  }}
2388  break;
2389  case CSeq_align::TSegs::e_Dendiag:
2390  *label += "[Dense-diag]";
2391  break;
2392  case CSeq_align::TSegs::e_Std:
2393  *label += "[Standard-seg]";
2394  break;
2395  case CSeq_align::TSegs::e_Packed:
2396  *label += "[Packed-seg]";
2397  break;
2398  case CSeq_align::TSegs::e_Sparse:
2399  *label += "[Sparse-seg]";
2400  break;
2401  case CSeq_align::TSegs::e_Disc:
2402  {{
2403  string str;
2404  set<CSeq_id_Handle> handle_set;
2405  CTypeConstIterator<CSeq_id> id_iter(align.GetSegs());
2406  for ( ; id_iter; ++id_iter) {
2407  CSeq_id_Handle sih = CSeq_id_Handle::GetHandle(*id_iter);
2408  if ( !handle_set.insert(sih).second ) {
2409  continue;
2410  }
2411 
2412  if ( !str.empty() ) {
2413  str += " x ";
2414  }
2415  s_GetSeqLabel(*sih.GetSeqId(), &str, scope, CLabel::eContent);
2416  }
2417 
2418  *label += str;
2419  if (handle_set.size() == 1) { // paralogous alignment
2420  *label += " x ";
2421  *label += str;
2422  }
2423  }}
2424  break;
2425  }
2426 }
2427 
2428 static size_t s_CountSegments(const CSeq_align& align)
2429 {
2430  switch (align.GetSegs().Which()) {
2431  default:
2432  return 1;
2433 
2434  case CSeq_align::TSegs::e_Disc:
2435  return align.GetSegs().GetDisc().Get().size();
2436 
2437  case CSeq_align::TSegs::e_Spliced:
2438  return align.GetSegs().GetSpliced().GetExons().size();
2439  }
2440 }
2441 
2442 
2443 
2444 static void s_GetAlignmentTooltip(const CSeq_align& align, string* label,
2445  CScope* scope)
2446 {
2447  const CSeq_align::TDim num_rows_limit = 10;
2448 
2449  ///
2450  /// first, format our seq-ids
2451  ///
2452  vector<bool> strands;
2453  CSeq_align::TDim num_rows = align.CheckNumRows();
2454  {{
2455  string ids;
2456  CSeq_align::TDim i = 0;
2457  for(; i < num_rows; ++i ){
2458  CSeq_id_Handle idh = CSeq_id_Handle::GetHandle( align.GetSeq_id(i) );
2459  if( scope ){
2460  CSeq_id_Handle idh_best = sequence::GetId( idh, *scope, sequence::eGetId_Best);
2461  if( idh_best ){
2462  idh = idh_best;
2463  }
2464  }
2465 
2466  if ( !ids.empty() ) {
2467  ids += " x ";
2468  }
2469  CConstRef<CSeq_id> seq_id(idh.GetSeqIdOrNull());
2470  if (!seq_id) {
2471  ids = "UNK";
2472  }
2473  else {
2474  idh.GetSeqId()->GetLabel(&ids, CSeq_id::eContent);
2475  }
2476 
2477  TSeqRange range = align.GetSeqRange(i);
2478  ids += " (";
2479  ids += NStr::IntToString(range.GetFrom() + 1, NStr::fWithCommas);
2480  ids += "..";
2481  ids += NStr::IntToString(range.GetTo() + 1, NStr::fWithCommas);
2482  ids += ")";
2483 
2484  try {
2485  strands.push_back(align.GetSeqStrand(i) == eNa_strand_plus);
2486  } catch (CException&) {
2487  // ignore the exception
2488  }
2489  // break out of the loop to avoid long (slow) tooltips
2490  if (i > num_rows_limit)
2491  break;
2492  }
2493 
2494  *label += ids;
2495 
2496  if (i < num_rows) { // early escape?
2497  *label += " x ... [ total ";
2498  *label += NStr::IntToString(num_rows, NStr::fWithCommas);
2499  *label += "]";
2500  return;
2501  }
2502  }}
2503 
2504  /// only report strand for pair-wise alignments
2505  if (num_rows == 2 && strands.size() == 2) {
2506  *label += "\nStrand: ";
2507  *label += strands[0] == strands[1] ? "forward" : "reverse";
2508  }
2509 
2510  ///
2511  /// next, add a remark about the total aligned range
2512  ///
2513  CScoreBuilder builder;
2514  // new method
2515  TSeqPos align_length = builder.GetAlignLength(align);
2516  *label += "\nAligned bases: ";
2517  *label += NStr::IntToString(align_length, NStr::fWithCommas);
2518 
2519  size_t segs = s_CountSegments(align);
2520  *label += "\nAligned segments: ";
2521  *label += NStr::SizetToString(segs, NStr::fWithCommas);
2522 
2523  char buf[255];
2524  double coverage = 0.0;
2525  *label += "\nCoverage: ";
2526  if ( !align.GetNamedScore(CSeq_align::eScore_PercentCoverage, coverage) && scope ){
2527  coverage = builder.GetPercentCoverage( *scope, align );
2528  }
2529  if (coverage < 100.0 && coverage > 99.9) {
2530  *label += "99.9+";
2531  } else {
2532  sprintf(buf, "%2.1f", coverage);
2533  *label += buf;
2534  }
2535  *label += "%";
2536 
2537  if (align_length < 1000000) {
2538  //int identities = builder.GetIdentityCount(*scope, align);
2539  //int mismatches = builder.GetMismatchCount(*scope, align);
2540  int identities = 0;
2541  int mismatches = 0;
2542  if (
2543  !( align.GetNamedScore(CSeq_align::eScore_IdentityCount, identities)
2544  && align.GetNamedScore(CSeq_align::eScore_MismatchCount, mismatches)
2545  )
2546  && scope
2547  ){
2548  builder.GetMismatchCount(*scope, align, identities, mismatches);
2549  }
2550 
2551  double identity = 0.0;
2552  *label += "\nIdentity: ";
2553  if ( !align.GetNamedScore(CSeq_align::eScore_PercentIdentity, identity) ) {
2554  identity = identities * 100.0 / align_length;
2555  }
2556  if (identity < 100.0 && identity > 99.9) {
2557  *label += "99.9+";
2558  } else {
2559  sprintf(buf, "%2.1f", identity);
2560  *label += buf;
2561  }
2562  *label += "%";
2563 
2564 
2565  *label += "\nMismatches: ";
2566  *label += NStr::IntToString(mismatches, NStr::fWithCommas);
2567  }
2568  int gap_count = builder.GetGapCount(align);
2569  *label += "\nGaps: ";
2570  *label += NStr::IntToString(gap_count, NStr::fWithCommas);
2571 
2572 #if 0
2573  switch (align.GetSegs().Which()) {
2574  default:
2575  case CSeq_align::TSegs::e_not_set:
2576  case CSeq_align::TSegs::e_Dendiag:
2577  case CSeq_align::TSegs::e_Std:
2578  case CSeq_align::TSegs::e_Packed:
2579  s_GetAlignmentContent(align, label, scope);
2580  break;
2581 
2582  case CSeq_align::TSegs::e_Disc:
2583  {{
2584  string s;
2585  size_t count = 0;
2586  ITERATE (CSeq_align::TSegs::TDisc::Tdata, iter, align.GetSegs().GetDisc().Get()) {
2587  if ( !s.empty() ) {
2588  s += '\n';
2589  }
2590  s += NStr::IntToString(++count) + ") ";
2591  s_GetAlignmentTooltip(**iter, &s, scope);
2592  }
2593  *label += s;
2594  }}
2595  break;
2596 
2597  case CSeq_align::TSegs::e_Denseg:
2598  {{
2599  size_t seqs = align.GetSegs().GetDenseg().GetIds().size();
2600  if (seqs != 2) {
2601  s_GetAlignmentContent(align, label, scope);
2602  break;
2603  }
2604 
2605  //
2606  // pairwise alignment
2607  //
2608  const CSeq_id& id1 = *align.GetSegs().GetDenseg().GetIds().front();
2609  const CSeq_id& id2 = *align.GetSegs().GetDenseg().GetIds().back();
2610 
2611  string str;
2612  int mate_ti = 0;
2613  if (align.GetNamedScore("matepair ti", mate_ti) ||
2614  align.GetNamedScore("bad matepair ti", mate_ti)) {
2615  //
2616  // "good" mate pair
2617  //
2618  const CSeq_id* id_trace = &id1;
2619  if (id2.IsGeneral() &&
2620  (id2.GetGeneral().GetDb() == "ti" ||
2621  id2.GetGeneral().GetDb() == "TRACE")) {
2622  id_trace = &id2;
2623  }
2624 
2625  str = "Trace: ";
2626  s_GetSeqLabel(*id_trace, &str, scope, CLabel::eContent);
2627  str += "\nMate: ti|";
2628  str += NStr::SizetToString((unsigned int)mate_ti);
2629 
2630  int code = 0;
2631  if (align.GetNamedScore("bad matepair code", code)) {
2632  switch (code) {
2633  case 1:
2634  str += "\nError: Mate has wrong orientation";
2635  break;
2636  case 2:
2637  str += "\nError: Trace has non-unique placement";
2638  break;
2639  case 3:
2640  str += "\nError: Mate lies outside expected distance from trace";
2641  break;
2642  default:
2643  str += "\nError Code: ";
2644  str += NStr::IntToString(code);
2645  break;
2646  }
2647  }
2648  } else {
2649  size_t count = 0;
2650  ITERATE (CDense_seg::TIds, iter, align.GetSegs().GetDenseg().GetIds()) {
2651  if ( !str.empty() ) {
2652  str += " x ";
2653  }
2654  s_GetSeqLabel(**iter, &str, scope, CLabel::eContent);
2655 
2656  TSeqRange range = align.GetSegs().GetDenseg().GetSeqRange(count++);
2657  str += " [";
2658  str += NStr::IntToString(range.GetFrom() + 1, NStr::fWithCommas);
2659  str += "-";
2660  str += NStr::IntToString(range.GetTo() + 1, NStr::fWithCommas);
2661  str += "]";
2662  }
2663 
2664  /// compose scores if they exist
2665  string score_str;
2666  if (align.IsSetScore()) {
2667  ITERATE (CSeq_align::TScore, iter, align.GetScore()) {
2668  score_str += ' ';
2669  const CScore& score = **iter;
2670  if (score.IsSetId()) {
2671  if (score.GetId().IsId()) {
2672  score_str += NStr::IntToString(score.GetId().GetId());
2673  } else {
2674  score_str += score.GetId().GetStr();
2675  }
2676  score_str += '=';
2677  }
2678  if (score.GetValue().IsReal()) {
2679  score_str += NStr::DoubleToString(score.GetValue().GetReal());
2680  } else {
2681  score_str += NStr::DoubleToString(score.GetValue().GetInt());
2682  }
2683  }
2684  } else {
2685  score_str = " (no scores)";
2686  }
2687  str += score_str;
2688  }
2689 
2690  *label += str;
2691  }}
2692  break;
2693  }
2694 #endif
2695 }
2696 
2697 
2698 class CSeq_alignHandler : public ILabelHandler
2699 {
2700 public:
2701  void GetLabel(const CObject& obj, string* label,
2702  CLabel::ELabelType type, CScope* scope) const
2703  {
2704  // check: scope is NEEDED [indirectly protected]
2705 
2706  const CSeq_align* align = dynamic_cast<const CSeq_align*> (&obj);
2707  if( !align ) return;
2708 
2709  switch (type) {
2710  case CLabel::eUserType:
2711  *label += CGUIUserType::sm_Tp_Alignment;
2712  break;
2713 
2714  case CLabel::eUserSubtype:
2715  *label += "";
2716  break;
2717 
2718  case CLabel::eType:
2719  s_GetAlignmentType(*align, label);
2720  return;
2721 
2722  default:
2723  case CLabel::eContent:
2724  case CLabel::eDescriptionBrief:
2725  s_GetAlignmentContent(*align, label, scope);
2726  return;
2727 
2728  case CLabel::eUserTypeAndContent:
2729  s_GetAlignmentType(*align, label);
2730  *label += ' ';
2731  s_GetAlignmentContent(*align, label, scope);
2732  break;
2733 
2734  case CLabel::eDescription:
2735  s_GetAlignmentTooltip(*align, label, scope);
2736  break;
2737  }
2738  }
2739 };
2740 
2741 
2742 class CSeq_align_setHandler : public ILabelHandler
2743 {
2744 public:
2745  void GetLabel(const CObject& obj, string* label,
2746  CLabel::ELabelType type, CScope* /*scope*/) const
2747  {
2748  const CSeq_align_set* align = dynamic_cast<const CSeq_align_set*> (&obj);
2749  if ( !align ) {
2750  return;
2751  }
2752 
2753  switch (type) {
2754  case CLabel::eUserType:
2755  *label += CGUIUserType::sm_Tp_Alignment_Set;
2756  break;
2757 
2758  case CLabel::eUserSubtype:
2759  *label += "";
2760  break;
2761 
2762  case CLabel::eType:
2763  *label += "Seq-align-set";
2764  return;
2765 
2766  default:
2767  case CLabel::eContent:
2768  case CLabel::eDescriptionBrief:
2769  *label += "Seq-align-set"; //TODO
2770  return;
2771 
2772  case CLabel::eUserTypeAndContent:
2773  *label += "Seq-align-set"; //TODO
2774  break;
2775 
2776  case CLabel::eDescription:
2777  *label += "Seq-align-set"; //TODO
2778  break;
2779  }
2780  }
2781 };
2782 
2783 //
2784 // seq-annots are complicated
2785 //
2786 
2787 static void s_GetAnnotType(const CSeq_annot& annot, string* label)
2788 {
2789  const CSeq_annot::TData& annot_data = annot.GetData();
2790  switch (annot_data.Which()) {
2791  case CSeq_annot::TData::e_Ftable:
2792  *label += "Feature Table";
2793  break;
2794 
2795  case CSeq_annot::TData::e_Align:
2796  *label += "Alignment";
2797  break;
2798 
2799  case CSeq_annot::TData::e_Graph:
2800  *label += "Graph";
2801  break;
2802 
2803  case CSeq_annot::TData::e_Ids:
2804  *label += "IDs";
2805  break;
2806  case CSeq_annot::TData::e_Locs:
2807  *label += "Locations";
2808  break;
2809 
2810  default:
2811  *label = "Annotation";
2812  return;
2813  }
2814 }
2815 
2816 
2817 static void s_GetAnnotContent(const CSeq_annot& annot, string* label, CScope* scope)
2818 {
2819  // check: scope is NEEDED [protected]
2820 
2821  //
2822  // check for formatted comments in descriptors first
2823  //
2824  if (annot.IsSetDesc()) {
2825  const string* title = NULL;
2826  const string* name = NULL;
2827  ITERATE (CSeq_annot::TDesc::Tdata, iter, annot.GetDesc().Get()) {
2828  switch ((*iter)->Which()) {
2829  case CAnnotdesc::e_Title:
2830  title = &(*iter)->GetTitle();
2831  break;
2832 
2833  case CAnnotdesc::e_Name:
2834  name = &(*iter)->GetName();
2835  break;
2836 
2837  default:
2838  break;
2839  }
2840  }
2841 
2842  if (title) {
2843  *label = *title;
2844  return;
2845  } else if (name) {
2846  *label = *name;
2847  return;
2848  }
2849  }
2850 
2851  //
2852  // default handling
2853  //
2854  string str, extra;
2855  size_t items = 0;
2856  const CSeq_annot::TData& annot_data = annot.GetData();
2857 
2858  switch (annot_data.Which()) {
2859  case CSeq_annot::TData::e_Ftable:
2860  str = "Feature Table, ";
2861  items = annot_data.GetFtable().size();
2862  if( items > 0 ){
2863  const CSeq_id* sid = annot_data.GetFtable().front()->GetLocation().GetId();
2864  if( sid ){
2865  CSeq_id_Handle idh;
2866  if( scope ){
2867  idh = sequence::GetId(*sid, *scope, sequence::eGetId_Canonical);
2868  }
2869  if( idh ){
2870  CSeq_id_Handle idh_best =
2871  sequence::GetId(*sid, *scope, sequence::eGetId_Best)
2872  ;
2873  if( idh_best ){
2874  idh = idh_best;
2875  }
2876  }
2877 
2878  if( idh ){
2879  CConstRef<CSeq_id> seq_id_ref = idh.GetSeqId();
2880  extra = "on " + seq_id_ref->GetSeqIdString( true );
2881  } else {
2882  extra = "on " + sid->GetSeqIdString( true );
2883  }
2884  }
2885  }
2886 
2887  break;
2888 
2889  case CSeq_annot::TData::e_Align:
2890  {{
2891  ITERATE (CSeq_annot::TData::TAlign, iter, annot_data.GetAlign()) {
2892  const CSeq_align& align = **iter;
2893  string s;
2894  s_GetAlignmentContent(align, &s, scope);
2895  if (str.empty()) {
2896  str = s;
2897  } else if (str != s) {
2898  str.erase();
2899  break;
2900  }
2901  }
2902  if (str.empty()) {
2903  str = "Mixed sequence alignments";
2904  }
2905  }}
2906  if (str.empty()) {
2907  str = "Alignment, ";
2908  } else {
2909  str += ", ";
2910  }
2911  items = annot_data.GetAlign().size();
2912  break;
2913 
2914  case CSeq_annot::TData::e_Graph:
2915  str = "Graph, ";
2916  items = annot_data.GetGraph().size();
2917  break;
2918 
2919  case CSeq_annot::TData::e_Ids:
2920  str = "IDs, ";
2921  items = annot_data.GetIds().size();
2922  break;
2923  case CSeq_annot::TData::e_Locs:
2924  str = "Locations, ";
2925  items = annot_data.GetLocs().size();
2926  break;
2927 
2928  default:
2929  *label = "Annotation";
2930  return;
2931  }
2932 
2933  str += NStr::SizetToString( items );
2934  if( items != 1 ){
2935  str += " entries";
2936  } else {
2937  str += " entry";
2938  }
2939 
2940  if( !extra.empty() ){
2941  str += " (" + extra + ")";
2942  }
2943 
2944  *label += str;
2945 
2946 }
2947 
2948 
2949 class CSeq_annotHandler : public ILabelHandler
2950 {
2951 public:
2952  void GetLabel(const CObject& obj, string* label,
2953  CLabel::ELabelType type, CScope* scope) const
2954  {
2955  // check: scope is NEEDED [indirectly protected]
2956 
2957  const CSeq_annot* annot = dynamic_cast<const CSeq_annot*> (&obj);
2958  if ( !annot ) {
2959  return;
2960  }
2961 
2962  switch (type) {
2963  case CLabel::eUserType:
2964  *label += CGUIUserType::sm_Tp_Annotation;
2965  break;
2966 
2967  case CLabel::eUserSubtype: {
2968  switch(annot->GetData().Which()) {
2969  case CSeq_annot::TData::e_Align:
2970  *label += CGUIUserType::sm_SbTp_Alignments;
2971  break;
2972 
2973  case CSeq_annot::TData::e_Ftable:
2974  *label += CGUIUserType::sm_SbTp_Features;
2975  break;
2976 
2977  case CSeq_annot::TData::e_Graph:
2978  *label += CGUIUserType::sm_SbTp_Graphs;
2979  break;
2980 
2981  case CSeq_annot::TData::e_Locs:
2982  *label += CGUIUserType::sm_SbTp_Locations;
2983  break;
2984 
2985  case CSeq_annot::TData::e_Ids:
2986  *label += CGUIUserType::sm_SbTp_Sequence_IDs;
2987  break;
2988 
2989  case CSeq_annot::TData::e_Seq_table:
2990  *label += CGUIUserType::sm_SbTp_Table;
2991  break;
2992 
2993  default:
2994  _ASSERT(false);
2995  break;
2996  }
2997  return;
2998  }
2999 
3000  case CLabel::eType:
3001  s_GetAnnotType(*annot, label);
3002  return;
3003 
3004  case CLabel::eContent:
3005  case CLabel::eDescriptionBrief:
3006  s_GetAnnotContent(*annot, label, scope);
3007  return;
3008 
3009  case CLabel::eUserTypeAndContent:
3010  case CLabel::eDescription:
3011  s_GetAnnotType(*annot, label);
3012  *label += ": ";
3013  s_GetAnnotContent(*annot, label, scope);
3014  break;
3015 
3016  default:
3017  break;
3018  }
3019  }
3020 };
3021 
3022 //
3023 //
3024 // ValidError handler
3025 //
3026 //
3027 class CValidErrorHandler : public ILabelHandler
3028 {
3029 public:
3030  void GetLabel(const CObject& obj, string* label,
3031  CLabel::ELabelType type, CScope* /*scope*/) const
3032  {
3033  // check: no scope info is actually used
3034 
3035  const CValidError* valerr = dynamic_cast<const CValidError*>(&obj);
3036  if ( ! valerr) {
3037  return;
3038  }
3039 
3040  switch (type) {
3041  case CLabel::eUserType:
3042  *label += CGUIUserType::sm_Tp_ValidationResult;
3043  break;
3044 
3045  case CLabel::eUserSubtype:
3046  *label += CGUIUserType::sm_SbTp_Undefined;
3047  break;
3048 
3049  case CLabel::eType:
3050  *label += valerr->GetThisTypeInfo()->GetName();
3051  return;
3052 
3053  case CLabel::eContent:
3054  case CLabel::eUserTypeAndContent:
3055  case CLabel::eDescriptionBrief:
3056  {
3057  CValidError_CI valerr_it(*valerr);
3058  string acc;
3059  if (valerr->TotalSize() > 0) {
3060  if (valerr_it->CanGetAccession()) {
3061  acc = valerr_it->GetAccession();
3062  }
3063  }
3064  *label += "Validation results for " + acc
3065  + ": " + NStr::SizetToString(valerr->TotalSize());
3066  if (valerr->TotalSize() == 1) {
3067  *label += " error";
3068  } else {
3069  *label += " errors";
3070  }
3071  return;
3072  }
3073 
3074  case CLabel::eDescription:
3075 
3076  *label = "Validation errors total: " + NStr::SizetToString(valerr->TotalSize());
3077  if (valerr->InfoSize() > 0) {
3078  *label += " Info: " + NStr::SizetToString(valerr->InfoSize());
3079  }
3080  if (valerr->WarningSize() > 0) {
3081  *label += " Warning: " + NStr::SizetToString(valerr->WarningSize());
3082  }
3083  if (valerr->ErrorSize() > 0) {
3084  *label += " Error: " + NStr::SizetToString(valerr->ErrorSize());
3085  }
3086  if (valerr->CriticalSize() > 0) {
3087  *label += " Reject: " + NStr::SizetToString(valerr->CriticalSize());
3088  }
3089  if (valerr->FatalSize() > 0) {
3090  *label += " Fatal: " + NStr::SizetToString(valerr->FatalSize());
3091  }
3092  return;
3093 
3094  default:
3095  break;
3096  }
3097  }
3098 };
3099 
3100 //
3101 //
3102 // CTaxIdSelSet handler
3103 //
3104 //
3105 class CTaxIDSetLabelHandler : public ILabelHandler
3106 {
3107 public:
3108  void GetLabel(const CObject& obj, string* label,
3109  CLabel::ELabelType type, CScope* /*scope*/) const
3110  {
3111  // check: no scope info is actually used
3112 
3113  const CTaxIdSelSet* tax_ids = dynamic_cast<const CTaxIdSelSet*>(&obj);
3114  if ( ! tax_ids) {
3115  return;
3116  }
3117 
3118  switch (type) {
3119  case CLabel::eUserType:
3120  *label += CGUIUserType::sm_Tp_TaxId_Set;
3121  break;
3122 
3123  case CLabel::eUserSubtype:
3124  *label += CGUIUserType::sm_SbTp_Undefined;
3125  break;
3126 
3127  case CLabel::eType:
3128  *label += "Set of Tax IDs";
3129  return;
3130 
3131  case CLabel::eContent:
3132  case CLabel::eUserTypeAndContent:
3133  case CLabel::eDescriptionBrief:
3134  {
3135  CTaxIdSelSet::TTaxId count = tax_ids->GetSelectedTaxIds().count();
3136 
3137  *label += "Num TaxIDs: " + NStr::UIntToString((unsigned int)count);
3138  return;
3139  }
3140 
3141  case CLabel::eDescription:
3142  {
3143  *label += "Ids: ";
3144 
3145  int char_count = 0;
3146  CTaxIdSelSet::TBitVec::enumerator e = tax_ids->GetSelectedTaxIds().first();
3147 
3148  // could be any number of ids but they will be displayed on one line in a list,
3149  // so pick a max string length which char count can't exceed
3150  for (; e != tax_ids->GetSelectedTaxIds().end() && char_count < 60; ++e) {
3151  CTaxIdSelSet::TTaxId id = *e;
3152 
3153  if (char_count > 0)
3154  *label += ", ";
3155 
3156  string idstr = NStr::UIntToString((unsigned int)id);
3157  char_count += idstr.length();
3158 
3159  *label += idstr;
3160  }
3161 
3162  /// Could not fit all the selected ids on one line:
3163  if (e != tax_ids->GetSelectedTaxIds().end())
3164  *label += " ...";
3165 
3166  return;
3167  }
3168 
3169  default:
3170  break;
3171  }
3172  }
3173 };
3174 
3175 
3176 //
3177 //
3178 // CGBProject_ver2 handler
3179 // Moved from CGBProject_ver2
3180 //
3181 //
3182 class CGBProject_ver2LabelHandler : public ILabelHandler
3183 {
3184 public:
3185  void GetLabel(const CObject& obj, string* str,
3186  CLabel::ELabelType type,
3187  objects::CScope* scope) const
3188  {
3189  const CGBProject_ver2* proj = dynamic_cast<const CGBProject_ver2*>(&obj);
3190  if (proj) {
3191  switch (type) {
3192  case CLabel::eUserType:
3193  *str += CGUIUserType::sm_Tp_Project;
3194  break;
3195 
3196  case CLabel::eUserSubtype:
3197  *str += CGUIUserType::sm_SbTp_ProjectVer2;
3198  break;
3199 
3200  case CLabel::eType:
3201  *str += "Project (ver.2)";
3202  break;
3203 
3204  case CLabel::eContent:
3205  {{
3206  string title;
3207  if (proj->IsSetDescr() && proj->GetDescr().IsSetTitle()) {
3208  title = proj->GetDescr().GetTitle();
3209  }
3210 
3211  if ( !title.empty() ) {
3212  *str += title;
3213  } else if (proj->IsSetData()) {
3214  CTypeConstIterator<CProjectItem> iter(proj->GetData());
3215 
3216  string s;
3217  for ( ; iter; ++iter) {
3218  const CSerialObject* cso = iter->GetObject();
3219  if (cso) {
3220  if ( !s.empty() ) {
3221  s += ", ";
3222  }
3223  CLabel::GetLabel(*cso, &s, type, scope);
3224  }
3225  }
3226  *str += s;
3227  }
3228  }}
3229  break;
3230 
3231  case CLabel::eUserTypeAndContent:
3232  {{
3233  string type_str;
3234  GetLabel(obj, &type_str, CLabel::eType, scope);
3235  string content_str;
3236  GetLabel(obj, &content_str, CLabel::eType, scope);
3237  *str += type_str;
3238  if ( !type_str.empty() && !content_str.empty() ) {
3239  *str += ": ";
3240  }
3241  if ( !content_str.empty() ) {
3242  *str += content_str;
3243  }
3244  }}
3245  break;
3246 
3247  default:
3248  break;
3249  }
3250  }
3251  }
3252 };
3253 
3254 
3255 
3256 ////////////////////////////////////////////////////////////
3257 // label handlers for genome workbench project types
3258 // these will be regsitered at application initialization
3259 // Moved from CProjectItem
3260 class CProjectItemLabelHandler : public ILabelHandler
3261 {
3262 public:
3263  void GetLabel(const CObject& obj, string* str,
3264  CLabel::ELabelType type,
3265  objects::CScope* scope) const
3266  {
3267  if(str == NULL) {
3268  return;
3269  }
3270  const CProjectItem* item = dynamic_cast<const CProjectItem*>(&obj);
3271  LOG_POST(Error << MSerial_AsnText << *item);
3272  if (item) {
3273  switch(type) {
3274  case CLabel::eContent:
3275  *str = item->IsSetLabel() ? item->GetLabel() : "";
3276  break;
3277  case CLabel::eUserType:
3278  *str += CGUIUserType::sm_Tp_ProjectItem;
3279  break;
3280 
3281  case CLabel::eUserSubtype:
3282  break;
3283 
3284  case CLabel::eType:
3285  *str = "Project Item";
3286  break;
3287 
3288  case CLabel::eUserTypeAndContent:
3289  case CLabel::eDescriptionBrief:
3290  case CLabel::eDescription:
3291  *str += CGUIUserType::sm_Tp_ProjectItem;
3292  *str = " : " + item->GetLabel();
3293  break;
3294 
3295  default:
3296  break;
3297  }
3298  }
3299  /* the old way of getting the Label, now it shall be set explicitly
3300  const CObject* obj = item->GetObject();
3301  if (obj) {
3302  CLabel::GetLabel(*obj, str, type, scope);
3303  }*/
3304  }
3305 };
3306 
3307 
3308 /// *******************************************************************
3309 /// Moved from plugins/algo/init
3310 /// *******************************************************************
3311 
3312 ///
3313 /// CBioTreeContainer label handler
3314 ///
3315 class CBioTreeContainerHandler : public ILabelHandler
3316 {
3317 public:
3318  void GetLabel(const CObject& obj, string* label,
3319  CLabel::ELabelType type, objects::CScope* scope) const
3320  {
3321  // check: no scope info is actually used
3322 
3323  const CBioTreeContainer* tree =
3324  dynamic_cast<const CBioTreeContainer*>(&obj);
3325  if (tree) {
3326  switch (type) {
3327  case CLabel::eUserType:
3328  *label += tree->CanGetTreetype() ? tree->GetTreetype() : "Bio Tree";
3329  break;
3330 
3331  case CLabel::eUserSubtype:
3332  break;
3333 
3334  case CLabel::eType:
3335  *label += "Biological Tree";
3336  break;
3337 
3338  case CLabel::eContent:
3339  {{
3340  string str;
3341 
3342  if (tree->IsSetLabel()) {
3343  str.append("'");
3344  str += tree->GetLabel();
3345  str.append("'");
3346  str += " ";
3347  }
3348 
3349  str += NStr::SizetToString(tree->GetNodeCount());
3350  str += " nodes, ";
3351  str += NStr::SizetToString(tree->GetLeafCount());
3352  str += " leaves";
3353 
3354  if (tree->IsSetTreetype()) {
3355  *label += tree->GetTreetype();
3356  *label += " (" + str + ")";
3357  } else {
3358  *label += "Tree, " + str;
3359  }
3360  }}
3361  break;
3362 
3363  default:
3364  case CLabel::eUserTypeAndContent:
3365  GetLabel(obj, label, CLabel::eType, scope);
3366  *label += ": ";
3367  GetLabel(obj, label, CLabel::eContent, scope);
3368  break;
3369  }
3370  }
3371  }
3372 };
3373 
3374 
3375 ///
3376 /// CGCAsssemblyHandler label handler
3377 ///
3378 class CGCAsssemblyHandler : public ILabelHandler
3379 {
3380 public:
3381  void GetLabel(const CObject& obj, string* label,
3382  CLabel::ELabelType type, objects::CScope* scope) const
3383  {
3384  // check: no scope info is actually used
3385 
3386  const CGC_Assembly* assm = dynamic_cast<const CGC_Assembly*>(&obj);
3387  if (assm) {
3388  switch (type) {
3389  case CLabel::eUserType:
3390  case CLabel::eType:
3391  *label += "Assembly";
3392  break;
3393 
3394  case CLabel::eUserSubtype:
3395  break;
3396 
3397 
3398  case CLabel::eContent:
3399  *label += assm->GetName();
3400  break;
3401 
3402  case CLabel::eDescriptionBrief:
3403  case CLabel::eDescription:
3404  {{
3405  const CGC_AssemblyDesc& desc = assm->GetDesc();
3406  if (desc.IsSetLong_name()) {
3407  *label += desc.GetLong_name();
3408  } else if (desc.IsSetName()) {
3409  *label += desc.GetName();
3410  }
3411  }}
3412  break;
3413 
3414  default:
3415  case CLabel::eUserTypeAndContent:
3416  GetLabel(obj, label, CLabel::eType, scope);
3417  *label += ": ";
3418  GetLabel(obj, label, CLabel::eContent, scope);
3419  break;
3420  }
3421  }
3422  }
3423 };
3424 
3425 
3426 ///
3427 /// CDistanceMatrix label handler
3428 ///
3429 class CDistanceMatrixHandler : public ILabelHandler
3430 {
3431 public:
3432  void GetLabel(const CObject& obj, string* label,
3433  CLabel::ELabelType /*type*/, objects::CScope* /*scope*/) const
3434  {
3435  // check: no scope info is used
3436 
3437  const CDistanceMatrix * mat =
3438  dynamic_cast<const CDistanceMatrix*>(&obj);
3439 
3440  if (mat) {
3441  *label += "Distance Matrix";
3442  }
3443  }
3444 };
3445 
3446 
3447 ///
3448 /// CEntrezgene label handler
3449 ///
3450 class CEntrezgeneHandler : public ILabelHandler
3451 {
3452 public:
3453  void GetLabel(const CObject& obj, string* label,
3454  CLabel::ELabelType type, objects::CScope* scope) const
3455  {
3456  // check: no scope info is actually used
3457 
3458  const CEntrezgene* egene =
3459  dynamic_cast<const CEntrezgene*>(&obj);
3460  if (egene) {
3461  switch (type) {
3462  case CLabel::eUserType:
3463  *label += CGUIUserType::sm_Tp_EntrezGeneRecord;
3464  break;
3465 
3466  case CLabel::eUserSubtype:
3467  break;
3468 
3469  case CLabel::eType:
3470  *label += "Entrez Gene Record";
3471  break;
3472 
3473  case CLabel::eContent:
3474  egene->GetGene().GetLabel(label);
3475  *label += " [";
3476  egene->GetSource().GetOrg().GetLabel(label);
3477  *label += "]";
3478  break;
3479 
3480  case CLabel::eDescription:
3481  egene->GetGene().GetLabel(label);
3482  if (egene->GetGene().IsSetDesc()) {
3483  *label += " : " + egene->GetGene().GetDesc();
3484  }
3485  *label += " [";
3486  egene->GetSource().GetOrg().GetLabel(label);
3487  *label += "]";
3488  break;
3489 
3490  default:
3491  case CLabel::eUserTypeAndContent:
3492  GetLabel(obj, label, CLabel::eType, scope);
3493  *label += ": ";
3494  GetLabel(obj, label, CLabel::eContent, scope);
3495  break;
3496  }
3497  }
3498  }
3499 };
3500 
3501 
3502 ///
3503 /// CEntrezgene_Set label handler
3504 ///
3505 class CEntrezgene_SetHandler : public ILabelHandler
3506 {
3507 public:
3508  void GetLabel(const CObject& obj, string* label,
3509  CLabel::ELabelType type, objects::CScope* scope) const
3510  {
3511  // check: no scope info is actually used
3512 
3513  const CEntrezgene_Set* egene_set =
3514  dynamic_cast<const CEntrezgene_Set*>(&obj);
3515  if (egene_set) {
3516  switch (type) {
3517  case CLabel::eUserType:
3518  case CLabel::eType:
3519  *label += "Entrez Gene Set";
3520  break;
3521 
3522  case CLabel::eContent:
3523  {{
3524  string s;
3525  ITERATE (CEntrezgene_Set::Tdata, iter, egene_set->Get()) {
3526  if ( !s.empty() ) {
3527  s += "; ";
3528  }
3529  (*iter)->GetGene().GetLabel(&s);
3530  s += " (";
3531  (*iter)->GetSource().GetOrg().GetLabel(&s);
3532  s += ")";
3533  }
3534  *label += s;
3535  }}
3536  break;
3537 
3538  default:
3539  case CLabel::eUserTypeAndContent:
3540  GetLabel(obj, label, CLabel::eType, scope);
3541  *label += ": ";
3542  GetLabel(obj, label, CLabel::eContent, scope);
3543  break;
3544  }
3545  }
3546  }
3547 };
3548 
3549 ///
3550 /// CVariation label handler
3551 ///
3552 class CVariationHandler : public ILabelHandler
3553 {
3554 public:
3555  void GetLabel(const CObject& obj, string* label,
3556  CLabel::ELabelType type, objects::CScope* scope) const
3557  {
3558  const CVariation* pVariation(dynamic_cast<const CVariation*>(&obj));
3559  if(pVariation) {
3560  switch (type) {
3561  case CLabel::eUserType:
3562  *label += CGUIUserType::sm_Tp_Variation;
3563  break;
3564 
3565  case CLabel::eUserSubtype:
3566  break;
3567 
3568  case CLabel::eType:
3569  *label += "Variation";
3570  break;
3571 
3572  case CLabel::eContent:
3573  if(pVariation->CanGetId()) {
3574  pVariation->GetId().GetLabel(label);
3575  }
3576  if(pVariation->CanGetOther_ids() && !pVariation->GetOther_ids().empty()) {
3577  *label += "[";
3578  const CVariation::TOther_ids& OtherIds(pVariation->GetOther_ids());
3579  ITERATE(CVariation::TOther_ids, iOtherIds, OtherIds) {
3580  if(iOtherIds != OtherIds.begin())
3581  *label += ", ";
3582  (*iOtherIds)->GetLabel(label);
3583  *label += "]";
3584  }
3585  }
3586  break;
3587 
3588  case CLabel::eDescription:
3589  if(pVariation->CanGetDescription())
3590  *label += pVariation->GetDescription();
3591  break;
3592 
3593  default:
3594  GetLabel(obj, label, CLabel::eType, scope);
3595  *label += ": ";
3596  GetLabel(obj, label, CLabel::eContent, scope);
3597  break;
3598  }
3599  }
3600  }
3601 };
3602 
3603 
3604 
3605 
3606 //
3607 // force registration at load
3608 //
3609 
3610 struct SForceRegister
3611 {
3612  SForceRegister()
3613  {
3614  CLabel::RegisterLabelHandler(*CSeq_id::GetTypeInfo(), *new CSeq_idHandler());
3615  CLabel::RegisterLabelHandler(*CSeq_loc::GetTypeInfo(), *new CSeq_locHandler());
3616  CLabel::RegisterLabelHandler(*CBioseq::GetTypeInfo(), *new CBioseqHandler());
3617  CLabel::RegisterLabelHandler(*CBioseq_set::GetTypeInfo(), *new CBioseq_setHandler());
3618  CLabel::RegisterLabelHandler(*CSeq_feat::GetTypeInfo(), *new CSeq_featHandler());
3619  CLabel::RegisterLabelHandler(*CSeq_entry::GetTypeInfo(), *new CSeq_entryHandler());
3620  CLabel::RegisterLabelHandler(*CSeq_annot::GetTypeInfo(), *new CSeq_annotHandler());
3621  CLabel::RegisterLabelHandler(*CSeq_align::GetTypeInfo(), *new CSeq_alignHandler());
3622  CLabel::RegisterLabelHandler(*CSeq_align_set::GetTypeInfo(), *new CSeq_align_setHandler());
3623  CLabel::RegisterLabelHandler(*CValidError::GetTypeInfo(), *new CValidErrorHandler());
3624  CLabel::RegisterLabelHandler(CVcfVariant::GetTypeName(), *new CVcfVariantHandler());
3625  // TBD: Need support for GetTypeInfo to see taxid collection in selection inspector
3626  //CLabel::RegisterLabelHandler(*CTaxIdSelSet::GetTypeInfo(), *new CTaxIDSetLabelHandler());
3627 
3628  // Originially located in plugins/algo/init
3629  CLabel::RegisterLabelHandler(*CBioTreeContainer::GetTypeInfo(), *new CBioTreeContainerHandler);
3630  CLabel::RegisterLabelHandler(*CGC_Assembly::GetTypeInfo(), *new CGCAsssemblyHandler);
3631  CLabel::RegisterLabelHandler(*CDistanceMatrix::GetTypeInfo(), *new CDistanceMatrixHandler);
3632  CLabel::RegisterLabelHandler(*CEntrezgene::GetTypeInfo(), *new CEntrezgeneHandler);
3633  CLabel::RegisterLabelHandler(*CVariation::GetTypeInfo(), *new CVariationHandler);
3634  CLabel::RegisterLabelHandler(*CGBProject_ver2::GetTypeInfo(), *new CGBProject_ver2LabelHandler);
3635  CLabel::RegisterLabelHandler(*CProjectItem::GetTypeInfo(), *new CProjectItemLabelHandler);
3636  }
3637 };
3638 
3639 
3640 static SForceRegister sm_ForceRegistration;
3641 
3642 END_NCBI_SCOPE
Annot_descr.hpp
User-defined methods of the data storage class.
Annotdesc.hpp
User-defined methods of the data storage class.
BioTreeContainer.hpp
User-defined methods of the data storage class.
Bioseq_set.hpp
Clone_ref.hpp
User-defined methods of the data storage class.
Clone_seq.hpp
User-defined methods of the data storage class.
Clone_seq_set.hpp
User-defined methods of the data storage class.
Delta_item.hpp
User-defined methods of the data storage class.
Dense_seg.hpp
DistanceMatrix.hpp
User-defined methods of the data storage class.
Entrezgene.hpp
User-defined methods of the data storage class.
Entrezgene_Set.hpp
User-defined methods of the data storage class.
GBProject_ver2.hpp
User-defined methods of the data storage class.
GC_AssemblyDesc.hpp
User-defined methods of the data storage class.
Gb_qual.hpp
Gene_ref.hpp
Imp_feat.hpp
eExtreme_Positional
@ eExtreme_Positional
numerical value
Definition: Na_strand.hpp:63
Object_id.hpp
Org_ref.hpp
Phenotype.hpp
User-defined methods of the data storage class.
ProjectDescr.hpp
User-defined methods of the data storage class.
ProjectFolder.hpp
User-defined methods of the data storage class.
ProjectItem.hpp
User-defined methods of the data storage class.
Score.hpp
User-defined methods of the data storage class.
Seq_align.hpp
Seq_align_set.hpp
Seq_annot.hpp
Seq_descr.hpp
Seq_entry.hpp
Seq_id.hpp
Seq_interval.hpp
Seq_literal.hpp
User-defined methods of the data storage class.
Seq_loc.hpp
Seq_point.hpp
Spliced_seg.hpp
User-defined methods of the data storage class.
User_field.hpp
User_object.hpp
ValidErrItem.hpp
User-defined methods of the data storage class.
ValidError.hpp
User-defined methods of the data storage class.
VariantProperties.hpp
User-defined methods of the data storage class.
Variation.hpp
User-defined methods of the data storage class.
Variation_inst.hpp
User-defined methods of the data storage class.
Variation_ref.hpp
User-defined methods of the data storage class.
align_ci.hpp
bioseq_set_handle.hpp
CAlign_CI
CAlign_CI –.
Definition: align_ci.hpp:63
CAnnotTypes_CI::GetSize
size_t GetSize(void) const
Definition: annot_types_ci.hpp:235
CBioTreeContainerHandler
******************************************************************* Moved from plugins/algo/init ****...
Definition: label.cpp:3316
CBioTreeContainerHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3318
CBioseqHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *) const
Definition: label.cpp:961
CBioseq_Handle
CBioseq_Handle –.
Definition: bioseq_handle.hpp:91
CBioseq_setHandler
Definition: label.cpp:1208
CBioseq_setHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:1210
CBioseq_set_Handle
CBioseq_set_Handle –.
Definition: bioseq_set_handle.hpp:107
CBioseq_set
Definition: Bioseq_set.hpp:55
CBioseq_set::GetNucFromNucProtSet
const CBioseq & GetNucFromNucProtSet(void) const
Definition: Bioseq_set.cpp:227
CBioseq_set::GetMasterFromSegSet
const CBioseq & GetMasterFromSegSet(void) const
Definition: Bioseq_set.cpp:275
CBioseq_set::GetGenomicFromGenProdSet
const CBioseq & GetGenomicFromGenProdSet(void) const
Definition: Bioseq_set.cpp:251
CBioseq_set::eContent
@ eContent
Definition: Bioseq_set.hpp:76
CBioseq_set::GetLabel
void GetLabel(string *label, ELabelType type) const
Definition: Bioseq_set.cpp:107
CBioseq::eContent
@ eContent
Definition: Bioseq.hpp:103
CBioseq::eType
@ eType
Definition: Bioseq.hpp:102
CBioseq::eBoth
@ eBoth
Definition: Bioseq.hpp:104
CBioseq::GetLabel
void GetLabel(string *label, ELabelType type, bool worst=false) const
Definition: Bioseq.cpp:202
CBioseq::IsNa
bool IsNa(void) const
Definition: Bioseq.cpp:345
CBioseq::IsAa
bool IsAa(void) const
Definition: Bioseq.cpp:350
CClone_ref
CClone_ref –.
Definition: Clone_ref.hpp:66
CClone_seq
CClone_seq –.
Definition: Clone_seq.hpp:66
CDbtag::GetLabel
void GetLabel(string *label) const
Definition: Dbtag.cpp:187
CDense_seg::GetSeqRange
CRange< TSeqPos > GetSeqRange(TDim row) const
Definition: Dense_seg.hpp:234
CDistanceMatrixHandler
CDistanceMatrix label handler.
Definition: label.cpp:3430
CDistanceMatrixHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType, objects::CScope *) const
Definition: label.cpp:3432
CEntrezgeneHandler
CEntrezgene label handler.
Definition: label.cpp:3451
CEntrezgeneHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3453
CEntrezgene_SetHandler
CEntrezgene_Set label handler.
Definition: label.cpp:3506
CEntrezgene_SetHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3508
CEntrezgene_Set
CEntrezgene_Set –.
Definition: Entrezgene_Set.hpp:66
CFastMutex
CFastMutex –.
Definition: ncbimtx.hpp:667
CGBProject_ver2LabelHandler
Definition: label.cpp:3183
CGBProject_ver2LabelHandler::GetLabel
void GetLabel(const CObject &obj, string *str, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3185
CGBProject_ver2
Definition: GBProject_ver2.hpp:57
CGBProject_ver2::IsSetDescr
bool IsSetDescr() const
retrieve the descriptor set for this project
Definition: GBProject_ver2.cpp:111
CGBProject_ver2::GetDescr
const CProjectDescr & GetDescr() const
Definition: GBProject_ver2.cpp:117
CGBProject_ver2::GetData
const CProjectFolder & GetData() const
retrieve our project's data, in the form of a project folder this may be a contrived entity,...
Definition: GBProject_ver2.cpp:89
CGCAsssemblyHandler
CGCAsssemblyHandler label handler.
Definition: label.cpp:3379
CGCAsssemblyHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3381
CGC_AssemblyDesc
CGC_AssemblyDesc –.
Definition: GC_AssemblyDesc.hpp:66
CGC_Assembly
Definition: GC_Assembly.hpp:63
CGC_Assembly::GetName
string GetName() const
Retrieve the name of this assembly.
Definition: GC_Assembly.cpp:147
CGC_Assembly::GetDesc
const CGC_AssemblyDesc & GetDesc() const
Retrieve the full set of assembly descriptors.
Definition: GC_Assembly.cpp:133
CGb_qual
@Gb_qual.hpp User-defined methods of the data storage class.
Definition: Gb_qual.hpp:61
CGene_ref::GetLabel
void GetLabel(string *label) const
Definition: Gene_ref.cpp:57
CLabelDescriptionCacheImpl::GetLabel
void GetLabel(TGi gi, string *label) const
Definition: label.cpp:330
CLabelDescriptionCacheImpl::AddCaches
void AddCaches(const map< TGi, string > &caches)
Definition: label.cpp:356
CLabelDescriptionCacheImpl::TGi2DescriptionMap
map< TIntId, string > TGi2DescriptionMap
Definition: label.cpp:317
CLabelDescriptionCacheImpl::GetLabel
string GetLabel(TGi gi) const
Definition: label.cpp:321
CLabelDescriptionCacheImpl::HasLabel
bool HasLabel(TGi gi) const
Definition: label.cpp:340
CLabelDescriptionCacheImpl::m_DescrCache
TGi2DescriptionMap m_DescrCache
Definition: label.cpp:367
CLabelDescriptionCacheImpl::SetLabel
void SetLabel(TGi gi, const string &label)
Definition: label.cpp:350
CObject_id
Definition: Object_id.hpp:54
CObject
CObject –.
Definition: ncbiobj.hpp:180
COrg_ref::GetLabel
void GetLabel(string *label) const
Definition: Org_ref.cpp:57
CProjectItemLabelHandler::GetLabel
void GetLabel(const CObject &obj, string *str, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3263
CRef
CRef –.
Definition: ncbiobj.hpp:618
CScope
CScope –.
Definition: scope.hpp:92
CScoreBuilderBase::GetAlignLength
TSeqPos GetAlignLength(const CSeq_align &align, bool ungapped=false)
Compute the length of the alignment (= length of all segments, gaps + aligned)
Definition: score_builder_base.cpp:850
CScoreBuilderBase::GetGapCount
int GetGapCount(const CSeq_align &align)
Compute the number of gaps in the alignment.
Definition: score_builder_base.cpp:844
CScoreBuilderBase::GetPercentCoverage
double GetPercentCoverage(CScope &scope, const CSeq_align &align, unsigned query=0)
Compute percent coverage of the query (sequence 0) (range 0-100)
Definition: score_builder_base.cpp:689
CScoreBuilderBase::GetMismatchCount
int GetMismatchCount(CScope &scope, const CSeq_align &align)
Compute the number of mismatches in the alignment.
Definition: score_builder_base.cpp:730
CScore
Definition: Score.hpp:57
CSeqFeatData::GetSubtype
ESubtype GetSubtype(void) const
Definition: SeqFeatData.cpp:361
CSeqFeatData::SubtypeValueToName
static CTempString SubtypeValueToName(ESubtype eSubtype)
Turns a ESubtype into its string value which is NOT necessarily related to the identifier of the enum...
Definition: SeqFeatData.cpp:513
CSeq_alignHandler
Definition: label.cpp:2699
CSeq_alignHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:2701
CSeq_align_Base::C_Segs
alignment data
Definition: Seq_align_.hpp:118
CSeq_align_setHandler
Definition: label.cpp:2743
CSeq_align_setHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *) const
Definition: label.cpp:2745
CSeq_align_set
Definition: Seq_align_set.hpp:51
CSeq_align
Definition: Seq_align.hpp:55
CSeq_align::eScore_PercentCoverage
@ eScore_PercentCoverage
Definition: Seq_align.hpp:168
CSeq_align::eScore_IdentityCount
@ eScore_IdentityCount
Definition: Seq_align.hpp:145
CSeq_align::eScore_PercentIdentity
@ eScore_PercentIdentity
Definition: Seq_align.hpp:189
CSeq_align::eScore_MismatchCount
@ eScore_MismatchCount
Definition: Seq_align.hpp:154
CSeq_align::GetSeqRange
CRange< TSeqPos > GetSeqRange(TDim row) const
GetSeqRange NB: On a Spliced-seg, in case the product-type is protein, these only return the amin par...
Definition: Seq_align.cpp:153
CSeq_align::CheckNumRows
TDim CheckNumRows(void) const
Validatiors.
Definition: Seq_align.cpp:73
CSeq_align::GetSeq_id
const CSeq_id & GetSeq_id(TDim row) const
Get seq-id (the first one if segments have different ids).
Definition: Seq_align.cpp:317
CSeq_align::GetNamedScore
bool GetNamedScore(const string &id, int &score) const
Get score.
Definition: Seq_align.cpp:563
CSeq_align::GetSeqStrand
ENa_strand GetSeqStrand(TDim row) const
Get strand (the first one if segments have different strands).
Definition: Seq_align.cpp:294
CSeq_annotHandler
Definition: label.cpp:2950
CSeq_annotHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:2952
CSeq_annot_Base::C_Data
C_Data –.
Definition: Seq_annot_.hpp:118
CSeq_annot
Definition: Seq_annot.hpp:58
CSeq_entryHandler
Definition: label.cpp:2289
CSeq_entryHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:2291
CSeq_entry_Handle
CSeq_entry_Handle –.
Definition: seq_entry_handle.hpp:107
CSeq_entry
Definition: Seq_entry.hpp:56
CSeq_featHandler
Definition: label.cpp:1431
CSeq_featHandler::m_UserHandler
CUserFeatHandler m_UserHandler
Definition: label.cpp:2217
CSeq_featHandler::x_UseCustomLabel
bool x_UseCustomLabel(const objects::CSeq_feat &feat) const
Definition: label.cpp:2221
CSeq_featHandler::x_LabelFromQualifiers
void x_LabelFromQualifiers(const objects::CSeq_feat &feat, string &label) const
Definition: label.cpp:2257
CSeq_featHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:1433
CSeq_featHandler::x_GetCustomLabel
void x_GetCustomLabel(const objects::CSeq_feat &feat, string &label) const
Definition: label.cpp:2230
CSeq_featHandler::x_IncludeFeatureTypeInLabel
bool x_IncludeFeatureTypeInLabel(const objects::CSeq_feat &feat) const
Definition: label.cpp:2272
CSeq_feat
namespace ncbi::objects::
Definition: Seq_feat.hpp:58
CSeq_feat::GetNamedQual
const string & GetNamedQual(const CTempString &qual_name) const
Return a named qualifier.
Definition: Seq_feat.cpp:429
CSeq_idHandler
Definition: label.cpp:918
CSeq_idHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:920
CSeq_id_Handle
Definition: seq_id_handle.hpp:158
CSeq_id
Definition: Seq_id.hpp:71
CSeq_interval
Definition: Seq_interval.hpp:51
CSeq_interval::GetLength
TSeqPos GetLength(void) const
Definition: Seq_interval.hpp:125
CSeq_locHandler
Definition: label.cpp:937
CSeq_locHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:939
CSeq_loc_CI
Seq-loc iterator class – iterates all intervals from a seq-loc in the correct order.
Definition: Seq_loc.hpp:453
CSeq_loc
Definition: Seq_loc.hpp:94
CSerialObject
Base class for all serializable objects.
Definition: serialbase.hpp:150
CSnpBitfield
CSnpBitfield is a facade for representing any version of the SNP bitfield.
Definition: snp_bitfield.hpp:69
CSnpBitfield::IsTrue
bool IsTrue(EProperty prop) const
Definition: snp_bitfield.hpp:357
CSnpBitfield::isGood
bool isGood() const
Definition: snp_bitfield.hpp:337
CSnpBitfield::GetVariationClassString
const char * GetVariationClassString() const
Definition: snp_bitfield.cpp:165
CSpliced_seg
Definition: Spliced_seg.hpp:57
CStaticArrayMap
class CStaticArrayMap<> provides access to a static array in much the same way as CStaticArraySet<>,...
Definition: static_map.hpp:175
CTaxIDSetLabelHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *) const
Definition: label.cpp:3108
CTaxIdSelSet
Class designed to hold a set of tax-ids represented as (on) bits in a bit vector.
Definition: taxid_sel_set.hpp:48
CTaxIdSelSet::GetSelectedTaxIds
const TBitVec & GetSelectedTaxIds() const
Definition: taxid_sel_set.hpp:56
CTaxIdSelSet::TTaxId
bm::id_t TTaxId
Definition: taxid_sel_set.hpp:51
CTextseq_id
Definition: Textseq_id.hpp:51
CTypeConstIterator
Template class for iteration on objects of class C (non-medifiable version)
Definition: iterator.hpp:767
CTypeInfo
CTypeInfo class contains all information about C++ types (both basic and classes): members and layout...
Definition: typeinfo.hpp:76
CUserFeatHandler
handler specific for User-object features
Definition: label.cpp:1287
CUserFeatHandler::GetLabel
void GetLabel(const CObject &obj_in, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:1289
CUser_object
Definition: User_object.hpp:51
CUser_object::GetFieldRef
CConstRef< CUser_field > GetFieldRef(const string &str, const string &delim=".", NStr::ECase use_case=NStr::eCase) const
Definition: User_object.cpp:84
CValidErrorHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *) const
Definition: label.cpp:3030
CValidError_CI
Definition: ValidError.hpp:194
CValidError::ErrorSize
SIZE_TYPE ErrorSize() const
Definition: ValidError.hpp:262
CValidError::InfoSize
SIZE_TYPE InfoSize() const
Definition: ValidError.hpp:248
CValidError::CriticalSize
SIZE_TYPE CriticalSize() const
Definition: ValidError.hpp:269
CValidError::WarningSize
SIZE_TYPE WarningSize() const
Definition: ValidError.hpp:255
CValidError::TotalSize
SIZE_TYPE TotalSize() const
Definition: ValidError.hpp:234
CValidError::FatalSize
SIZE_TYPE FatalSize() const
Definition: ValidError.hpp:276
CVariationHandler
CVariation label handler.
Definition: label.cpp:3553
CVariationHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, objects::CScope *scope) const
Definition: label.cpp:3555
CVariation_ref
Definition: Variation_ref.hpp:57
CVariation_ref::GetValidated
TValidated GetValidated(void) const
Definition: Variation_ref.cpp:257
CVariation_ref::IsLoss
bool IsLoss() const
Definition: Variation_ref.cpp:1187
CVariation_ref::IsSetAllele_origin
bool IsSetAllele_origin(void) const
Definition: Variation_ref.cpp:338
CVariation_ref::IsUnknown
bool IsUnknown() const
Definition: Variation_ref.cpp:1330
CVariation_ref::GetAllele_origin
TAllele_origin GetAllele_origin(void) const
Definition: Variation_ref.cpp:365
CVariation_ref::IsComplex
bool IsComplex() const
Definition: Variation_ref.cpp:1319
CVariation_ref::IsEversion
bool IsEversion() const
Definition: Variation_ref.cpp:1261
CVariation_ref::IsUniparentalDisomy
bool IsUniparentalDisomy() const
Definition: Variation_ref.cpp:1306
CVariation_ref::IsDeletionInsertion
bool IsDeletionInsertion() const
Definition: Variation_ref.cpp:1066
CVariation_ref::IsGain
bool IsGain() const
Definition: Variation_ref.cpp:1159
CVariation_ref::IsSetValidated
bool IsSetValidated(void) const
Definition: Variation_ref.cpp:230
CVariation_ref::IsTranslocation
bool IsTranslocation() const
Definition: Variation_ref.cpp:1291
CVariation_ref::IsInversion
bool IsInversion() const
Definition: Variation_ref.cpp:1241
CVariation_ref::IsInsertion
bool IsInsertion() const
Definition: Variation_ref.cpp:1027
CVariation_ref::IsDeletion
bool IsDeletion() const
Definition: Variation_ref.cpp:1003
CVariation_ref::IsCNV
bool IsCNV() const
Definition: Variation_ref.cpp:1137
CVcfVariantHandler::GetLabel
void GetLabel(const CObject &obj, string *label, CLabel::ELabelType type, CScope *scope) const
Definition: label.cpp:1005
ILabelHandler
ILabelHandler interface.
Definition: label.hpp:136
NSnp::GetRsid
static TRsid GetRsid(const CMappedFeat &mapped_feat)
Return rsid of SNP.
Definition: snp_utils.cpp:109
NSnp::GetLength
static int GetLength(const CMappedFeat &)
Return distance of neighbors in flanking sequence.
Definition: snp_utils.cpp:133
NSnp::TAlleles
vector< string > TAlleles
list of alleles belonging to particular SNP a deletion is represented by a "-"
Definition: snp_utils.hpp:188
NSnp::TRsid
CObject_id::TId8 TRsid
Definition: snp_utils.hpp:70
NSnp::GetAlleles
static void GetAlleles(const CMappedFeat &mapped_feat, TAlleles &Alleles)
Return list of alleles encoded in qual.
Definition: snp_utils.cpp:237
NSnp::ClinSigAsString
static string ClinSigAsString(const CVariation_ref &var, ELetterCase LetterCase=eLetterCase_Mixed)
get a human-readable text for various clinical significance types
Definition: snp_utils.cpp:172
bm::bvector::enumerator
Constant iterator designed to enumerate "ON" bits.
Definition: bm.h:603
bm::bvector::first
enumerator first() const
Returns enumerator pointing on the first non-zero bit.
Definition: bm.h:1871
bm::bvector::end
enumerator end() const
Returns enumerator pointing on the next bit after the last.
Definition: bm.h:1877
bm::bvector::count
size_type count() const noexcept
population count (count of ON bits)
Definition: bm.h:2401
map_checker< std::map< Key, T, less< Key > > >::const_iterator
container_type::const_iterator const_iterator
Definition: map.hpp:53
map_checker::begin
const_iterator begin() const
Definition: map.hpp:151
map_checker::end
const_iterator end() const
Definition: map.hpp:152
map_checker::find
const_iterator find(const key_type &key) const
Definition: map.hpp:153
map
Definition: map.hpp:338
set
Definition: set.hpp:45
set::insert
iterator_bool insert(const value_type &val)
Definition: set.hpp:149
set::size
size_type size() const
Definition: set.hpp:132
handler
void(*)(CSeq_entry_Handle seh, IWorkbench *wb, const CSerialObject &obj) handler
Definition: common_commands.cpp:295
create_defline.hpp
API (CDeflineGenerator) for computing sequences' titles ("definitions").
TPair
SStaticPair< const char *, const char * > TPair
Definition: entrez_conversion.cpp:43
type
static int type
Definition: getdata.c:31
str
static const char * str(char *buf, int n)
Definition: stats.c:84
TSeqPos
unsigned int TSeqPos
Type for sequence locations and lengths.
Definition: ncbimisc.hpp:875
ITERATE
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
Definition: ncbimisc.hpp:815
TIntId
Int8 TIntId
Definition: ncbimisc.hpp:999
ZERO_GI
#define ZERO_GI
Definition: ncbimisc.hpp:1088
GI_TO
#define GI_TO(T, gi)
Definition: ncbimisc.hpp:1085
string
string
Definition: cgiapp.hpp:687
NULL
#define NULL
Definition: ncbistd.hpp:225
LOG_POST
#define LOG_POST(message)
This macro is deprecated and it's strongly recomended to move in all projects (except tests) to macro...
Definition: ncbidiag.hpp:226
Error
void Error(CExceptionArgs_Base &args)
Definition: ncbiexpt.hpp:1197
NCBI_CATCH
#define NCBI_CATCH(message)
Catch CExceptions as well This macro is deprecated - use *_X or *_XX variant instead of it.
Definition: ncbiexpt.hpp:580
CException::GetMsg
const string & GetMsg(void) const
Get message string.
Definition: ncbiexpt.cpp:461
CEnumeratedTypeValues::FindName
const string & FindName(TEnumValueType value, bool allowBadValue) const
Find name of the enum by its numeric value.
Definition: enumerated.cpp:146
CLabel::GetTypeIconAlias
static string GetTypeIconAlias(const string &user_type, const string &user_subtype)
Definition: label.cpp:268
CLabel::RegisterLabelHandler
static void RegisterLabelHandler(const string &type, ILabelHandler &handler)
Definition: label.cpp:229
CGUIUserType::sm_Tp_Sequence
static const string sm_Tp_Sequence
Definition: user_type.hpp:64
CGUIUserType::sm_Tp_ProjectItem
static const string sm_Tp_ProjectItem
Definition: user_type.hpp:74
CLabelDescriptionCache::StopCache
static void StopCache()
Stop cache instance (call once at gBench stop)
Definition: label.cpp:380
CGUIUserType::sm_Tp_EntrezGeneRecord
static const string sm_Tp_EntrezGeneRecord
Definition: user_type.hpp:58
CLabel::GetLabel
static void GetLabel(const CObject &obj, string *label, ELabelType type=eDefault)
Definition: label.cpp:140
CStringUtil::FormatStringsOccurrences
static string FormatStringsOccurrences(const std::vector< string > &strings, const string &delimiter=", ")
Definition: string_utils.cpp:70
CGUIUserType::sm_Tp_Alignment
static const string sm_Tp_Alignment
Definition: user_type.hpp:55
CGUIUserType::sm_Tp_Annotation
static const string sm_Tp_Annotation
Definition: user_type.hpp:57
CGUIUserType::sm_Tp_Sequence_Set
static const string sm_Tp_Sequence_Set
Definition: user_type.hpp:66
CGUIUserType::sm_SbTp_PhySet
static const string sm_SbTp_PhySet
Definition: user_type.hpp:98
CGUIUserType::sm_SbTp_MutSet_Aln
static const string sm_SbTp_MutSet_Aln
Definition: user_type.hpp:105
CLabelDescriptionCache::AddCaches
static void AddCaches(const map< TGi, string > &caches)
Definition: label.cpp:480
CLabel::GetIconAlias
static void GetIconAlias(const CObject &obj, string *alias, objects::CScope *scope=NULL)
Definition: label.cpp:300
CGUIUserType::sm_SbTp_PhySet_Aln
static const string sm_SbTp_PhySet_Aln
Definition: user_type.hpp:103
CGUIUserType::sm_SbTp_Undefined
static const string sm_SbTp_Undefined
Definition: user_type.hpp:78
CGUIUserType::sm_SbTp_DNA
static const string sm_SbTp_DNA
Definition: user_type.hpp:81
CGUIUserType::sm_SbTp_EcoSet
static const string sm_SbTp_EcoSet
Definition: user_type.hpp:99
CGUIUserType::sm_Tp_TaxId_Set
static const string sm_Tp_TaxId_Set
Definition: user_type.hpp:63
CGUIUserType::sm_SbTp_Graphs
static const string sm_SbTp_Graphs
Definition: user_type.hpp:87
CLabel::HasHandler
static bool HasHandler(const CTypeInfo &type)
Definition: label.cpp:243
CGUIUserType::sm_SbTp_NucProt
static const string sm_SbTp_NucProt
Definition: user_type.hpp:93
CLabelDescriptionCache::CacheSeqId
static void CacheSeqId(const objects::CSeq_id &id, objects::CScope *scope)
Generate and cache description label for the specified gi.
Definition: label.cpp:459
CStringUtil::ConcatenateStrings
static string ConcatenateStrings(const std::vector< string > &strings, const string &delimiter=", ")
Definition: string_utils.cpp:54
CLabel::SetLabelByData
static void SetLabelByData(objects::CProjectItem &item, objects::CScope *scope=NULL)
Definition: label.cpp:121
CGUIUserType::sm_Tp_Feature
static const string sm_Tp_Feature
Definition: user_type.hpp:60
CGUIUserType::sm_SbTp_PopSet_Aln
static const string sm_SbTp_PopSet_Aln
Definition: user_type.hpp:102
CGUIUserType::sm_SbTp_EcoSet_Aln
static const string sm_SbTp_EcoSet_Aln
Definition: user_type.hpp:104
CGUIUserType::sm_SbTp_GenProdSet
static const string sm_SbTp_GenProdSet
Definition: user_type.hpp:95
CGUIUserType::sm_Tp_Alignment_Set
static const string sm_Tp_Alignment_Set
Definition: user_type.hpp:56
CGUIUserType::sm_SbTp_Features
static const string sm_SbTp_Features
Definition: user_type.hpp:86
CGUIUserType::sm_SbTp_Sequence_IDs
static const string sm_SbTp_Sequence_IDs
Definition: user_type.hpp:88
CLabel::TruncateLabel
static void TruncateLabel(string *label, unsigned length_limit, unsigned length_tolerance)
truncate the label to some specific length with a desired leven of precision algorithm tries to analy...
Definition: label.cpp:187
CLabelDescriptionCache::InitCache
static void InitCache()
Initialize cache instance (call once at gBench start)
Definition: label.cpp:372
CGUIUserType::sm_SbTp_Table
static const string sm_SbTp_Table
Definition: user_type.hpp:90
CGUIUserType::sm_Tp_ValidationResult
static const string sm_Tp_ValidationResult
Definition: user_type.hpp:69
CGUIUserType::sm_SbTp_Protein
static const string sm_SbTp_Protein
Definition: user_type.hpp:82
CGUIUserType::sm_SbTp_MutSet
static const string sm_SbTp_MutSet
Definition: user_type.hpp:100
CGUIUserType::sm_SbTp_ProjectVer2
static const string sm_SbTp_ProjectVer2
Definition: user_type.hpp:109
CGUIUserType::sm_SbTp_SegSeq
static const string sm_SbTp_SegSeq
Definition: user_type.hpp:94
CLabel::RegisterTypeIcon
static void RegisterTypeIcon(const string &user_type, const string &user_subtype, const string &icon_alias)
Definition: label.cpp:257
CGUIUserType::sm_SbTp_Locations
static const string sm_SbTp_Locations
Definition: user_type.hpp:89
CGUIUserType::sm_SbTp_PopSet
static const string sm_SbTp_PopSet
Definition: user_type.hpp:97
CLabel::sm_LabelMap
static TLabelMap sm_LabelMap
Definition: label.hpp:128
CLabel::ELabelType
ELabelType
Definition: label.hpp:60
CVcfVariant::GetTypeName
static string GetTypeName()
Definition: snp_gui.hpp:304
CGUIUserType::sm_Tp_Variation
static const string sm_Tp_Variation
Definition: user_type.hpp:71
CVcfVariant::GetLabel
void GetLabel(string &label, CLabel::ELabelType type) const
Definition: snp_gui.cpp:1226
CGUIUserType::sm_SbTp_Alignments
static const string sm_SbTp_Alignments
Definition: user_type.hpp:85
CLabel::sm_AliasMap
static TAliasMap sm_AliasMap
Definition: label.hpp:129
CGUIUserType::sm_Tp_Sequence_ID
static const string sm_Tp_Sequence_ID
Definition: user_type.hpp:65
CGUIUserType::sm_Tp_Location
static const string sm_Tp_Location
Definition: user_type.hpp:61
CGUIUserType::sm_Tp_Project
static const string sm_Tp_Project
Definition: user_type.hpp:73
CLabel::eContentAndProduct
@ eContentAndProduct
Definition: label.hpp:71
CLabel::eType
@ eType
Definition: label.hpp:65
CLabel::eUserSubtype
@ eUserSubtype
Definition: label.hpp:64
CLabel::eDefault
@ eDefault
Definition: label.hpp:73
CLabel::eUserTypeAndContent
@ eUserTypeAndContent
Definition: label.hpp:66
CLabel::eContent
@ eContent
Definition: label.hpp:62
CLabel::eGi
@ eGi
Definition: label.hpp:70
CLabel::eDescription
@ eDescription
Definition: label.hpp:68
CLabel::eUserType
@ eUserType
Definition: label.hpp:63
CLabel::eDescriptionBrief
@ eDescriptionBrief
Definition: label.hpp:67
ENUM_METHOD_NAME
#define ENUM_METHOD_NAME(EnumName)
Definition: serialbase.hpp:994
CSerialObject::GetThisTypeInfo
virtual const CTypeInfo * GetThisTypeInfo(void) const =0
MSerial_AsnText
#define MSerial_AsnText
I/O stream manipulators –.
Definition: serialbase.hpp:696
CSeq_id::IdentifyAccession
static EAccessionInfo IdentifyAccession(const CTempString &accession, TParseFlags flags=fParse_AnyRaw)
Deduces information from a bare accession a la WHICH_db_accession; may report false negatives on prop...
Definition: Seq_id.cpp:1634
CSeq_id::GetSeqIdString
string GetSeqIdString(bool with_version=false) const
Return seqid string with optional version for text seqid type.
Definition: Seq_id.cpp:2145
CSeq_id::GetLabel
void GetLabel(string *label, ELabelType type=eDefault, TLabelFlags flags=fLabel_Default) const
Append a label for this Seq-id to the supplied string.
Definition: Seq_id.cpp:2040
CSeq_id_Handle::GetSeqId
CConstRef< CSeq_id > GetSeqId(void) const
Definition: seq_id_handle.hpp:304
CSeq_id::EAccessionInfo
EAccessionInfo
For IdentifyAccession (below)
Definition: Seq_id.hpp:220
CSeq_id_Handle::GetSeqIdOrNull
CConstRef< CSeq_id > GetSeqIdOrNull(void) const
Definition: seq_id_handle.hpp:315
CSeq_id::Match
bool Match(const CSeq_id &sid2) const
Match() - TRUE if SeqIds are equivalent.
Definition: Seq_id.hpp:1065
CSeq_id_Handle::GetHandle
static CSeq_id_Handle GetHandle(const CSeq_id &id)
Normal way of getting a handle, works for any seq-id.
Definition: seq_id_handle.cpp:113
CSeq_id::Score
static int Score(const CRef< CSeq_id > &id)
Wrappers for use with FindBestChoice from <corelib/ncbiutil.hpp>
Definition: Seq_id.hpp:772
GetLabel
string GetLabel(const CSeq_id &id)
Definition: seq_id_handle.cpp:288
CSeq_id_Handle::GetGi
TGi GetGi(void) const
Definition: seq_id_handle.hpp:283
CSeq_id::fLabel_Default
@ fLabel_Default
default options - always show the version
Definition: Seq_id.hpp:623
CSeq_id::fAcc_prot
@ fAcc_prot
Definition: Seq_id.hpp:252
CSeq_id::fAcc_nuc
@ fAcc_nuc
Definition: Seq_id.hpp:251
CSeq_id::eContent
@ eContent
Untagged human-readable accession or the like.
Definition: Seq_id.hpp:605
CSeq_id::eBoth
@ eBoth
Type and content, delimited by a vertical bar.
Definition: Seq_id.hpp:606
CSeq_loc::GetTotalRange
TRange GetTotalRange(void) const
Definition: Seq_loc.hpp:913
CSeq_loc::GetStart
TSeqPos GetStart(ESeqLocExtremes ext) const
Return start and stop positions of the seq-loc.
Definition: Seq_loc.cpp:915
CSeq_loc::GetId
const CSeq_id * GetId(void) const
Get the id of the location return NULL if has multiple ids or no id at all.
Definition: Seq_loc.hpp:941
CSeq_loc::GetLabel
void GetLabel(string *label) const
Appends a label suitable for display (e.g., error messages) label must point to an existing string ob...
Definition: Seq_loc.cpp:3467
CSeq_loc::GetStop
TSeqPos GetStop(ESeqLocExtremes ext) const
Definition: Seq_loc.cpp:963
CSeq_loc_CI::eEmpty_Allow
@ eEmpty_Allow
ignore empty locations
Definition: Seq_loc.hpp:458
ELabelType
ELabelType
For compatibility with legacy code.
Definition: feature.hpp:85
fFGL_NoComments
@ fFGL_NoComments
Leave out comments, even as fallbacks.
Definition: feature.hpp:75
fFGL_NoQualifiers
@ fFGL_NoQualifiers
Leave out qualifiers.
Definition: feature.hpp:76
fFGL_Content
@ fFGL_Content
Include its content if there is any.
Definition: feature.hpp:73
fFGL_Type
@ fFGL_Type
Always include the feature's type.
Definition: feature.hpp:72
GetId
const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)
If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...
Definition: seq_loc_util.cpp:359
GetStrand
ENa_strand GetStrand(const CSeq_loc &loc, CScope *scope=0)
Returns eNa_strand_unknown if multiple Bioseqs in loc Returns eNa_strand_other if multiple strands in...
Definition: seq_loc_util.cpp:481
IsOneBioseq
bool IsOneBioseq(const CSeq_loc &loc, CScope *scope)
Returns true if all embedded CSeq_ids represent the same CBioseq, else false.
Definition: seq_loc_util.cpp:386
IsSameBioseq
bool IsSameBioseq(const CSeq_id &id1, const CSeq_id &id2, CScope *scope, CScope::EGetBioseqFlag get_flag=CScope::eGetBioseq_All)
Determines if two CSeq_ids represent the same CBioseq.
Definition: seq_loc_util.cpp:300
eGetId_Best
@ eGetId_Best
return the "best" gi (uses FindBestScore(), with CSeq_id::CalculateScore() as the score function
Definition: sequence.hpp:101
eGetId_ForceGi
@ eGetId_ForceGi
return only a gi-based seq-id
Definition: sequence.hpp:99
eGetId_Canonical
@ eGetId_Canonical
Definition: sequence.hpp:114
CScope::GetBioseqHandle
CBioseq_Handle GetBioseqHandle(const CSeq_id &id)
Get bioseq handle by seq-id.
Definition: scope.cpp:95
CScope::GetBioseq_setHandle
CBioseq_set_Handle GetBioseq_setHandle(const CBioseq_set &seqset, EMissing action=eMissing_Default)
Definition: scope.cpp:176
CScope::eGetBioseq_All
@ eGetBioseq_All
Search bioseq, load if not loaded yet.
Definition: scope.hpp:128
CBioseq_set_Handle::GetTopLevelEntry
CSeq_entry_Handle GetTopLevelEntry(void) const
Return a handle for the top-level seq-entry.
Definition: bioseq_set_handle.cpp:127
SAnnotSelector::SetMaxSize
SAnnotSelector & SetMaxSize(TMaxSize max_size)
Set maximum number of annotations to find.
Definition: annot_selector.hpp:456
SAnnotSelector::SetLimitTSE
SAnnotSelector & SetLimitTSE(const CTSE_Handle &limit)
Limit annotations to those from the TSE only.
Definition: annot_selector.cpp:231
COpenRange::GetLength
position_type GetLength(void) const
Definition: range.hpp:158
END_NCBI_SCOPE
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
BEGIN_NCBI_SCOPE
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
NStr::SizetToString
static string SizetToString(size_t value, TNumToStringFlags flags=0, int base=10)
Convert size_t to string.
Definition: ncbistr.cpp:2742
NStr::DoubleToString
static string DoubleToString(double value, int precision=-1, TNumToStringFlags flags=0)
Convert double to string.
Definition: ncbistr.hpp:5189
kEmptyStr
#define kEmptyStr
Definition: ncbistr.hpp:123
NStr::StringToInt
static int StringToInt(const CTempString str, TStringToNumFlags flags=0, int base=10)
Convert string to int.
Definition: ncbistr.cpp:630
NStr::IntToString
static string IntToString(int value, TNumToStringFlags flags=0, int base=10)
Convert int to string.
Definition: ncbistr.hpp:5086
NStr::Join
static string Join(const TContainer &arr, const CTempString &delim)
Join strings using the specified delimiter.
Definition: ncbistr.hpp:2699
NStr::UIntToString
static string UIntToString(unsigned int value, TNumToStringFlags flags=0, int base=10)
Convert UInt to string.
Definition: ncbistr.hpp:5111
NStr::EqualNocase
static bool EqualNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)
Case-insensitive equality of a substring with another string.
Definition: ncbistr.hpp:5355
NStr::NumericToString
static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)
Convert numeric value to string.
Definition: ncbistr.hpp:673
NStr::fWithCommas
@ fWithCommas
Use commas as thousands separator.
Definition: ncbistr.hpp:254
CTypeInfo::GetName
const string & GetName(void) const
Get name of this type.
Definition: typeinfo.cpp:249
FindBestChoice
C::value_type FindBestChoice(const C &container, F score_func)
Find the best choice (lowest score) for values in a container.
Definition: ncbiutil.hpp:250
label
static const char label[]
Definition: sec_negotiate_gnutls.h:210
CBioSource_Base::GetOrg
const TOrg & GetOrg(void) const
Get the Org member data.
Definition: BioSource_.hpp:509
CSubSource_Base::eSubtype_sex
@ eSubtype_sex
Definition: SubSource_.hpp:91
CEntrezgene_Set_Base::Tdata
list< CRef< CEntrezgene > > Tdata
Definition: Entrezgene_Set_.hpp:89
CEntrezgene_Base::GetSource
const TSource & GetSource(void) const
Get the Source member data.
Definition: Entrezgene_.hpp:944
CEntrezgene_Set_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Entrezgene_Set_.hpp:164
CEntrezgene_Base::GetGene
const TGene & GetGene(void) const
Get the Gene member data.
Definition: Entrezgene_.hpp:974
CProjectItem_Base::IsSetLabel
bool IsSetLabel(void) const
user-defined label Check if a value has been assigned to Label data member.
Definition: ProjectItem_.hpp:942
CProjectDescr_Base::GetTitle
const TTitle & GetTitle(void) const
Get the Title member data.
Definition: ProjectDescr_.hpp:302
CProjectDescr_Base::IsSetTitle
bool IsSetTitle(void) const
user-defined title for the workspace Check if a value has been assigned to Title data member.
Definition: ProjectDescr_.hpp:290
CProjectItem_Base::GetLabel
const TLabel & GetLabel(void) const
Get the Label member data.
Definition: ProjectItem_.hpp:954
CGBProject_ver2_Base::IsSetData
bool IsSetData(void) const
a set of extra analyses perfromed by the user each of these may have descriptors Check if a value has...
Definition: GBProject_ver2_.hpp:745
CGene_ref_Base::GetDesc
const TDesc & GetDesc(void) const
Get the Desc member data.
Definition: Gene_ref_.hpp:599
CGene_ref_Base::IsSetDesc
bool IsSetDesc(void) const
descriptive name Check if a value has been assigned to Desc data member.
Definition: Gene_ref_.hpp:587
CUser_field_Base::C_Data::GetStr
const TStr & GetStr(void) const
Get the variant data.
Definition: User_field_.hpp:694
CObject_id_Base::IsStr
bool IsStr(void) const
Check if variant Str is selected.
Definition: Object_id_.hpp:291
CDbtag_Base::GetTag
const TTag & GetTag(void) const
Get the Tag member data.
Definition: Dbtag_.hpp:267
CObject_id_Base::IsId
bool IsId(void) const
Check if variant Id is selected.
Definition: Object_id_.hpp:264
CUser_field_Base::GetData
const TData & GetData(void) const
Get the Data member data.
Definition: User_field_.hpp:1024
CDbtag_Base::GetDb
const TDb & GetDb(void) const
Get the Db member data.
Definition: Dbtag_.hpp:220
CUser_field_Base::C_Data::GetBool
TBool GetBool(void) const
Get the variant data.
Definition: User_field_.hpp:768
CUser_object_Base::IsSetClass
bool IsSetClass(void) const
endeavor which designed this object Check if a value has been assigned to Class data member.
Definition: User_object_.hpp:246
CUser_object_Base::GetClass
const TClass & GetClass(void) const
Get the Class member data.
Definition: User_object_.hpp:258
CObject_id_Base::GetStr
const TStr & GetStr(void) const
Get the variant data.
Definition: Object_id_.hpp:297
CUser_object_Base::GetType
const TType & GetType(void) const
Get the Type member data.
Definition: User_object_.hpp:305
CObject_id_Base::GetId
TId GetId(void) const
Get the variant data.
Definition: Object_id_.hpp:270
CGC_AssemblyDesc_Base::GetName
const TName & GetName(void) const
Get the Name member data.
Definition: GC_AssemblyDesc_.hpp:935
CGC_AssemblyDesc_Base::GetLong_name
const TLong_name & GetLong_name(void) const
Get the Long_name member data.
Definition: GC_AssemblyDesc_.hpp:1076
CGC_AssemblyDesc_Base::IsSetLong_name
bool IsSetLong_name(void) const
Check if a value has been assigned to Long_name data member.
Definition: GC_AssemblyDesc_.hpp:1064
CGC_AssemblyDesc_Base::IsSetName
bool IsSetName(void) const
Names of the assembly Check if a value has been assigned to Name data member.
Definition: GC_AssemblyDesc_.hpp:923
CScore_Base::IsSetId
bool IsSetId(void) const
Check if a value has been assigned to Id data member.
Definition: Score_.hpp:432
CSeq_align_Base::C_Segs::GetDenseg
const TDenseg & GetDenseg(void) const
Get the variant data.
Definition: Seq_align_.cpp:153
CSpliced_seg_Base::GetGenomic_id
const TGenomic_id & GetGenomic_id(void) const
Get the Genomic_id member data.
Definition: Spliced_seg_.hpp:530
CScore_Base::C_Value::IsReal
bool IsReal(void) const
Check if variant Real is selected.
Definition: Score_.hpp:378
CSeq_align_Base::C_Segs::Which
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_align_.hpp:691
CSpliced_seg_Base::CanGetGenomic_id
bool CanGetGenomic_id(void) const
Check if it is safe to call GetGenomic_id method.
Definition: Spliced_seg_.hpp:524
CSeq_align_Base::TScore
vector< CRef< CScore > > TScore
Definition: Seq_align_.hpp:398
CSeq_align_Base::C_Segs::E_Choice
E_Choice
Choice variants.
Definition: Seq_align_.hpp:131
CSpliced_seg_Base::GetProduct_id
const TProduct_id & GetProduct_id(void) const
Get the Product_id member data.
Definition: Spliced_seg_.hpp:509
CSeq_align_Base::TDim
int TDim
Definition: Seq_align_.hpp:397
CDense_seg_Base::TIds
vector< CRef< CSeq_id > > TIds
Definition: Dense_seg_.hpp:106
CSeq_align_Base::C_Segs::GetSpliced
const TSpliced & GetSpliced(void) const
Get the variant data.
Definition: Seq_align_.cpp:219
CScore_Base::C_Value::GetInt
TInt GetInt(void) const
Get the variant data.
Definition: Score_.hpp:411
CSpliced_seg_Base::GetExons
const TExons & GetExons(void) const
Get the Exons member data.
Definition: Spliced_seg_.hpp:692
CScore_Base::GetValue
const TValue & GetValue(void) const
Get the Value member data.
Definition: Score_.hpp:465
CSpliced_seg_Base::CanGetProduct_id
bool CanGetProduct_id(void) const
Check if it is safe to call GetProduct_id method.
Definition: Spliced_seg_.hpp:503
CDense_seg_Base::GetIds
const TIds & GetIds(void) const
Get the Ids member data.
Definition: Dense_seg_.hpp:505
CSeq_align_Base::IsSetScore
bool IsSetScore(void) const
for whole alignment Check if a value has been assigned to Score data member.
Definition: Seq_align_.hpp:884
CSeq_align_set_Base::Tdata
list< CRef< CSeq_align > > Tdata
Definition: Seq_align_set_.hpp:91
CSeq_align_Base::GetScore
const TScore & GetScore(void) const
Get the Score member data.
Definition: Seq_align_.hpp:896
CScore_Base::C_Value::GetReal
TReal GetReal(void) const
Get the variant data.
Definition: Score_.hpp:384
CSeq_align_Base::C_Segs::GetDisc
const TDisc & GetDisc(void) const
Get the variant data.
Definition: Seq_align_.cpp:197
CScore_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Score_.hpp:444
CSeq_align_set_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Seq_align_set_.hpp:166
CSeq_align_Base::GetSegs
const TSegs & GetSegs(void) const
Get the Segs member data.
Definition: Seq_align_.hpp:921
CSeq_align_Base::C_Segs::e_Denseg
@ e_Denseg
Definition: Seq_align_.hpp:134
CSeq_align_Base::C_Segs::e_Std
@ e_Std
Definition: Seq_align_.hpp:135
CSeq_align_Base::C_Segs::e_Disc
@ e_Disc
Definition: Seq_align_.hpp:137
CSeq_align_Base::C_Segs::e_Spliced
@ e_Spliced
Definition: Seq_align_.hpp:138
CSeq_align_Base::C_Segs::e_Packed
@ e_Packed
Definition: Seq_align_.hpp:136
CSeq_align_Base::C_Segs::e_not_set
@ e_not_set
No variant selected.
Definition: Seq_align_.hpp:132
CSeq_align_Base::C_Segs::e_Sparse
@ e_Sparse
Definition: Seq_align_.hpp:139
CSeq_align_Base::C_Segs::e_Dendiag
@ e_Dendiag
Definition: Seq_align_.hpp:133
CGb_qual_Base::GetVal
const TVal & GetVal(void) const
Get the Val member data.
Definition: Gb_qual_.hpp:259
CClone_ref_Base::GetConcordant
TConcordant GetConcordant(void) const
Get the Concordant member data.
Definition: Clone_ref_.hpp:512
CSeq_feat_Base::IsSetComment
bool IsSetComment(void) const
Check if a value has been assigned to Comment data member.
Definition: Seq_feat_.hpp:1037
CSeqFeatData_Base::GetClone
const TClone & GetClone(void) const
Get the variant data.
Definition: SeqFeatData_.cpp:570
CSeq_feat_Base::IsSetQual
bool IsSetQual(void) const
qualifiers Check if a value has been assigned to Qual data member.
Definition: Seq_feat_.hpp:1135
CSeqFeatData_Base::IsUser
bool IsUser(void) const
Check if variant User is selected.
Definition: SeqFeatData_.hpp:1026
CClone_ref_Base::IsSetUnique
bool IsSetUnique(void) const
OPTIONAL? Check if a value has been assigned to Unique data member.
Definition: Clone_ref_.hpp:537
CSeqFeatData_Base::GetRegion
const TRegion & GetRegion(void) const
Get the variant data.
Definition: SeqFeatData_.hpp:940
CSeq_feat_Base::GetTitle
const TTitle & GetTitle(void) const
Get the Title member data.
Definition: Seq_feat_.hpp:1172
CSeqFeatData_Base::GetSeq
const TSeq & GetSeq(void) const
Get the variant data.
Definition: SeqFeatData_.cpp:398
CImp_feat_Base::IsSetDescr
bool IsSetDescr(void) const
text description Check if a value has been assigned to Descr data member.
Definition: Imp_feat_.hpp:341
CSeq_feat_Base::GetQual
const TQual & GetQual(void) const
Get the Qual member data.
Definition: Seq_feat_.hpp:1147
CClone_ref_Base::IsSetConcordant
bool IsSetConcordant(void) const
OPTIONAL? Check if a value has been assigned to Concordant data member.
Definition: Clone_ref_.hpp:487
CSeq_feat_Base::GetLocation
const TLocation & GetLocation(void) const
Get the Location member data.
Definition: Seq_feat_.hpp:1117
CClone_seq_Base::CanGetSeq
bool CanGetSeq(void) const
Check if it is safe to call GetSeq method.
Definition: Clone_seq_.hpp:528
CSeq_feat_Base::GetData
const TData & GetData(void) const
Get the Data member data.
Definition: Seq_feat_.hpp:925
CClone_seq_set_Base::Tdata
list< CRef< CClone_seq > > Tdata
Definition: Clone_seq_set_.hpp:89
CSeqFeatData_Base::GetUser
const TUser & GetUser(void) const
Get the variant data.
Definition: SeqFeatData_.cpp:470
CClone_ref_Base::GetName
const TName & GetName(void) const
Get the Name member data.
Definition: Clone_ref_.hpp:405
CClone_seq_Base::GetSupport
TSupport GetSupport(void) const
Get the Support member data.
Definition: Clone_seq_.hpp:583
CSeq_feat_Base::CanGetLocation
bool CanGetLocation(void) const
Check if it is safe to call GetLocation method.
Definition: Seq_feat_.hpp:1111
CImp_feat_Base::GetDescr
const TDescr & GetDescr(void) const
Get the Descr member data.
Definition: Imp_feat_.hpp:353
CSeq_feat_Base::GetProduct
const TProduct & GetProduct(void) const
Get the Product member data.
Definition: Seq_feat_.hpp:1096
CClone_ref_Base::IsSetPlacement_method
bool IsSetPlacement_method(void) const
Check if a value has been assigned to Placement_method data member.
Definition: Clone_ref_.hpp:587
CSeq_feat_Base::GetComment
const TComment & GetComment(void) const
Get the Comment member data.
Definition: Seq_feat_.hpp:1049
CClone_ref_Base::IsSetName
bool IsSetName(void) const
Official clone symbol Check if a value has been assigned to Name data member.
Definition: Clone_ref_.hpp:393
CClone_ref_Base::GetUnique
TUnique GetUnique(void) const
Get the Unique member data.
Definition: Clone_ref_.hpp:562
CSeqFeatData_Base::GetSite
TSite GetSite(void) const
Get the variant data.
Definition: SeqFeatData_.hpp:999
CClone_seq_set_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Clone_seq_set_.hpp:164
CClone_ref_Base::GetClone_seq
const TClone_seq & GetClone_seq(void) const
Get the Clone_seq member data.
Definition: Clone_ref_.hpp:646
CClone_ref_Base::GetPlacement_method
TPlacement_method GetPlacement_method(void) const
Get the Placement_method member data.
Definition: Clone_ref_.hpp:606
CClone_seq_Base::GetSeq
const TSeq & GetSeq(void) const
Get the Seq member data.
Definition: Clone_seq_.hpp:534
CSeq_feat_Base::TQual
vector< CRef< CGb_qual > > TQual
Definition: Seq_feat_.hpp:117
CGb_qual_Base::GetQual
const TQual & GetQual(void) const
Get the Qual member data.
Definition: Gb_qual_.hpp:212
CSeq_feat_Base::IsSetProduct
bool IsSetProduct(void) const
product of process Check if a value has been assigned to Product data member.
Definition: Seq_feat_.hpp:1084
CSeqFeatData_Base::GetVariation
const TVariation & GetVariation(void) const
Get the variant data.
Definition: SeqFeatData_.cpp:592
CSeqFeatData_Base::IsRna
bool IsRna(void) const
Check if variant Rna is selected.
Definition: SeqFeatData_.hpp:910
CClone_seq_Base::CanGetSupport
bool CanGetSupport(void) const
Check if it is safe to call GetSupport method.
Definition: Clone_seq_.hpp:570
CSeqFeatData_Base::IsRegion
bool IsRegion(void) const
Check if variant Region is selected.
Definition: SeqFeatData_.hpp:934
CSeq_feat_Base::CanGetTitle
bool CanGetTitle(void) const
Check if it is safe to call GetTitle method.
Definition: Seq_feat_.hpp:1166
CSeqFeatData_Base::GetImp
const TImp & GetImp(void) const
Get the variant data.
Definition: SeqFeatData_.cpp:420
CClone_ref_Base::IsSetClone_seq
bool IsSetClone_seq(void) const
Check if a value has been assigned to Clone_seq data member.
Definition: Clone_ref_.hpp:634
CSeq_feat_Base::CanGetComment
bool CanGetComment(void) const
Check if it is safe to call GetComment method.
Definition: Seq_feat_.hpp:1043
CClone_seq_Base::eSupport_supporting
@ eSupport_supporting
sequence supports placement
Definition: Clone_seq_.hpp:113
CClone_seq_Base::eSupport_supports_other
@ eSupport_supports_other
supports a different placement
Definition: Clone_seq_.hpp:114
CClone_seq_Base::eSupport_prototype
@ eSupport_prototype
sequence used to place clone
Definition: Clone_seq_.hpp:112
CClone_seq_Base::eSupport_non_supporting
@ eSupport_non_supporting
does not support any placement
Definition: Clone_seq_.hpp:115
CSeqFeatData_Base::eSite_other
@ eSite_other
Definition: SeqFeatData_.hpp:141
CTextseq_id_Base::IsSetAccession
bool IsSetAccession(void) const
Check if a value has been assigned to Accession data member.
Definition: Textseq_id_.hpp:328
CPacked_seqint_Base::Tdata
list< CRef< CSeq_interval > > Tdata
Definition: Packed_seqint_.hpp:89
ENa_strand
ENa_strand
strand of nucleic acid
Definition: Na_strand_.hpp:64
CPacked_seqint_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Packed_seqint_.hpp:164
CSeq_interval_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Seq_interval_.hpp:517
CSeq_loc_Base::GetPnt
const TPnt & GetPnt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:238
CSeq_point_Base::GetPoint
TPoint GetPoint(void) const
Get the Point member data.
Definition: Seq_point_.hpp:303
CSeq_loc_Base::GetWhole
const TWhole & GetWhole(void) const
Get the variant data.
Definition: Seq_loc_.cpp:172
CSeq_interval_Base::GetFrom
TFrom GetFrom(void) const
Get the From member data.
Definition: Seq_interval_.hpp:383
CSeq_id_Base::IsGeneral
bool IsGeneral(void) const
Check if variant General is selected.
Definition: Seq_id_.hpp:877
CSeq_loc_mix_Base::Tdata
list< CRef< CSeq_loc > > Tdata
Definition: Seq_loc_mix_.hpp:90
CSeq_loc_Base::Which
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_loc_.hpp:475
CSeq_point_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Seq_point_.hpp:390
CSeq_loc_mix_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Seq_loc_mix_.hpp:165
CSeq_loc_Base::GetPacked_pnt
const TPacked_pnt & GetPacked_pnt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:260
CPacked_seqpnt_Base::TPoints
vector< TSeqPos > TPoints
Definition: Packed_seqpnt_.hpp:94
CSeq_id_Base::GetLocal
const TLocal & GetLocal(void) const
Get the variant data.
Definition: Seq_id_.cpp:193
CSeq_interval_Base::IsSetStrand
bool IsSetStrand(void) const
Check if a value has been assigned to Strand data member.
Definition: Seq_interval_.hpp:458
CSeq_id_Base::IsLocal
bool IsLocal(void) const
Check if variant Local is selected.
Definition: Seq_id_.hpp:775
CPacked_seqpnt_Base::GetPoints
const TPoints & GetPoints(void) const
Get the Points member data.
Definition: Packed_seqpnt_.hpp:388
CSeq_interval_Base::GetStrand
TStrand GetStrand(void) const
Get the Strand member data.
Definition: Seq_interval_.hpp:477
CSeq_id_Base::GetGeneral
const TGeneral & GetGeneral(void) const
Get the variant data.
Definition: Seq_id_.cpp:369
CSeq_id_Base::IsGi
bool IsGi(void) const
Check if variant Gi is selected.
Definition: Seq_id_.hpp:883
CSeq_interval_Base::GetTo
TTo GetTo(void) const
Get the To member data.
Definition: Seq_interval_.hpp:430
CSeq_loc_Base::GetInt
const TInt & GetInt(void) const
Get the variant data.
Definition: Seq_loc_.cpp:194
CSeq_loc_Base::GetMix
const TMix & GetMix(void) const
Get the variant data.
Definition: Seq_loc_.cpp:282
CSeq_loc_Base::GetPacked_int
const TPacked_int & GetPacked_int(void) const
Get the variant data.
Definition: Seq_loc_.cpp:216
CTextseq_id_Base::GetAccession
const TAccession & GetAccession(void) const
Get the Accession member data.
Definition: Textseq_id_.hpp:340
eNa_strand_plus
@ eNa_strand_plus
Definition: Na_strand_.hpp:66
eNa_strand_minus
@ eNa_strand_minus
Definition: Na_strand_.hpp:67
eNa_strand_unknown
@ eNa_strand_unknown
Definition: Na_strand_.hpp:65
CSeq_id_Base::e_not_set
@ e_not_set
No variant selected.
Definition: Seq_id_.hpp:94
CSeq_loc_Base::e_Pnt
@ e_Pnt
Definition: Seq_loc_.hpp:103
CSeq_loc_Base::e_Packed_pnt
@ e_Packed_pnt
Definition: Seq_loc_.hpp:104
CSeq_loc_Base::e_Null
@ e_Null
not placed
Definition: Seq_loc_.hpp:98
CSeq_loc_Base::e_Packed_int
@ e_Packed_int
Definition: Seq_loc_.hpp:102
CSeq_loc_Base::e_Mix
@ e_Mix
Definition: Seq_loc_.hpp:105
CSeq_loc_Base::e_Int
@ e_Int
from to
Definition: Seq_loc_.hpp:101
CSeq_loc_Base::e_Whole
@ e_Whole
whole sequence
Definition: Seq_loc_.hpp:100
CSeq_entry_Base::GetSeq
const TSeq & GetSeq(void) const
Get the variant data.
Definition: Seq_entry_.cpp:102
CBioseq_set_Base::GetClass
TClass GetClass(void) const
Get the Class member data.
Definition: Bioseq_set_.hpp:630
CSeq_entry_Base::GetSet
const TSet & GetSet(void) const
Get the variant data.
Definition: Seq_entry_.cpp:124
CSeq_entry_Base::IsSet
bool IsSet(void) const
Check if variant Set is selected.
Definition: Seq_entry_.hpp:263
CBioseq_set_Base::GetSeq_set
const TSeq_set & GetSeq_set(void) const
Get the Seq_set member data.
Definition: Bioseq_set_.hpp:756
CBioseq_set_Base::TSeq_set
list< CRef< CSeq_entry > > TSeq_set
Definition: Bioseq_set_.hpp:136
CBioseq_set_Base::eClass_equiv
@ eClass_equiv
a set of equivalent maps or seqs
Definition: Bioseq_set_.hpp:108
CBioseq_set_Base::eClass_parts
@ eClass_parts
parts for 2 or 3
Definition: Bioseq_set_.hpp:102
CBioseq_set_Base::eClass_pop_set
@ eClass_pop_set
population study
Definition: Bioseq_set_.hpp:112
CBioseq_set_Base::eClass_other
@ eClass_other
Definition: Bioseq_set_.hpp:122
CBioseq_set_Base::eClass_phy_set
@ eClass_phy_set
phylogenetic study
Definition: Bioseq_set_.hpp:113
CBioseq_set_Base::eClass_not_set
@ eClass_not_set
Definition: Bioseq_set_.hpp:98
CBioseq_set_Base::eClass_conset
@ eClass_conset
constructed sequence + parts
Definition: Bioseq_set_.hpp:101
CBioseq_set_Base::eClass_gi
@ eClass_gi
geninfo
Definition: Bioseq_set_.hpp:104
CBioseq_set_Base::eClass_wgs_set
@ eClass_wgs_set
whole genome shotgun project
Definition: Bioseq_set_.hpp:116
CBioseq_set_Base::eClass_mut_set
@ eClass_mut_set
set of mutations
Definition: Bioseq_set_.hpp:111
CBioseq_set_Base::eClass_pir
@ eClass_pir
converted pir
Definition: Bioseq_set_.hpp:106
CBioseq_set_Base::eClass_eco_set
@ eClass_eco_set
ecological sample study
Definition: Bioseq_set_.hpp:114
CBioseq_set_Base::eClass_nuc_prot
@ eClass_nuc_prot
nuc acid and coded proteins
Definition: Bioseq_set_.hpp:99
CBioseq_set_Base::eClass_gibb
@ eClass_gibb
geninfo backbone
Definition: Bioseq_set_.hpp:103
CBioseq_set_Base::eClass_gen_prod_set
@ eClass_gen_prod_set
genomic products, chrom+mRNA+protein
Definition: Bioseq_set_.hpp:115
CBioseq_set_Base::eClass_pdb_entry
@ eClass_pdb_entry
a complete PDB entry
Definition: Bioseq_set_.hpp:110
CBioseq_set_Base::eClass_genbank
@ eClass_genbank
converted genbank
Definition: Bioseq_set_.hpp:105
CBioseq_set_Base::eClass_swissprot
@ eClass_swissprot
converted SWISSPROT
Definition: Bioseq_set_.hpp:109
CBioseq_set_Base::eClass_segset
@ eClass_segset
segmented sequence + parts
Definition: Bioseq_set_.hpp:100
CBioseq_set_Base::eClass_pub_set
@ eClass_pub_set
all the seqs from a single publication
Definition: Bioseq_set_.hpp:107
CAnnot_descr_Base::Get
const Tdata & Get(void) const
Get the member data.
Definition: Annot_descr_.hpp:164
CSeq_annot_Base::C_Data::GetGraph
const TGraph & GetGraph(void) const
Get the variant data.
Definition: Seq_annot_.hpp:661
CSeq_annot_Base::C_Data::GetLocs
const TLocs & GetLocs(void) const
Get the variant data.
Definition: Seq_annot_.hpp:701
CBioseq_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Bioseq_.hpp:290
CSeq_annot_Base::C_Data::TAlign
list< CRef< CSeq_align > > TAlign
Definition: Seq_annot_.hpp:194
CSeq_annot_Base::C_Data::GetIds
const TIds & GetIds(void) const
Get the variant data.
Definition: Seq_annot_.hpp:681
CSeq_annot_Base::GetDesc
const TDesc & GetDesc(void) const
Get the Desc member data.
Definition: Seq_annot_.hpp:852
CSeq_annot_Base::IsSetDesc
bool IsSetDesc(void) const
used only for stand alone Seq-annots Check if a value has been assigned to Desc data member.
Definition: Seq_annot_.hpp:840
CSeq_annot_Base::C_Data::GetAlign
const TAlign & GetAlign(void) const
Get the variant data.
Definition: Seq_annot_.hpp:641
CSeq_annot_Base::C_Data::GetFtable
const TFtable & GetFtable(void) const
Get the variant data.
Definition: Seq_annot_.hpp:621
CSeq_annot_Base::GetData
const TData & GetData(void) const
Get the Data member data.
Definition: Seq_annot_.hpp:873
CSeq_annot_Base::C_Data::Which
E_Choice Which(void) const
Which variant is currently selected.
Definition: Seq_annot_.hpp:586
CAnnot_descr_Base::Tdata
list< CRef< CAnnotdesc > > Tdata
Definition: Annot_descr_.hpp:89
CSeq_annot_Base::C_Data::e_Ids
@ e_Ids
used for communication between tools
Definition: Seq_annot_.hpp:136
CSeq_annot_Base::C_Data::e_Align
@ e_Align
Definition: Seq_annot_.hpp:134
CSeq_annot_Base::C_Data::e_Seq_table
@ e_Seq_table
Definition: Seq_annot_.hpp:138
CSeq_annot_Base::C_Data::e_Ftable
@ e_Ftable
Definition: Seq_annot_.hpp:133
CSeq_annot_Base::C_Data::e_Graph
@ e_Graph
Definition: Seq_annot_.hpp:135
CSeq_annot_Base::C_Data::e_Locs
@ e_Locs
used for communication between tools
Definition: Seq_annot_.hpp:137
CAnnotdesc_Base::e_Name
@ e_Name
a short name for this collection
Definition: Annotdesc_.hpp:97
CAnnotdesc_Base::e_Title
@ e_Title
a title for this collection
Definition: Annotdesc_.hpp:98
CValidErrItem_Base::CanGetAccession
bool CanGetAccession(void) const
Check if it is safe to call GetAccession method.
Definition: ValidErrItem_.hpp:1033
CValidErrItem_Base::GetAccession
const TAccession & GetAccession(void) const
Get the Accession member data.
Definition: ValidErrItem_.hpp:1039
CVariation_Base::CanGetOther_ids
bool CanGetOther_ids(void) const
Check if it is safe to call GetOther_ids method.
Definition: Variation_.hpp:2733
CVariation_Base::CanGetId
bool CanGetId(void) const
Check if it is safe to call GetId method.
Definition: Variation_.hpp:2666
CVariation_Base::GetOther_ids
const TOther_ids & GetOther_ids(void) const
Get the Other_ids member data.
Definition: Variation_.hpp:2739
CVariation_Base::GetDescription
const TDescription & GetDescription(void) const
Get the Description member data.
Definition: Variation_.hpp:2836
CVariation_Base::CanGetDescription
bool CanGetDescription(void) const
Check if it is safe to call GetDescription method.
Definition: Variation_.hpp:2830
CVariation_Base::TOther_ids
list< CRef< CDbtag > > TOther_ids
Definition: Variation_.hpp:1217
CVariation_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Variation_.hpp:2672
CVariation_ref_Base::C_Data::GetInstance
const TInstance & GetInstance(void) const
Get the variant data.
Definition: Variation_ref_.cpp:257
CVariation_ref_Base::GetVariant_prop
const TVariant_prop & GetVariant_prop(void) const
Get the Variant_prop member data.
Definition: Variation_ref_.hpp:3166
CVariation_ref_Base::TAllele_origin
int TAllele_origin
Definition: Variation_ref_.hpp:1293
CVariation_ref_Base::CanGetConsequence
bool CanGetConsequence(void) const
Check if it is safe to call GetConsequence method.
Definition: Variation_ref_.hpp:3492
CVariation_ref_Base::CanGetMethod
bool CanGetMethod(void) const
Check if it is safe to call GetMethod method.
Definition: Variation_ref_.hpp:3110
CVariation_inst_Base::IsSetDelta
bool IsSetDelta(void) const
Sequence that replaces the location, in biological order.
Definition: Variation_inst_.hpp:325
CVariation_ref_Base::IsSetVariant_prop
bool IsSetVariant_prop(void) const
variant properties bit fields Check if a value has been assigned to Variant_prop data member.
Definition: Variation_ref_.hpp:3154
CVariation_ref_Base::TPhenotype
list< CRef< CPhenotype > > TPhenotype
Definition: Variation_ref_.hpp:1287
CVariantProperties_Base::IsSetAllele_origin
bool IsSetAllele_origin(void) const
Check if a value has been assigned to Allele_origin data member.
Definition: VariantProperties_.hpp:1506
CVariation_ref_Base::GetId
const TId & GetId(void) const
Get the Id member data.
Definition: Variation_ref_.hpp:2884
CVariation_inst_Base::GetDelta
const TDelta & GetDelta(void) const
Get the Delta member data.
Definition: Variation_inst_.hpp:337
CVariation_ref_Base::TSomatic_origin
list< CRef< C_E_Somatic_origin > > TSomatic_origin
Definition: Variation_ref_.hpp:1304
CVariation_ref_Base::GetData
const TData & GetData(void) const
Get the Data member data.
Definition: Variation_ref_.hpp:3468
CVariation_ref_Base::GetPhenotype
const TPhenotype & GetPhenotype(void) const
Get the Phenotype member data.
Definition: Variation_ref_.hpp:3091
CVariation_ref_Base::CanGetSomatic_origin
bool CanGetSomatic_origin(void) const
Check if it is safe to call GetSomatic_origin method.
Definition: Variation_ref_.hpp:3584
CVariation_ref_Base::C_Data::IsInstance
bool IsInstance(void) const
Check if variant Instance is selected.
Definition: Variation_ref_.hpp:2455
CVariantProperties_Base::GetOther_validation
TOther_validation GetOther_validation(void) const
Get the Other_validation member data.
Definition: VariantProperties_.hpp:1478
CVariation_ref_Base::TConsequence
list< CRef< C_E_Consequence > > TConsequence
Definition: Variation_ref_.hpp:1300
CVariation_ref_Base::GetSomatic_origin
const TSomatic_origin & GetSomatic_origin(void) const
Get the Somatic_origin member data.
Definition: Variation_ref_.hpp:3590
CVariation_ref_Base::GetConsequence
const TConsequence & GetConsequence(void) const
Get the Consequence member data.
Definition: Variation_ref_.hpp:3498
CVariation_ref_Base::GetParent_id
const TParent_id & GetParent_id(void) const
Get the Parent_id member data.
Definition: Variation_ref_.hpp:2905
CVariation_inst_Base::TDelta
list< CRef< CDelta_item > > TDelta
Definition: Variation_inst_.hpp:131
CVariantProperties_Base::IsSetOther_validation
bool IsSetOther_validation(void) const
has this variant been validated? While a boolean flag offers no subtle distinctions of validation met...
Definition: VariantProperties_.hpp:1459
CVariation_ref_Base::CanGetParent_id
bool CanGetParent_id(void) const
Check if it is safe to call GetParent_id method.
Definition: Variation_ref_.hpp:2899
CVariation_ref_Base::TMethod
list< int > TMethod
Definition: Variation_ref_.hpp:1288
CVariation_ref_Base::IsSetId
bool IsSetId(void) const
ids (i.e., SNP rsid / ssid, dbVar nsv/nssv) expected values include 'dbSNP|rs12334',...
Definition: Variation_ref_.hpp:2872
CVariation_ref_Base::CanGetPhenotype
bool CanGetPhenotype(void) const
Check if it is safe to call GetPhenotype method.
Definition: Variation_ref_.hpp:3085
CVariation_ref_Base::CanGetId
bool CanGetId(void) const
Check if it is safe to call GetId method.
Definition: Variation_ref_.hpp:2878
CVariation_ref_Base::GetMethod
const TMethod & GetMethod(void) const
Get the Method member data.
Definition: Variation_ref_.hpp:3116
CVariantProperties_Base::GetAllele_origin
TAllele_origin GetAllele_origin(void) const
Get the Allele_origin member data.
Definition: VariantProperties_.hpp:1525
CVariation_ref_Base::eMethod_E_unknown
@ eMethod_E_unknown
Definition: Variation_ref_.hpp:101
CVariation_ref_Base::eMethod_E_optical_mapping
@ eMethod_E_optical_mapping
Definition: Variation_ref_.hpp:127
CVariation_ref_Base::eMethod_E_sequencing
@ eMethod_E_sequencing
Definition: Variation_ref_.hpp:122
CVariation_ref_Base::eMethod_E_mcd_analysis
@ eMethod_E_mcd_analysis
Definition: Variation_ref_.hpp:110
CVariation_ref_Base::eMethod_E_maph
@ eMethod_E_maph
Definition: Variation_ref_.hpp:109
CVariation_ref_Base::eAllele_origin_de_novo
@ eAllele_origin_de_novo
Definition: Variation_ref_.hpp:145
CVariation_ref_Base::eAllele_origin_not_tested
@ eAllele_origin_not_tested
Definition: Variation_ref_.hpp:148
CVariation_ref_Base::eAllele_origin_paternal
@ eAllele_origin_paternal
Definition: Variation_ref_.hpp:143
CVariation_ref_Base::eAllele_origin_somatic
@ eAllele_origin_somatic
Definition: Variation_ref_.hpp:141
CVariation_ref_Base::eAllele_origin_tested_inconclusive
@ eAllele_origin_tested_inconclusive
Definition: Variation_ref_.hpp:149
CVariation_ref_Base::eAllele_origin_biparental
@ eAllele_origin_biparental
Definition: Variation_ref_.hpp:146
CVariation_ref_Base::eAllele_origin_uniparental
@ eAllele_origin_uniparental
Definition: Variation_ref_.hpp:147
CVariation_ref_Base::eAllele_origin_maternal
@ eAllele_origin_maternal
Definition: Variation_ref_.hpp:144
CVariation_ref_Base::eAllele_origin_unknown
@ eAllele_origin_unknown
Definition: Variation_ref_.hpp:139
CVariation_ref_Base::eAllele_origin_inherited
@ eAllele_origin_inherited
Definition: Variation_ref_.hpp:142
CVariation_ref_Base::eAllele_origin_other
@ eAllele_origin_other
stopper - 2^31
Definition: Variation_ref_.hpp:150
USING_SCOPE
USING_SCOPE(objects)
s_GetBioseq_setType
static void s_GetBioseq_setType(const CBioseq_set &bst, string *label)
Definition: label.cpp:1021
s_GetAlignmentTooltip
static void s_GetAlignmentTooltip(const CSeq_align &align, string *label, CScope *scope)
Definition: label.cpp:2444
s_BreakSeq_loc
static void s_BreakSeq_loc(const CSeq_loc &loc, vector< CRef< CSeq_loc > > &locs, CScope *scope)
Definition: label.cpp:700
s_GetDefline
static void s_GetDefline(const CSeq_id &id, CScope *scope, string *label)
Definition: label.cpp:416
s_GetCachedDescription
static void s_GetCachedDescription(const CSeq_id &id, CScope *scope, string *label)
Definition: label.cpp:430
s_DFLock
static CFastMutex s_DFLock
Definition: label.cpp:412
s_GetAnnotContent
static void s_GetAnnotContent(const CSeq_annot &annot, string *label, CScope *scope)
Definition: label.cpp:2817
DEFINE_STATIC_MUTEX
DEFINE_STATIC_MUTEX(sm_Mutex)
s_GetSeq_TotalRangeLabel
static void s_GetSeq_TotalRangeLabel(const CSeq_loc &loc, string *label, CScope *scope, CLabel::ELabelType type)
Definition: label.cpp:610
s_DefGen
static sequence::CDeflineGenerator s_DefGen
This class seems to be non-thread safe even as a stack var.
Definition: label.cpp:413
s_IsCopyNumberMethod
static bool s_IsCopyNumberMethod(const CVariation_ref::TMethod &method)
Definition: label.cpp:1411
s_GetLabel
static const CSeq_id * s_GetLabel(const CSeq_loc &loc, string *label, CScope *scope, CLabel::ELabelType type, const CSeq_id *last_id=NULL)
Definition: label.cpp:731
s_GetBioseq_setContent
static void s_GetBioseq_setContent(const CBioseq_set &bst, string *label, CScope *scope)
Definition: label.cpp:1148
s_GetSeq_intervalLabel
static void s_GetSeq_intervalLabel(const CSeq_interval &interval, string *label, CScope *scope, CLabel::ELabelType type, const CSeq_id *last_id=NULL)
Definition: label.cpp:558
s_GetGenProdContent
static void s_GetGenProdContent(const CBioseq_set &bst, string *label, CScope *scope)
Definition: label.cpp:1138
s_GetAlignmentContent
static void s_GetAlignmentContent(const CSeq_align &align, string *label, CScope *scope)
Definition: label.cpp:2332
s_GetNucProtContent
static void s_GetNucProtContent(const CBioseq_set &bst, string *label, CScope *scope)
Definition: label.cpp:1117
s_GetIdLabel
static void s_GetIdLabel(const CBioseq_set &bst, string *label, CScope *scope)
Definition: label.cpp:1057
s_GetChildNum
static int s_GetChildNum(const objects::CSeq_feat &feat)
Definition: label.cpp:1384
s_GetSeqLabel
static void s_GetSeqLabel(const CSeq_id &id, string *label, CScope *scope, CLabel::ELabelType type)
Definition: label.cpp:492
s_HasAlignment
static bool s_HasAlignment(const CBioseq_set &bst, CScope *scope)
Definition: label.cpp:1185
s_IsLOH
static bool s_IsLOH(const CVariation_ref &var)
Definition: label.cpp:1398
sm_ForceRegistration
static SForceRegister sm_ForceRegistration
Definition: label.cpp:3640
s_DescrCachePtr
static std::unique_ptr< CLabelDescriptionCacheImpl > s_DescrCachePtr
Definition: label.cpp:370
s_CountSegments
static size_t s_CountSegments(const CSeq_align &align)
Definition: label.cpp:2428
s_GetAlignmentType
static void s_GetAlignmentType(const CSeq_align &align, string *label)
Definition: label.cpp:2306
s_GetAnnotType
static void s_GetAnnotType(const CSeq_annot &annot, string *label)
Definition: label.cpp:2787
s_GetGi
static TGi s_GetGi(const CSeq_id &id, CScope *scope)
Definition: label.cpp:387
s_GetSegsetContent
static void s_GetSegsetContent(const CBioseq_set &bst, string *label, CScope *scope)
Def