开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
bioseq_handle.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：27k
源码类别：

生物技术

开发平台：

C/C++

bioseq_handle.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: bioseq_handle.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:22:54  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.66
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: bioseq_handle.cpp,v 1000.5 2004/06/01 19:22:54 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author: Aleksey Grichenko, Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *
  39. */
  41. #include <ncbi_pch.hpp>
  42. #include <objmgr/bioseq_handle.hpp>
  43. #include <objmgr/seq_annot_handle.hpp>
  44. #include <objmgr/seq_entry_handle.hpp>
  46. #include <objmgr/impl/scope_impl.hpp>
  48. #include <objmgr/seq_vector.hpp>
  49. #include <objmgr/seqmatch_info.hpp>
  51. #include <objmgr/impl/data_source.hpp>
  52. #include <objmgr/impl/tse_info.hpp>
  53. #include <objmgr/impl/handle_range.hpp>
  54. #include <objmgr/impl/bioseq_info.hpp>
  55. #include <objmgr/impl/seq_entry_info.hpp>
  56. #include <objmgr/impl/bioseq_set_info.hpp>
  57. #include <objmgr/impl/tse_info.hpp>
  58. #include <objmgr/impl/synonyms.hpp>
  59. #include <objmgr/seq_loc_mapper.hpp>
  61. #include <objects/general/Object_id.hpp>
  62. #include <objects/seqloc/Seq_loc.hpp>
  63. #include <objects/seqloc/Seq_interval.hpp>
  64. #include <objects/seqloc/Seq_point.hpp>
  65. #include <objects/seqloc/Seq_id.hpp>
  67. #include <objects/seq/Bioseq.hpp>
  68. #include <objects/seqset/Seq_entry.hpp>
  71. BEGIN_NCBI_SCOPE
  72. BEGIN_SCOPE(objects)
  74. /////////////////////////////////////////////////////////////////////////////
  75. // CBioseq_Handle
  76. /////////////////////////////////////////////////////////////////////////////
  78. CBioseq_Handle::CBioseq_Handle(const CSeq_id_Handle& id,
  79.                                CBioseq_ScopeInfo* bioseq_info)
  80.     : m_Seq_id(id),
  81.       m_Bioseq_Info(bioseq_info)
  82. {
  83. }
  86. bool CBioseq_Handle::operator==(const CBioseq_Handle& h) const
  87. {
  88.     if ( m_Scope != m_Scope ) {
  89.         return false;
  90.     }
  91.     if ( *this && h )
  92.         return &x_GetInfo() == &h.x_GetInfo();
  93.     // Compare by id key
  94.     return GetSeq_id_Handle() == h.GetSeq_id_Handle();
  95. }
  98. bool CBioseq_Handle::operator< (const CBioseq_Handle& h) const
  99. {
  100.     if ( m_Scope != h.m_Scope ) {
  101.         return m_Scope < h.m_Scope;
  102.     }
  103.     if ( *this && h )
  104.         return &x_GetInfo() < &h.x_GetInfo();
  105.     return GetSeq_id_Handle() < h.GetSeq_id_Handle();
  106. }
  109. const CBioseq_Info& CBioseq_Handle::x_GetInfo(void) const
  110. {
  111.     return x_GetScopeInfo().GetBioseq_Info();
  112. }
  115. CConstRef<CSeq_id> CBioseq_Handle::GetSeqId(void) const
  116. {
  117.     return GetSeq_id_Handle().GetSeqIdOrNull();
  118. }
  121. CConstRef<CBioseq> CBioseq_Handle::GetCompleteBioseq(void) const
  122. {
  123.     return x_GetInfo().GetCompleteBioseq();
  124. }
  127. const CBioseq& CBioseq_Handle::GetBioseq(void) const
  128. {
  129.     ERR_POST_ONCE(Warning<<
  130.                   "CBioseq_Handle::GetBioseq() is deprecated, "
  131.                   "use GetCompleteBioseq() or GetBioseqCore().");
  132.     return *GetCompleteBioseq();
  133. }
  136. const CSeq_entry& CBioseq_Handle::GetTopLevelSeqEntry(void) const
  137. {
  138.     ERR_POST_ONCE(Warning<<
  139.                   "CBioseq_Handle::GetTopLevelSeqEntry() is deprecated, "
  140.                   "use GetTopLevelEntry().");
  141.     return *GetTopLevelEntry().GetCompleteSeq_entry();
  142. }
  145. CBioseq_Handle::TBioseqCore CBioseq_Handle::GetBioseqCore(void) const
  146. {
  147.     return x_GetInfo().GetBioseqCore();
  148. }
  151. CBioseq_EditHandle CBioseq_Handle::GetEditHandle(void) const
  152. {
  153.     return m_Scope->GetEditHandle(*this);
  154. }
  157. /////////////////////////////////////////////////////////////////////////////
  158. // Bioseq members
  160. bool CBioseq_Handle::IsSetId(void) const
  161. {
  162.     return x_GetInfo().IsSetId();
  163. }
  166. bool CBioseq_Handle::CanGetId(void) const
  167. {
  168.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetId();
  169. }
  172. const CBioseq_Handle::TId& CBioseq_Handle::GetId(void) const
  173. {
  174.     return x_GetInfo().GetId();
  175. }
  178. bool CBioseq_Handle::IsSetDescr(void) const
  179. {
  180.     return x_GetInfo().IsSetDescr();
  181. }
  184. bool CBioseq_Handle::CanGetDescr(void) const
  185. {
  186.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetDescr();
  187. }
  190. const CSeq_descr& CBioseq_Handle::GetDescr(void) const
  191. {
  192.     return x_GetInfo().GetDescr();
  193. }
  196. bool CBioseq_Handle::IsSetInst(void) const
  197. {
  198.     return x_GetInfo().IsSetInst();
  199. }
  202. bool CBioseq_Handle::CanGetInst(void) const
  203. {
  204.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst();
  205. }
  208. const CSeq_inst& CBioseq_Handle::GetInst(void) const
  209. {
  210.     return x_GetInfo().GetInst();
  211. }
  214. bool CBioseq_Handle::IsSetInst_Repr(void) const
  215. {
  216.     return x_GetInfo().IsSetInst_Repr();
  217. }
  220. bool CBioseq_Handle::CanGetInst_Repr(void) const
  221. {
  222.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Repr();
  223. }
  226. CBioseq_Handle::TInst_Repr CBioseq_Handle::GetInst_Repr(void) const
  227. {
  228.     return x_GetInfo().GetInst_Repr();
  229. }
  232. bool CBioseq_Handle::IsSetInst_Mol(void) const
  233. {
  234.     return x_GetInfo().IsSetInst_Mol();
  235. }
  238. bool CBioseq_Handle::CanGetInst_Mol(void) const
  239. {
  240.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Mol();
  241. }
  244. CBioseq_Handle::TInst_Mol CBioseq_Handle::GetInst_Mol(void) const
  245. {
  246.     return x_GetInfo().GetInst_Mol();
  247. }
  250. bool CBioseq_Handle::IsSetInst_Length(void) const
  251. {
  252.     return x_GetInfo().IsSetInst_Length();
  253. }
  256. bool CBioseq_Handle::CanGetInst_Length(void) const
  257. {
  258.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Length();
  259. }
  262. CBioseq_Handle::TInst_Length CBioseq_Handle::GetInst_Length(void) const
  263. {
  264.     return x_GetInfo().GetInst_Length();
  265. }
  268. TSeqPos CBioseq_Handle::GetBioseqLength(void) const
  269. {
  270.     return x_GetInfo().GetBioseqLength();
  271. }
  274. bool CBioseq_Handle::IsSetInst_Fuzz(void) const
  275. {
  276.     return x_GetInfo().IsSetInst_Fuzz();
  277. }
  280. bool CBioseq_Handle::CanGetInst_Fuzz(void) const
  281. {
  282.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Fuzz();
  283. }
  286. const CBioseq_Handle::TInst_Fuzz& CBioseq_Handle::GetInst_Fuzz(void) const
  287. {
  288.     return x_GetInfo().GetInst_Fuzz();
  289. }
  292. bool CBioseq_Handle::IsSetInst_Topology(void) const
  293. {
  294.     return x_GetInfo().IsSetInst_Topology();
  295. }
  298. bool CBioseq_Handle::CanGetInst_Topology(void) const
  299. {
  300.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Topology();
  301. }
  304. CBioseq_Handle::TInst_Topology CBioseq_Handle::GetInst_Topology(void) const
  305. {
  306.     return x_GetInfo().GetInst_Topology();
  307. }
  310. bool CBioseq_Handle::IsSetInst_Strand(void) const
  311. {
  312.     return x_GetInfo().IsSetInst_Strand();
  313. }
  316. bool CBioseq_Handle::CanGetInst_Strand(void) const
  317. {
  318.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Strand();
  319. }
  322. CBioseq_Handle::TInst_Strand CBioseq_Handle::GetInst_Strand(void) const
  323. {
  324.     return x_GetInfo().GetInst_Strand();
  325. }
  328. bool CBioseq_Handle::IsSetInst_Seq_data(void) const
  329. {
  330.     return x_GetInfo().IsSetInst_Seq_data();
  331. }
  334. bool CBioseq_Handle::CanGetInst_Seq_data(void) const
  335. {
  336.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Seq_data();
  337. }
  340. const CBioseq_Handle::TInst_Seq_data&
  341. CBioseq_Handle::GetInst_Seq_data(void) const
  342. {
  343.     return x_GetInfo().GetInst_Seq_data();
  344. }
  347. bool CBioseq_Handle::IsSetInst_Ext(void) const
  348. {
  349.     return x_GetInfo().IsSetInst_Ext();
  350. }
  353. bool CBioseq_Handle::CanGetInst_Ext(void) const
  354. {
  355.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Ext();
  356. }
  359. const CBioseq_Handle::TInst_Ext& CBioseq_Handle::GetInst_Ext(void) const
  360. {
  361.     return x_GetInfo().GetInst_Ext();
  362. }
  365. bool CBioseq_Handle::IsSetInst_Hist(void) const
  366. {
  367.     return x_GetInfo().IsSetInst_Hist();
  368. }
  371. bool CBioseq_Handle::CanGetInst_Hist(void) const
  372. {
  373.     return bool(m_Bioseq_Info)  &&  x_GetInfo().CanGetInst_Hist();
  374. }
  377. const CBioseq_Handle::TInst_Hist& CBioseq_Handle::GetInst_Hist(void) const
  378. {
  379.     return x_GetInfo().GetInst_Hist();
  380. }
  383. bool CBioseq_Handle::HasAnnots(void) const
  384. {
  385.     return x_GetInfo().HasAnnots();
  386. }
  389. // end of Bioseq members
  390. /////////////////////////////////////////////////////////////////////////////
  393. CSeq_inst::TMol CBioseq_Handle::GetBioseqMolType(void) const
  394. {
  395.     return x_GetInfo().GetInst_Mol();
  396. }
  399. const CSeqMap& CBioseq_Handle::GetSeqMap(void) const
  400. {
  401.     return x_GetInfo().GetSeqMap();
  402. }
  405. CSeqVector CBioseq_Handle::GetSeqVector(EVectorCoding coding,
  406.                                         ENa_strand strand) const
  407. {
  408.     return CSeqVector(GetSeqMap(), GetScope(), coding, strand);
  409. }
  412. CSeqVector CBioseq_Handle::GetSeqVector(ENa_strand strand) const
  413. {
  414.     return CSeqVector(GetSeqMap(), GetScope(), eCoding_Ncbi, strand);
  415. }
  418. CSeqVector CBioseq_Handle::GetSeqVector(EVectorCoding coding,
  419.                                         EVectorStrand strand) const
  420. {
  421.     return CSeqVector(GetSeqMap(), GetScope(), coding,
  422.                       strand == eStrand_Minus?
  423.                       eNa_strand_minus: eNa_strand_plus);
  424. }
  427. CSeqVector CBioseq_Handle::GetSeqVector(EVectorStrand strand) const
  428. {
  429.     return CSeqVector(GetSeqMap(), GetScope(), eCoding_Ncbi,
  430.                       strand == eStrand_Minus?
  431.                       eNa_strand_minus: eNa_strand_plus);
  432. }
  435. CConstRef<CSynonymsSet> CBioseq_Handle::GetSynonyms(void) const
  436. {
  437.     if ( !*this ) {
  438.         return CConstRef<CSynonymsSet>();
  439.     }
  440.     return GetScope().GetSynonyms(*this);
  441. }
  444. bool CBioseq_Handle::IsSynonym(const CSeq_id& id) const
  445. {
  446.     CConstRef<CSynonymsSet> syns = GetSynonyms();
  447.     return bool(syns) && syns->ContainsSynonym(CSeq_id_Handle::GetHandle(id));
  448. }
  451. CSeqVector CBioseq_Handle::GetSequenceView(const CSeq_loc& location,
  452.                                            ESequenceViewMode mode,
  453.                                            EVectorCoding coding,
  454.                                            ENa_strand strand) const
  455. {
  456.     if ( mode != eViewConstructed )
  457.         strand = eNa_strand_unknown;
  458.     return CSeqVector(GetSeqMapByLocation(location, mode), GetScope(),
  459.                       coding, strand);
  460. }
  463. CConstRef<CSeqMap>
  464. CBioseq_Handle::GetSeqMapByLocation(const CSeq_loc& loc,
  465.                                     ESequenceViewMode mode) const
  466. {
  467.     CConstRef<CSeqMap> ret;
  468.     if ( mode == eViewConstructed ) {
  469.         ret = CSeqMap::CreateSeqMapForSeq_loc(loc, &GetScope());
  470.     }
  471.     else {
  472.         // Parse the location
  473.         CHandleRange rlist;      // all intervals pointing to the sequence
  474.         CSeq_loc_CI loc_it(loc);
  475.         for ( ; loc_it; ++loc_it) {
  476.             if ( !IsSynonym(loc_it.GetSeq_id()) )
  477.                 continue;
  478.             rlist.AddRange(loc_it.GetRange(), loc_it.GetStrand());
  479.         }
  481.         // Make mode-dependent parsing of the range list
  482.         CHandleRange mode_rlist; // processed intervals (merged, excluded)
  483.         switch (mode) {
  484.         case eViewMerged:
  485.         {
  486.             // Merge intervals from "rlist"
  487.             ITERATE (CHandleRange, rit, rlist) {
  488.                 mode_rlist.MergeRange(rit->first, rit->second);
  489.             }
  490.             break;
  491.         }
  492.         case eViewExcluded:
  493.         {
  494.             // Exclude intervals from "rlist"
  495.             TSeqPos last_from = 0;
  496.             ITERATE (CHandleRange, rit, rlist) {
  497.                 if (last_from < rit->first.GetFrom()) {
  498.                     mode_rlist.MergeRange(
  499.                         CHandleRange::TRange(last_from, rit->first.GetFrom()-1),
  500.                         eNa_strand_unknown);
  501.                 }
  502.                 if ( !rit->first.IsWholeTo() ) {
  503.                     last_from = rit->first.GetTo()+1;
  504.                 }
  505.                 else {
  506.                     last_from = CHandleRange::TRange::GetWholeTo();
  507.                 }
  508.             }
  509.             TSeqPos total_length = GetSeqMap().GetLength(&GetScope());
  510.             if (last_from < total_length) {
  511.                 mode_rlist.MergeRange(
  512.                     CHandleRange::TRange(last_from, total_length-1),
  513.                     eNa_strand_unknown);
  514.             }
  515.             break;
  516.         }
  517.         default:
  518.             break;
  519.         }
  521.         // Convert ranges to seq-loc
  522.         CRef<CSeq_loc> view_loc(new CSeq_loc);
  523.         ITERATE (CHandleRange, rit, mode_rlist) {
  524.             CRef<CSeq_loc> seg_loc(new CSeq_loc);
  525.             CRef<CSeq_id> id(new CSeq_id);
  526.             id->Assign(*GetSeqId());
  527.             seg_loc->SetInt().SetId(*id);
  528.             seg_loc->SetInt().SetFrom(rit->first.GetFrom());
  529.             seg_loc->SetInt().SetTo(rit->first.GetTo());
  530.             view_loc->SetMix().Set().push_back(seg_loc);
  531.         }
  532.         ret = CSeqMap::CreateSeqMapForSeq_loc(*view_loc, &GetScope());
  533.     }
  534.     return ret;
  535. }
  538. CSeq_entry_Handle CBioseq_Handle::GetTopLevelEntry(void) const
  539. {
  540.     return CSeq_entry_Handle(GetScope(),
  541.                              x_GetInfo().GetTSE_Info());
  542. }
  545. CSeq_entry_Handle CBioseq_Handle::GetParentEntry(void) const
  546. {
  547.     return CSeq_entry_Handle(m_Scope,
  548.                              x_GetInfo().GetParentSeq_entry_Info());
  549. }
  552. CSeq_entry_Handle CBioseq_Handle::GetSeq_entry_Handle(void) const
  553. {
  554.     return GetParentEntry();
  555. }
  559. static int s_Complexity[] = {
  560.     0, // not-set (0)
  561.     3, // nuc-prot (1)
  562.     2, // segset (2)
  563.     2, // conset (3)
  564.     1, // parts (4)
  565.     1, // gibb (5)
  566.     1, // gi (6)
  567.     5, // genbank (7)
  568.     3, // pir (8)
  569.     4, // pub-set (9)
  570.     4, // equiv (10)
  571.     3, // swissprot (11)
  572.     3, // pdb-entry (12)
  573.     4, // mut-set (13)
  574.     4, // pop-set (14)
  575.     4, // phy-set (15)
  576.     4, // eco-set (16)
  577.     4, // gen-prod-set (17)
  578.     4, // wgs-set (18)
  579.     0, // other (255 - processed separately)
  580. };
  583. CSeq_entry_Handle
  584. CBioseq_Handle::GetComplexityLevel(CBioseq_set::EClass cls) const
  585. {
  586.     if (cls == CBioseq_set::eClass_other) {
  587.         // adjust 255 to the correct value
  588.         cls = CBioseq_set::EClass(sizeof(s_Complexity) - 1);
  589.     }
  590.     CSeq_entry_Handle last = GetParentEntry();
  591.     _ASSERT(last && last.IsSeq());
  592.     CSeq_entry_Handle e = last.GetParentEntry();
  593.     while ( e ) {
  594.         _ASSERT(e.IsSet());
  595.         // Found good level
  596.         if ( last.IsSet()  &&
  597.              s_Complexity[last.GetSet().GetClass()] == s_Complexity[cls] )
  598.             break;
  599.         // Gone too high
  600.         if ( s_Complexity[e.GetSet().GetClass()] > s_Complexity[cls] ) {
  601.             break;
  602.         }
  603.         // Go up one level
  604.         last = e;
  605.         e = e.GetParentEntry();
  606.     }
  607.     return last;
  608. }
  611. CSeq_entry_Handle
  612. CBioseq_Handle::GetExactComplexityLevel(CBioseq_set::EClass cls) const
  613. {
  614.     CSeq_entry_Handle ret = GetComplexityLevel(cls);
  615.     if ( ret  &&  
  616.          (!ret.IsSet()  ||  !ret.GetSet().IsSetClass()  ||
  617.          ret.GetSet().GetClass() != cls) ) {
  618.         ret.Reset();
  619.     }
  620.     return ret;
  621. }
  624. CRef<CSeq_loc> CBioseq_Handle::MapLocation(const CSeq_loc& loc) const
  625. {
  626.     CSeq_loc_Mapper mapper(*this);
  627.     return mapper.Map(loc);
  628. }
  631. CBioseq_EditHandle
  632. CBioseq_Handle::CopyTo(const CSeq_entry_EditHandle& entry,
  633.                        int index) const
  634. {
  635.     return entry.CopyBioseq(*this, index);
  636. }
  639. CBioseq_EditHandle
  640. CBioseq_Handle::CopyTo(const CBioseq_set_EditHandle& seqset,
  641.                        int index) const
  642. {
  643.     return seqset.CopyBioseq(*this, index);
  644. }
  647. CBioseq_EditHandle
  648. CBioseq_Handle::CopyToSeq(const CSeq_entry_EditHandle& entry) const
  649. {
  650.     return entry.CopySeq(*this);
  651. }
  654. /////////////////////////////////////////////////////////////////////////////
  655. // CBioseq_EditHandle
  656. /////////////////////////////////////////////////////////////////////////////
  658. CBioseq_EditHandle::CBioseq_EditHandle(void)
  659. {
  660. }
  663. CBioseq_EditHandle::CBioseq_EditHandle(const CBioseq_Handle& h)
  664.     : CBioseq_Handle(h)
  665. {
  666. }
  669. CSeq_entry_EditHandle CBioseq_EditHandle::GetParentEntry(void) const
  670. {
  671.     return CSeq_entry_EditHandle(m_Scope,
  672.                                  x_GetInfo().GetParentSeq_entry_Info());
  673. }
  676. CSeq_annot_EditHandle
  677. CBioseq_EditHandle::AttachAnnot(const CSeq_annot& annot) const
  678. {
  679.     return GetParentEntry().AttachAnnot(annot);
  680. }
  683. CSeq_annot_EditHandle
  684. CBioseq_EditHandle::CopyAnnot(const CSeq_annot_Handle& annot) const
  685. {
  686.     return GetParentEntry().CopyAnnot(annot);
  687. }
  690. CSeq_annot_EditHandle
  691. CBioseq_EditHandle::TakeAnnot(const CSeq_annot_EditHandle& annot) const
  692. {
  693.     return GetParentEntry().TakeAnnot(annot);
  694. }
  697. CBioseq_EditHandle
  698. CBioseq_EditHandle::MoveTo(const CSeq_entry_EditHandle& entry,
  699.                            int index) const
  700. {
  701.     return entry.TakeBioseq(*this, index);
  702. }
  705. CBioseq_EditHandle
  706. CBioseq_EditHandle::MoveTo(const CBioseq_set_EditHandle& seqset,
  707.                                 int index) const
  708. {
  709.     return seqset.TakeBioseq(*this, index);
  710. }
  713. CBioseq_EditHandle
  714. CBioseq_EditHandle::MoveToSeq(const CSeq_entry_EditHandle& entry) const
  715. {
  716.     return entry.TakeSeq(*this);
  717. }
  720. void CBioseq_EditHandle::Remove(void) const
  721. {
  722.     m_Scope->RemoveBioseq(*this);
  723. }
  726. /////////////////////////////////////////////////////////////////////////////
  727. // Bioseq members
  729. void CBioseq_EditHandle::SetDescr(TDescr& v) const
  730. {
  731.     x_GetInfo().SetDescr(v);
  732. }
  735. void CBioseq_EditHandle::SetInst(TInst& v) const
  736. {
  737.     x_GetInfo().SetInst(v);
  738. }
  741. void CBioseq_EditHandle::SetInst_Repr(TInst_Repr v) const
  742. {
  743.     x_GetInfo().SetInst_Repr(v);
  744. }
  747. void CBioseq_EditHandle::SetInst_Mol(TInst_Mol v) const
  748. {
  749.     x_GetInfo().SetInst_Mol(v);
  750. }
  753. void CBioseq_EditHandle::SetInst_Length(TInst_Length v) const
  754. {
  755.     x_GetInfo().SetInst_Length(v);
  756. }
  759. void CBioseq_EditHandle::SetInst_Fuzz(TInst_Fuzz& v) const
  760. {
  761.     x_GetInfo().SetInst_Fuzz(v);
  762. }
  765. void CBioseq_EditHandle::SetInst_Topology(TInst_Topology v) const
  766. {
  767.     x_GetInfo().SetInst_Topology(v);
  768. }
  771. void CBioseq_EditHandle::SetInst_Strand(TInst_Strand v) const
  772. {
  773.     x_GetInfo().SetInst_Strand(v);
  774. }
  777. void CBioseq_EditHandle::SetInst_Seq_data(TInst_Seq_data& v) const
  778. {
  779.     x_GetInfo().SetInst_Seq_data(v);
  780. }
  783. void CBioseq_EditHandle::SetInst_Ext(TInst_Ext& v) const
  784. {
  785.     x_GetInfo().SetInst_Ext(v);
  786. }
  789. void CBioseq_EditHandle::SetInst_Hist(TInst_Hist& v) const
  790. {
  791.     x_GetInfo().SetInst_Hist(v);
  792. }
  796. // end of Bioseq members
  797. /////////////////////////////////////////////////////////////////////////////
  800. END_SCOPE(objects)
  801. END_NCBI_SCOPE
  803. /*
  804. * ---------------------------------------------------------------------------
  805. * $Log: bioseq_handle.cpp,v $
  806. * Revision 1000.5  2004/06/01 19:22:54  gouriano
  807. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.66
  808. *
  809. * Revision 1.66  2004/05/27 14:59:49  shomrat
  810. * Added CBioseq_EditHandle constructor implementation
  811. *
  812. * Revision 1.65  2004/05/26 14:29:20  grichenk
  813. * Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
  814. * fixed strands handling, improved performance.
  815. *
  816. * Revision 1.64  2004/05/21 21:42:12  gorelenk
  817. * Added PCH ncbi_pch.hpp
  818. *
  819. * Revision 1.63  2004/05/10 18:26:37  grichenk
  820. * Fixed 'not used' warnings
  821. *
  822. * Revision 1.62  2004/05/06 17:32:37  grichenk
  823. * Added CanGetXXXX() methods
  824. *
  825. * Revision 1.61  2004/04/20 20:34:40  shomrat
  826. * fix GetExactComplexityLevel
  827. *
  828. * Revision 1.60  2004/03/31 19:54:08  vasilche
  829. * Fixed removal of bioseqs and bioseq-sets.
  830. *
  831. * Revision 1.59  2004/03/31 19:23:13  vasilche
  832. * Fixed scope in CBioseq_Handle::GetEditHandle().
  833. *
  834. * Revision 1.58  2004/03/29 20:13:06  vasilche
  835. * Implemented whole set of methods to modify Seq-entry object tree.
  836. * Added CBioseq_Handle::GetExactComplexityLevel().
  837. *
  838. * Revision 1.57  2004/03/25 19:27:44  vasilche
  839. * Implemented MoveTo and CopyTo methods of handles.
  840. *
  841. * Revision 1.56  2004/03/24 18:30:29  vasilche
  842. * Fixed edit API.
  843. * Every *_Info object has its own shallow copy of original object.
  844. *
  845. * Revision 1.55  2004/03/16 21:01:32  vasilche
  846. * Added methods to move Bioseq withing Seq-entry
  847. *
  848. * Revision 1.54  2004/03/16 15:47:27  vasilche
  849. * Added CBioseq_set_Handle and set of EditHandles
  850. *
  851. * Revision 1.53  2004/02/06 16:07:27  grichenk
  852. * Added CBioseq_Handle::GetSeq_entry_Handle()
  853. * Fixed MapLocation()
  854. *
  855. * Revision 1.52  2004/01/28 22:10:10  grichenk
  856. * Removed extra seq-loc initialization in MapLocation
  857. *
  858. * Revision 1.51  2004/01/23 16:14:47  grichenk
  859. * Implemented alignment mapping
  860. *
  861. * Revision 1.50  2004/01/22 20:10:40  vasilche
  862. * 1. Splitted ID2 specs to two parts.
  863. * ID2 now specifies only protocol.
  864. * Specification of ID2 split data is moved to seqsplit ASN module.
  865. * For now they are still reside in one resulting library as before - libid2.
  866. * As the result split specific headers are now in objects/seqsplit.
  867. * 2. Moved ID2 and ID1 specific code out of object manager.
  868. * Protocol is processed by corresponding readers.
  869. * ID2 split parsing is processed by ncbi_xreader library - used by all readers.
  870. * 3. Updated OBJMGR_LIBS correspondingly.
  871. *
  872. * Revision 1.49  2003/11/28 15:13:26  grichenk
  873. * Added CSeq_entry_Handle
  874. *
  875. * Revision 1.48  2003/11/26 17:55:57  vasilche
  876. * Implemented ID2 split in ID1 cache.
  877. * Fixed loading of splitted annotations.
  878. *
  879. * Revision 1.47  2003/11/10 18:12:43  grichenk
  880. * Added MapLocation()
  881. *
  882. * Revision 1.46  2003/09/30 16:22:02  vasilche
  883. * Updated internal object manager classes to be able to load ID2 data.
  884. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  885. * Scope caches results of requests for data to data loaders.
  886. * Optimized CSeq_id_Handle for gis.
  887. * Optimized bioseq lookup in scope.
  888. * Reduced object allocations in annotation iterators.
  889. * CScope is allowed to be destroyed before other objects using this scope are
  890. * deleted (feature iterators, bioseq handles etc).
  891. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  892. * Added 'adaptive' option to objmgr_demo application.
  893. *
  894. * Revision 1.45  2003/09/05 17:29:40  grichenk
  895. * Structurized Object Manager exceptions
  896. *
  897. * Revision 1.44  2003/08/27 14:27:19  vasilche
  898. * Use Reverse(ENa_strand) function.
  899. *
  900. * Revision 1.43  2003/07/15 16:14:08  grichenk
  901. * CBioseqHandle::IsSynonym() made public
  902. *
  903. * Revision 1.42  2003/06/24 14:22:46  vasilche
  904. * Fixed CSeqMap constructor from CSeq_loc.
  905. *
  906. * Revision 1.41  2003/06/19 18:23:45  vasilche
  907. * Added several CXxx_ScopeInfo classes for CScope related information.
  908. * CBioseq_Handle now uses reference to CBioseq_ScopeInfo.
  909. * Some fine tuning of locking in CScope.
  910. *
  911. * Revision 1.38  2003/05/20 15:44:37  vasilche
  912. * Fixed interaction of CDataSource and CDataLoader in multithreaded app.
  913. * Fixed some warnings on WorkShop.
  914. * Added workaround for memory leak on WorkShop.
  915. *
  916. * Revision 1.37  2003/04/29 19:51:13  vasilche
  917. * Fixed interaction of Data Loader garbage collector and TSE locking mechanism.
  918. * Made some typedefs more consistent.
  919. *
  920. * Revision 1.36  2003/04/24 16:12:38  vasilche
  921. * Object manager internal structures are splitted more straightforward.
  922. * Removed excessive header dependencies.
  923. *
  924. * Revision 1.35  2003/03/27 19:39:36  grichenk
  925. * +CBioseq_Handle::GetComplexityLevel()
  926. *
  927. * Revision 1.34  2003/03/18 14:52:59  grichenk
  928. * Removed obsolete methods, replaced seq-id with seq-id handle
  929. * where possible. Added argument to limit annotations update to
  930. * a single seq-entry.
  931. *
  932. * Revision 1.33  2003/03/12 20:09:33  grichenk
  933. * Redistributed members between CBioseq_Handle, CBioseq_Info and CTSE_Info
  934. *
  935. * Revision 1.32  2003/03/11 15:51:06  kuznets
  936. * iterate -> ITERATE
  937. *
  938. * Revision 1.31  2003/02/05 17:59:17  dicuccio
  939. * Moved formerly private headers into include/objects/objmgr/impl
  940. *
  941. * Revision 1.30  2003/01/29 22:03:46  grichenk
  942. * Use single static CSeq_id_Mapper instead of per-OM model.
  943. *
  944. * Revision 1.29  2003/01/23 19:33:57  vasilche
  945. * Commented out obsolete methods.
  946. * Use strand argument of CSeqVector instead of creation reversed seqmap.
  947. * Fixed ordering operators of CBioseqHandle to be consistent.
  948. *
  949. * Revision 1.28  2003/01/22 20:11:54  vasilche
  950. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  951. * CSeqMap_CI now supports resolution and iteration over sequence range.
  952. * Added several caches to CScope.
  953. * Optimized CSeqVector().
  954. * Added serveral variants of CBioseqHandle::GetSeqVector().
  955. * Tried to optimize annotations iterator (not much success).
  956. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  957. *
  958. * Revision 1.27  2002/12/26 20:55:17  dicuccio
  959. * Moved seq_id_mapper.hpp, tse_info.hpp, and bioseq_info.hpp -> include/ tree
  960. *
  961. * Revision 1.26  2002/12/26 16:39:24  vasilche
  962. * Object manager class CSeqMap rewritten.
  963. *
  964. * Revision 1.25  2002/12/06 15:36:00  grichenk
  965. * Added overlap type for annot-iterators
  966. *
  967. * Revision 1.24  2002/11/08 22:15:51  grichenk
  968. * Added methods for removing/replacing annotations
  969. *
  970. * Revision 1.23  2002/11/08 19:43:35  grichenk
  971. * CConstRef<> constructor made explicit
  972. *
  973. * Revision 1.22  2002/09/03 21:27:01  grichenk
  974. * Replaced bool arguments in CSeqVector constructor and getters
  975. * with enums.
  976. *
  977. * Revision 1.21  2002/07/10 16:49:29  grichenk
  978. * Removed commented reference to old CDataSource mutex
  979. *
  980. * Revision 1.20  2002/07/08 20:51:01  grichenk
  981. * Moved log to the end of file
  982. * Replaced static mutex (in CScope, CDataSource) with the mutex
  983. * pool. Redesigned CDataSource data locking.
  984. *
  985. * Revision 1.19  2002/06/12 14:39:02  grichenk
  986. * Renamed enumerators
  987. *
  988. * Revision 1.18  2002/06/06 21:00:42  clausen
  989. * Added include for scope.hpp
  990. *
  991. * Revision 1.17  2002/05/31 17:53:00  grichenk
  992. * Optimized for better performance (CTSE_Info uses atomic counter,
  993. * delayed annotations indexing, no location convertions in
  994. * CAnnot_Types_CI if no references resolution is required etc.)
  995. *
  996. * Revision 1.16  2002/05/24 14:57:12  grichenk
  997. * SerialAssign<>() -> CSerialObject::Assign()
  998. *
  999. * Revision 1.15  2002/05/21 18:39:30  grichenk
  1000. * CBioseq_Handle::GetResolvedSeqMap() -> CreateResolvedSeqMap()
  1001. *
  1002. * Revision 1.14  2002/05/06 03:28:46  vakatov
  1003. * OM/OM1 renaming
  1004. *
  1005. * Revision 1.13  2002/05/03 21:28:08  ucko
  1006. * Introduce T(Signed)SeqPos.
  1007. *
  1008. * Revision 1.12  2002/04/29 16:23:28  grichenk
  1009. * GetSequenceView() reimplemented in CSeqVector.
  1010. * CSeqVector optimized for better performance.
  1011. *
  1012. * Revision 1.11  2002/04/23 19:01:07  grichenk
  1013. * Added optional flag to GetSeqVector() and GetSequenceView()
  1014. * for switching to IUPAC encoding.
  1015. *
  1016. * Revision 1.10  2002/04/22 20:06:59  grichenk
  1017. * +GetSequenceView(), +x_IsSynonym()
  1018. *
  1019. * Revision 1.9  2002/04/11 12:07:30  grichenk
  1020. * Redesigned CAnnotTypes_CI to resolve segmented sequences correctly.
  1021. *
  1022. * Revision 1.8  2002/03/19 19:16:28  gouriano
  1023. * added const qualifier to GetTitle and GetSeqVector
  1024. *
  1025. * Revision 1.7  2002/03/15 18:10:07  grichenk
  1026. * Removed CRef<CSeq_id> from CSeq_id_Handle, added
  1027. * key to seq-id map th CSeq_id_Mapper
  1028. *
  1029. * Revision 1.6  2002/03/04 15:08:44  grichenk
  1030. * Improved CTSE_Info locks
  1031. *
  1032. * Revision 1.5  2002/02/21 19:27:05  grichenk
  1033. * Rearranged includes. Added scope history. Added searching for the
  1034. * best seq-id match in data sources and scopes. Updated tests.
  1035. *
  1036. * Revision 1.4  2002/01/28 19:44:49  gouriano
  1037. * changed the interface of BioseqHandle: two functions moved from Scope
  1038. *
  1039. * Revision 1.3  2002/01/23 21:59:31  grichenk
  1040. * Redesigned seq-id handles and mapper
  1041. *
  1042. * Revision 1.2  2002/01/16 16:25:56  gouriano
  1043. * restructured objmgr
  1044. *
  1045. * Revision 1.1  2002/01/11 19:06:17  gouriano
  1046. * restructured objmgr
  1047. *
  1048. *
  1049. * ===========================================================================
  1050. */