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

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

生物技术

开发平台：

C/C++

Seq_loc.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Seq_loc.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:34:35  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.42
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: Seq_loc.cpp,v 1000.3 2004/06/01 19:34:35 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:   Author:  Cliff Clausen, Eugene Vasilchenko
  36.  *
  37.  * File Description:
  38.  *   .......
  39.  *
  40.  * Remark:
  41.  *   This code was originally generated by application DATATOOL
  42.  *   using specifications from the ASN data definition file
  43.  *   'seqloc.asn'.
  44.  *
  45.  * ===========================================================================
  46.  */
  48. #include <ncbi_pch.hpp>
  49. #include <serial/enumvalues.hpp>
  50. #include <objects/general/Int_fuzz.hpp>
  51. #include <objects/seqloc/Seq_point.hpp>
  52. #include <objects/seqloc/Packed_seqint.hpp>
  53. #include <objects/seqloc/Packed_seqpnt.hpp>
  54. #include <objects/seqloc/Seq_loc_mix.hpp>
  55. #include <objects/seqloc/Seq_loc_equiv.hpp>
  56. #include <objects/seqloc/Seq_loc.hpp>
  57. #include <objects/seqfeat/Feat_id.hpp>
  60. BEGIN_NCBI_SCOPE
  61. BEGIN_objects_SCOPE // namespace ncbi::objects::
  64. // constructors
  65. CSeq_loc::CSeq_loc(E_Choice index)
  66. {
  67.     x_InvalidateCache();
  68.     switch ( index ) {
  69.     case e_Null:
  70.         {
  71.             SetNull();
  72.             break;
  73.         }
  74.     case e_Empty:
  75.         {
  76.             SetEmpty();
  77.             break;
  78.         }
  79.     case e_Whole:
  80.         {
  81.             SetWhole();
  82.             break;
  83.         }
  84.     case e_Int:
  85.         {
  86.             SetInt();
  87.             break;
  88.         }
  89.     case e_Packed_int:
  90.         {
  91.             SetPacked_int();
  92.             break;
  93.         }
  94.     case e_Pnt:
  95.         {
  96.             SetPnt();
  97.             break;
  98.         }
  99.     case e_Packed_pnt:
  100.         {
  101.             SetPacked_pnt();
  102.             break;
  103.         }
  104.     case e_Mix:
  105.         {
  106.             SetMix();
  107.             break;
  108.         }
  109.     case e_Equiv:
  110.         {
  111.             SetEquiv();
  112.             break;
  113.         }
  114.     case e_Bond:
  115.         {
  116.             SetBond();
  117.             break;
  118.         }
  119.     case e_Feat:
  120.         {
  121.             SetFeat();
  122.             break;
  123.         }
  124.     case e_not_set:
  125.     default:
  126.         break;
  127.     }
  128. }
  131. CSeq_loc::CSeq_loc(TId& id, TPoint point, TStrand strand)
  132. {
  133.     x_InvalidateCache();
  134.     SetPnt(*new CSeq_point(id, point, strand));
  135. }
  138. CSeq_loc::CSeq_loc(TId& id, const TPoints& points, TStrand strand)
  139. {
  140.     x_InvalidateCache();
  141.     if ( points.size() == 1 ) {
  142.         SetPnt(*new CSeq_point(id, points.front(), strand));
  143.     } else {
  144.         SetPacked_pnt(*new CPacked_seqpnt(id, points, strand));
  145.     }
  146. }
  149. CSeq_loc::CSeq_loc(TId& id, TPoint from, TPoint to, TStrand strand)
  150. {
  151.     x_InvalidateCache();
  152.     SetInt(*new CSeq_interval(id, from, to, strand));
  153. }
  156. CSeq_loc::CSeq_loc(TId& id, TRanges ranges, TStrand strand)
  157. {
  158.     x_InvalidateCache();
  159.     if ( ranges.size() == 1 ) {
  160.         SetInt(*new CSeq_interval(id,
  161.             ranges.front().GetFrom(), ranges.front().GetTo(), strand));
  162.     } else {
  163.         SetPacked_int(*new CPacked_seqint(id, ranges, strand));
  164.     }
  165. }
  168. // destructor
  169. CSeq_loc::~CSeq_loc(void)
  170. {
  171. }
  174. inline
  175. void x_Assign(CInt_fuzz& dst, const CInt_fuzz& src)
  176. {
  177.     switch ( src.Which() ) {
  178.     case CInt_fuzz::e_not_set:
  179.         dst.Reset();
  180.         break;
  181.     case CInt_fuzz::e_P_m:
  182.         dst.SetP_m(src.GetP_m());
  183.         break;
  184.     case CInt_fuzz::e_Range:
  185.         dst.SetRange().SetMin(src.GetRange().GetMin());
  186.         dst.SetRange().SetMax(src.GetRange().GetMax());
  187.         break;
  188.     case CInt_fuzz::e_Pct:
  189.         dst.SetPct(src.GetPct());
  190.         break;
  191.     case CInt_fuzz::e_Lim:
  192.         dst.SetLim(src.GetLim());
  193.         break;
  194.     case CInt_fuzz::e_Alt:
  195.         dst.SetAlt() = src.GetAlt();
  196.         break;
  197.     default:
  198.         NCBI_THROW(CException, eUnknown,
  199.             "Invalid Int-fuzz variant");
  200.     }
  201. }
  204. inline
  205. void x_Assign(CSeq_interval& dst, const CSeq_interval& src)
  206. {
  207.     dst.SetFrom(src.GetFrom());
  208.     dst.SetTo(src.GetTo());
  209.     if ( src.IsSetStrand() ) {
  210.         dst.SetStrand(src.GetStrand());
  211.     }
  212.     else {
  213.         dst.ResetStrand();
  214.     }
  215.     dst.SetId().Assign(src.GetId());
  216.     if ( src.IsSetFuzz_from() ) {
  217.         x_Assign(dst.SetFuzz_from(), src.GetFuzz_from());
  218.     }
  219.     else {
  220.         dst.ResetFuzz_from();
  221.     }
  222.     if ( src.IsSetFuzz_to() ) {
  223.         x_Assign(dst.SetFuzz_to(), src.GetFuzz_to());
  224.     }
  225.     else {
  226.         dst.ResetFuzz_to();
  227.     }
  228. }
  231. inline
  232. void x_Assign(CSeq_point& dst, const CSeq_point& src)
  233. {
  234.     dst.SetPoint(src.GetPoint());
  235.     if ( src.IsSetStrand() ) {
  236.         dst.SetStrand(src.GetStrand());
  237.     }
  238.     else {
  239.         dst.ResetStrand();
  240.     }
  241.     dst.SetId().Assign(src.GetId());
  242.     if ( src.IsSetFuzz() ) {
  243.         x_Assign(dst.SetFuzz(), src.GetFuzz());
  244.     }
  245.     else {
  246.         dst.ResetFuzz();
  247.     }
  248. }
  251. inline
  252. void x_Assign(CPacked_seqint& dst, const CPacked_seqint& src)
  253. {
  254.     CPacked_seqint::Tdata& data = dst.Set();
  255.     data.clear();
  256.     ITERATE ( CPacked_seqint::Tdata, i, src.Get() ) {
  257.         data.push_back(CRef<CSeq_interval>(new CSeq_interval));
  258.         x_Assign(*data.back(), **i);
  259.     }
  260. }
  263. inline
  264. void x_Assign(CPacked_seqpnt& dst, const CPacked_seqpnt& src)
  265. {
  266.     if ( src.IsSetStrand() ) {
  267.         dst.SetStrand(src.GetStrand());
  268.     }
  269.     else {
  270.         dst.ResetStrand();
  271.     }
  272.     dst.SetId().Assign(src.GetId());
  273.     if ( src.IsSetFuzz() ) {
  274.         x_Assign(dst.SetFuzz(), src.GetFuzz());
  275.     }
  276.     else {
  277.         dst.ResetFuzz();
  278.     }
  279.     dst.SetPoints() = src.GetPoints();
  280. }
  283. inline
  284. void x_Assign(CSeq_bond& dst, const CSeq_bond& src)
  285. {
  286.     x_Assign(dst.SetA(), src.GetA());
  287.     if ( src.IsSetB() ) {
  288.         x_Assign(dst.SetB(), src.GetB());
  289.     }
  290.     else {
  291.         dst.ResetB();
  292.     }
  293. }
  296. inline
  297. void x_Assign(CSeq_loc_mix& dst, const CSeq_loc_mix& src)
  298. {
  299.     CSeq_loc_mix::Tdata& data = dst.Set();
  300.     data.clear();
  301.     ITERATE ( CSeq_loc_mix::Tdata, i, src.Get() ) {
  302.         data.push_back(CRef<CSeq_loc>(new CSeq_loc));
  303.         data.back()->Assign(**i);
  304.     }
  305. }
  308. inline
  309. void x_Assign(CSeq_loc_equiv& dst, const CSeq_loc_equiv& src)
  310. {
  311.     CSeq_loc_equiv::Tdata& data = dst.Set();
  312.     data.clear();
  313.     ITERATE ( CSeq_loc_equiv::Tdata, i, src.Get() ) {
  314.         data.push_back(CRef<CSeq_loc>(new CSeq_loc));
  315.         data.back()->Assign(**i);
  316.     }
  317. }
  320. void CSeq_loc::Assign(const CSerialObject& obj, ESerialRecursionMode how)
  321. {
  322.     if ( GetTypeInfo() == obj.GetThisTypeInfo() ) {
  323.         const CSeq_loc& loc = static_cast<const CSeq_loc&>(obj);
  324.         switch ( loc.Which() ) {
  325.         case CSeq_loc::e_not_set:
  326.             Reset();
  327.             return;
  328.         case CSeq_loc::e_Null:
  329.             SetNull();
  330.             return;
  331.         case CSeq_loc::e_Empty:
  332.             SetEmpty().Assign(loc.GetEmpty());
  333.             return;
  334.         case CSeq_loc::e_Whole:
  335.             SetWhole().Assign(loc.GetWhole());
  336.             return;
  337.         case CSeq_loc::e_Int:
  338.             x_Assign(SetInt(), loc.GetInt());
  339.             return;
  340.         case CSeq_loc::e_Pnt:
  341.             x_Assign(SetPnt(), loc.GetPnt());
  342.             return;
  343.         case CSeq_loc::e_Packed_int:
  344.             x_Assign(SetPacked_int(), loc.GetPacked_int());
  345.             return;
  346.         case CSeq_loc::e_Packed_pnt:
  347.             x_Assign(SetPacked_pnt(), loc.GetPacked_pnt());
  348.             return;
  349.         case CSeq_loc::e_Mix:
  350.             x_Assign(SetMix(), loc.GetMix());
  351.             return;
  352.         case CSeq_loc::e_Equiv:
  353.             x_Assign(SetEquiv(), loc.GetEquiv());
  354.             return;
  355.         case CSeq_loc::e_Bond:
  356.             x_Assign(SetBond(), loc.GetBond());
  357.             return;
  358.         case CSeq_loc::e_Feat:
  359.             SetFeat().Assign(loc.GetFeat());
  360.             return;
  361.         }
  362.     }
  363.     CSerialObject::Assign(obj, how);
  364. }
  367. CSeq_loc::TRange CSeq_loc::x_UpdateTotalRange(void) const
  368. {
  369.     TRange range = m_TotalRangeCache;
  370.     if ( range.GetFrom() == TSeqPos(kDirtyCache) ) {
  371.         const CSeq_id* id = 0;
  372.         range = m_TotalRangeCache = x_CalculateTotalRangeCheckId(id);
  373.         m_IdCache = id;
  374.     }
  375.     return range;
  376. }
  379. void CSeq_loc::x_UpdateId(const CSeq_id*& total_id, const CSeq_id* id) const
  380. {
  381.     if ( total_id == id ) {
  382.         return;
  383.     }
  384.     
  385.     if ( !total_id ) {
  386.         total_id = id;
  387.     } else if ( (id  &&  !total_id->Equals(*id))  ||  !id ) {
  388.         NCBI_THROW(CException, eUnknown, "CSeq_loc -- multiple seq-ids");
  389.     }
  390. } 
  394. // returns enclosing location range
  395. // the total range is meaningless if there are several seq-ids
  396. // in the location
  397. CSeq_loc::TRange CSeq_loc::x_CalculateTotalRangeCheckId(const CSeq_id*& id) const
  398. {
  399.     TRange total_range;
  400.     switch ( Which() ) {
  401.     case CSeq_loc::e_not_set:
  402.     case CSeq_loc::e_Null:
  403.         {
  404.             // Ignore locations without id
  405.             total_range = TRange::GetEmpty();
  406.             break;
  407.         }
  408.     case CSeq_loc::e_Empty:
  409.         {
  410.             x_UpdateId(id, &GetEmpty());
  411.             total_range = TRange::GetEmpty();
  412.             break;
  413.         }
  414.     case CSeq_loc::e_Whole:
  415.         {
  416.             x_UpdateId(id, &GetWhole());
  417.             total_range = TRange::GetWhole();
  418.             break;
  419.         }
  420.     case CSeq_loc::e_Int:
  421.         {
  422.             const CSeq_interval& loc = GetInt();
  423.             x_UpdateId(id, &loc.GetId());
  424.             total_range.Set(loc.GetFrom(), loc.GetTo());
  425.             break;
  426.         }
  427.     case CSeq_loc::e_Pnt:
  428.         {
  429.             const CSeq_point& pnt = GetPnt();
  430.             x_UpdateId(id, &pnt.GetId());
  431.             TSeqPos pos = pnt.GetPoint();
  432.             total_range.Set(pos, pos);
  433.             break;
  434.         }
  435.     case CSeq_loc::e_Packed_int:
  436.         {
  437.             // Check ID of each interval
  438.             const CPacked_seqint& ints = GetPacked_int();
  439.             total_range = TRange::GetEmpty();
  440.             ITERATE ( CPacked_seqint::Tdata, ii, ints.Get() ) {
  441.                 const CSeq_interval& loc = **ii;
  442.                 x_UpdateId(id, &loc.GetId());
  443.                 total_range += TRange(loc.GetFrom(), loc.GetTo());
  444.             }
  445.             break;
  446.         }
  447.     case CSeq_loc::e_Packed_pnt:
  448.         {
  449.             const CPacked_seqpnt& pnts = GetPacked_pnt();
  450.             x_UpdateId(id, &pnts.GetId());
  451.             total_range = TRange::GetEmpty();
  452.             ITERATE( CPacked_seqpnt::TPoints, pi, pnts.GetPoints() ) {
  453.                 TSeqPos pos = *pi;
  454.                 total_range += TRange(pos, pos);
  455.             }
  456.             break;
  457.         }
  458.     case CSeq_loc::e_Mix:
  459.         {
  460.             // Check ID of each sub-location.
  461.             const CSeq_loc_mix& mix = GetMix();
  462.             total_range = TRange::GetEmpty();
  463.             ITERATE( CSeq_loc_mix::Tdata, li, mix.Get() ) {
  464.                 // instead of Get... to be able to check ID
  465.                 total_range += (*li)->x_CalculateTotalRangeCheckId(id);
  466.             }
  467.             break;
  468.         }
  469.     case CSeq_loc::e_Equiv:
  470. /*
  471.         {
  472.             // Does it make any sense to GetTotalRange() from an equiv?
  473.             total_range = TRange::GetEmpty();
  474.             ITERATE(CSeq_loc_equiv::Tdata, li, GetEquiv().Get()) {
  475.                 total_range += (*li)->GetTotalRange();
  476.             }
  477.             break;
  478.         }
  479. */
  480.     case CSeq_loc::e_Bond:
  481. /*
  482.         {
  483.             // Does it make any sense to GetTotalRange() from a bond?
  484.             const CSeq_bond& loc = GetBond();
  485.             TSeqPos pos = loc.GetA().GetPoint();
  486.             total_range = TRange(pos, pos);
  487.             if ( loc.IsSetB() ) {
  488.                 pos = loc.GetB().GetPoint();
  489.                 total_range += TRange(pos, pos);
  490.             }
  491.             break;
  492.         }
  493. */
  494.     case CSeq_loc::e_Feat:
  495.     default:
  496.         {
  497.             NCBI_THROW(CException, eUnknown,
  498.                        "CSeq_loc::CalculateTotalRange -- "
  499.                        "unsupported location type");
  500.         }
  501.     }
  503.     return total_range;
  504. }
  507. TSeqPos CSeq_loc::GetStart(TSeqPos seq_len) const
  508. {
  509.     if (seq_len == kInvalidSeqPos) {
  510.         return GetTotalRange().GetFrom();
  511.     }
  512.     switch ( Which() ) {
  513.     case CSeq_loc::e_not_set:
  514.     case CSeq_loc::e_Null:
  515.     case CSeq_loc::e_Empty:
  516.         {
  517.             return kInvalidSeqPos;
  518.         }
  519.     case CSeq_loc::e_Whole:
  520.         {
  521.             return TRange::GetWhole().GetFrom();
  522.         }
  523.     case CSeq_loc::e_Int:
  524.         {
  525.             return GetInt().GetFrom();
  526.         }
  527.     case CSeq_loc::e_Pnt:
  528.         {
  529.             return GetPnt().GetPoint();
  530.         }
  531.     case CSeq_loc::e_Packed_int:
  532.         {
  533.             return (*GetPacked_int().Get().begin())->GetFrom();
  534.         }
  535.     case CSeq_loc::e_Packed_pnt:
  536.         {
  537.             return *GetPacked_pnt().GetPoints().begin();
  538.         }
  539.     case CSeq_loc::e_Mix:
  540.         {
  541.             return (*GetMix().Get().begin())->GetStart(seq_len);
  542.         }
  543.     case CSeq_loc::e_Equiv:
  544.     case CSeq_loc::e_Bond:
  545.     case CSeq_loc::e_Feat:
  546.     default:
  547.         {
  548.             NCBI_THROW(CException, eUnknown,
  549.                        "CSeq_loc::GetStart -- "
  550.                        "unsupported location type");
  551.         }
  552.     }
  553. }
  556. TSeqPos CSeq_loc::GetEnd(TSeqPos seq_len) const
  557. {
  558.     if (seq_len == kInvalidSeqPos) {
  559.         return GetTotalRange().GetTo();
  560.     }
  561.     switch ( Which() ) {
  562.     case CSeq_loc::e_not_set:
  563.     case CSeq_loc::e_Null:
  564.     case CSeq_loc::e_Empty:
  565.         {
  566.             return kInvalidSeqPos;
  567.         }
  568.     case CSeq_loc::e_Whole:
  569.         {
  570.             return TRange::GetWhole().GetTo();
  571.         }
  572.     case CSeq_loc::e_Int:
  573.         {
  574.             return GetInt().GetTo();
  575.         }
  576.     case CSeq_loc::e_Pnt:
  577.         {
  578.             return GetPnt().GetPoint();
  579.         }
  580.     case CSeq_loc::e_Packed_int:
  581.         {
  582.             return (*GetPacked_int().Get().rbegin())->GetTo();
  583.         }
  584.     case CSeq_loc::e_Packed_pnt:
  585.         {
  586.             return *GetPacked_pnt().GetPoints().rbegin();
  587.         }
  588.     case CSeq_loc::e_Mix:
  589.         {
  590.             return (*GetMix().Get().rbegin())->GetEnd(seq_len);
  591.         }
  592.     case CSeq_loc::e_Equiv:
  593.     case CSeq_loc::e_Bond:
  594.     case CSeq_loc::e_Feat:
  595.     default:
  596.         {
  597.             NCBI_THROW(CException, eUnknown,
  598.                        "CSeq_loc::GetEnd -- "
  599.                        "unsupported location type");
  600.         }
  601.     }
  602. }
  605. TSeqPos CSeq_loc::GetCircularLength(TSeqPos seq_len) const
  606. {
  607.     if (seq_len == kInvalidSeqPos) {
  608.         return GetTotalRange().GetLength();
  609.     }
  610.     TSeqPos start = GetStart(seq_len);
  611.     TSeqPos stop = GetEnd(seq_len);
  612.     return start > stop ? seq_len - start + stop + 1 : stop - start + 1;
  613. }
  616. // CSeq_loc_CI implementation
  617. CSeq_loc_CI::CSeq_loc_CI(void)
  618.     : m_Location(0),
  619.       m_EmptyFlag(eEmpty_Skip)
  620. {
  621.     m_CurLoc = m_LocList.end();
  622. }
  625. CSeq_loc_CI::CSeq_loc_CI(const CSeq_loc& loc, EEmptyFlag empty_flag)
  626.     : m_Location(&loc),
  627.       m_EmptyFlag(empty_flag)
  628. {
  629.     x_ProcessLocation(loc);
  630.     m_CurLoc = m_LocList.begin();
  631. }
  634. CSeq_loc_CI::CSeq_loc_CI(const CSeq_loc_CI& iter)
  635. {
  636.     *this = iter;
  637. }
  640. CSeq_loc_CI::~CSeq_loc_CI()
  641. {
  642. }
  645. CSeq_loc_CI& CSeq_loc_CI::operator= (const CSeq_loc_CI& iter)
  646. {
  647.     if (this == &iter)
  648.         return *this;
  649.     m_LocList.clear();
  650.     m_Location = iter.m_Location;
  651.     m_EmptyFlag = iter.m_EmptyFlag;
  652.     ITERATE(TLocList, li, iter.m_LocList) {
  653.         TLocList::iterator tmp = m_LocList.insert(m_LocList.end(), *li);
  654.         if (iter.m_CurLoc == li)
  655.             m_CurLoc = tmp;
  656.     }
  657.     return *this;
  658. }
  661. void CSeq_loc_CI::x_ThrowNotValid(const char* where) const
  662. {
  663.     string msg;
  664.     msg += "CSeq_loc_CI::";
  665.     msg += where;
  666.     msg += " -- iterator is not valid";
  667.     NCBI_THROW(CException, eUnknown,
  668.         msg);
  669. }
  671. void CSeq_loc_CI::x_ProcessLocation(const CSeq_loc& loc)
  672. {
  673.     switch ( loc.Which() ) {
  674.     case CSeq_loc::e_not_set:
  675.     case CSeq_loc::e_Null:
  676.     case CSeq_loc::e_Empty:
  677.         {
  678.             if (m_EmptyFlag == eEmpty_Allow) {
  679.                 SLoc_Info info;
  680.                 info.m_Id.Reset(new CSeq_id);
  681.                 info.m_Range = TRange::GetEmpty();
  682.                 info.m_Loc = &loc;
  683.                 m_LocList.push_back(info);
  684.             }
  685.             return;
  686.         }
  687.     case CSeq_loc::e_Whole:
  688.         {
  689.             SLoc_Info info;
  690.             info.m_Id = &loc.GetWhole();
  691.             info.m_Range = TRange::GetWhole();
  692.             info.m_Loc = &loc;
  693.             m_LocList.push_back(info);
  694.             return;
  695.         }
  696.     case CSeq_loc::e_Int:
  697.         {
  698.             SLoc_Info info;
  699.             info.m_Id = &loc.GetInt().GetId();
  700.             info.m_Range.Set(loc.GetInt().GetFrom(), loc.GetInt().GetTo());
  701.             if ( loc.GetInt().IsSetStrand() )
  702.                 info.m_Strand = loc.GetInt().GetStrand();
  703.             info.m_Loc = &loc;
  704.             if (loc.GetInt().IsSetFuzz_from()) {
  705.                 info.m_Fuzz[0] = &loc.GetInt().GetFuzz_from();
  706.             }
  707.             if (loc.GetInt().IsSetFuzz_to()) {
  708.                 info.m_Fuzz[1] = &loc.GetInt().GetFuzz_to();
  709.             }
  710.             m_LocList.push_back(info);
  711.             return;
  712.         }
  713.     case CSeq_loc::e_Pnt:
  714.         {
  715.             SLoc_Info info;
  716.             info.m_Id = &loc.GetPnt().GetId();
  717.             info.m_Range.Set(loc.GetPnt().GetPoint(), loc.GetPnt().GetPoint());
  718.             if ( loc.GetPnt().IsSetStrand() )
  719.                 info.m_Strand = loc.GetPnt().GetStrand();
  720.             info.m_Loc = &loc;
  721.             if (loc.GetPnt().IsSetFuzz()) {
  722.                 info.m_Fuzz[0] = info.m_Fuzz[1] = &loc.GetPnt().GetFuzz();
  723.             }
  724.             m_LocList.push_back(info);
  725.             return;
  726.         }
  727.     case CSeq_loc::e_Packed_int:
  728.         {
  729.             ITERATE ( CPacked_seqint::Tdata, ii, loc.GetPacked_int().Get() ) {
  730.                 SLoc_Info info;
  731.                 info.m_Id = &(*ii)->GetId();
  732.                 info.m_Range.Set((*ii)->GetFrom(), (*ii)->GetTo());
  733.                 if ( (*ii)->IsSetStrand() )
  734.                     info.m_Strand = (*ii)->GetStrand();
  735.                 info.m_Loc = &loc;
  736.                 if ((*ii)->IsSetFuzz_from()) {
  737.                     info.m_Fuzz[0] = &(*ii)->GetFuzz_from();
  738.                 }
  739.                 if ((*ii)->IsSetFuzz_to()) {
  740.                     info.m_Fuzz[1] = &(*ii)->GetFuzz_to();
  741.                 }
  742.                 m_LocList.push_back(info);
  743.             }
  744.             return;
  745.         }
  746.     case CSeq_loc::e_Packed_pnt:
  747.         {
  748.             ITERATE ( CPacked_seqpnt::TPoints, pi, loc.GetPacked_pnt().GetPoints() ) {
  749.                 SLoc_Info info;
  750.                 info.m_Id = &loc.GetPacked_pnt().GetId();
  751.                 info.m_Range.Set(*pi, *pi);
  752.                 if ( loc.GetPacked_pnt().IsSetStrand() )
  753.                     info.m_Strand = loc.GetPacked_pnt().GetStrand();
  754.                 info.m_Loc = &loc;
  755.                 if (loc.GetPacked_pnt().IsSetFuzz()) {
  756.                     info.m_Fuzz[0] = info.m_Fuzz[1]
  757.                         = &loc.GetPacked_pnt().GetFuzz();
  758.                 }
  759.                 m_LocList.push_back(info);
  760.             }
  761.             return;
  762.         }
  763.     case CSeq_loc::e_Mix:
  764.         {
  765.             ITERATE(CSeq_loc_mix::Tdata, li, loc.GetMix().Get()) {
  766.                 x_ProcessLocation(**li);
  767.             }
  768.             return;
  769.         }
  770.     case CSeq_loc::e_Equiv:
  771.         {
  772.             ITERATE(CSeq_loc_equiv::Tdata, li, loc.GetEquiv().Get()) {
  773.                 x_ProcessLocation(**li);
  774.             }
  775.             return;
  776.         }
  777.     case CSeq_loc::e_Bond:
  778.         {
  779.             SLoc_Info infoA;
  780.             infoA.m_Id = &loc.GetBond().GetA().GetId();
  781.             infoA.m_Range.Set(loc.GetBond().GetA().GetPoint(),
  782.                               loc.GetBond().GetA().GetPoint());
  783.             if ( loc.GetBond().GetA().IsSetStrand() )
  784.                 infoA.m_Strand = loc.GetBond().GetA().GetStrand();
  785.             infoA.m_Loc = &loc;
  786.             if (loc.GetBond().GetA().IsSetFuzz()) {
  787.                 infoA.m_Fuzz[0] = infoA.m_Fuzz[1]
  788.                     = &loc.GetBond().GetA().GetFuzz();
  789.             }
  790.             m_LocList.push_back(infoA);
  791.             if ( loc.GetBond().IsSetB() ) {
  792.                 SLoc_Info infoB;
  793.                 infoB.m_Id = &loc.GetBond().GetB().GetId();
  794.                 infoB.m_Range.Set(loc.GetBond().GetB().GetPoint(),
  795.                                   loc.GetBond().GetB().GetPoint());
  796.                 if ( loc.GetBond().GetB().IsSetStrand() )
  797.                     infoB.m_Strand = loc.GetBond().GetB().GetStrand();
  798.                 infoB.m_Loc = &loc;
  799.                 if (loc.GetBond().GetB().IsSetFuzz()) {
  800.                     infoB.m_Fuzz[0] = infoB.m_Fuzz[1]
  801.                         = &loc.GetBond().GetB().GetFuzz();
  802.                 }
  803.                 m_LocList.push_back(infoB);
  804.             }
  805.             return;
  806.         }
  807.     case CSeq_loc::e_Feat:
  808.     default:
  809.         {
  810.             NCBI_THROW(CException, eUnknown,
  811.                        "CSeq_loc_CI -- unsupported location type");
  812.         }
  813.     }
  814. }
  817. // Append a string representation of a CSeq_id to label
  818. inline
  819. void s_GetLabel(const CSeq_id& id, string* label)
  820. {
  821.     CNcbiOstrstream os;
  822.     id.WriteAsFasta(os);
  823.     *label += CNcbiOstrstreamToString(os);
  824. }
  827. // Append to label info for a CSeq_point
  828. inline
  829. const CSeq_id* s_GetLabel
  830. (const CSeq_point& pnt,
  831.  const CSeq_id*    last_id,
  832.  string*           label)
  833. {
  834.     // If CSeq_id does not match last_id, then append id to label
  835.     if ( !last_id  ||  !last_id->Match(pnt.GetId()) ) {
  836.         s_GetLabel(pnt.GetId(), label);
  837.         *label += ":";
  838.     }
  840.     // Add strand info to label
  841.     if (pnt.IsSetStrand()) {
  842.         *label += GetTypeInfo_enum_ENa_strand()
  843.             ->FindName(pnt.GetStrand(), true);
  844.     }
  846.     if (pnt.IsSetFuzz()) {
  847.         // Append Fuzz info to label
  848.         pnt.GetFuzz().GetLabel(label, pnt.GetPoint());
  849.     } else {
  850.         // Append 1 based point to label
  851.         *label += NStr::IntToString(pnt.GetPoint()+1);
  852.     }
  854.     // update last_id
  855.     last_id = &pnt.GetId();
  856.     return last_id;
  857. }
  860. // Append to label info for CSeq_interval
  861. inline
  862. const CSeq_id* s_GetLabel
  863. (const CSeq_interval& itval,
  864.  const CSeq_id*       last_id,
  865.  string*              label)
  866. {
  867.     if (!last_id || !last_id->Match(itval.GetId())) {
  868.         s_GetLabel(itval.GetId(), label);
  869.         *label += ":";
  870.     }
  871.     last_id = &itval.GetId();
  872.     if (itval.IsSetStrand()) {
  873.         *label += GetTypeInfo_enum_ENa_strand()
  874.             ->FindName(itval.GetStrand(), true);
  875.     }
  876.     if (itval.IsSetStrand() &&
  877.         (itval.GetStrand() == eNa_strand_minus ||
  878.          itval.GetStrand() == eNa_strand_both_rev)) {
  879.         if (itval.IsSetFuzz_to()) {
  880.             itval.GetFuzz_to().GetLabel(label, itval.GetTo(), false);
  881.         } else {
  882.             *label += NStr::IntToString(itval.GetTo()+1);
  883.         }
  884.         *label += "-";
  885.         if (itval.IsSetFuzz_from()) {
  886.             itval.GetFuzz_from().GetLabel(label, itval.GetFrom());
  887.         } else {
  888.             *label += NStr::IntToString(itval.GetFrom()+1);
  889.         }
  890.     } else {
  891.         if (itval.IsSetFuzz_from()) {
  892.             itval.GetFuzz_from().GetLabel
  893.                 (label, itval.GetFrom(), false);
  894.         } else {
  895.             *label += NStr::IntToString(itval.GetFrom()+1);
  896.         }
  897.         *label += "-";
  898.         if (itval.IsSetFuzz_to()) {
  899.             itval.GetFuzz_to().GetLabel(label, itval.GetTo());
  900.         } else {
  901.             *label += NStr::IntToString(itval.GetTo()+1);
  902.         }
  903.     }
  904.     return last_id;
  905. }
  908. // Forward declaration
  909. const CSeq_id* s_GetLabel
  910. (const CSeq_loc& loc,
  911.  const CSeq_id*  last_id,
  912.  string*         label,
  913.  bool            first = false);
  916. // Appends to label info for each CSeq_loc in a list of CSeq_locs
  917. inline
  918. const CSeq_id* s_GetLabel
  919. (const list<CRef<CSeq_loc> >&  loc_list,
  920.  const CSeq_id*                last_id,
  921.  string*                       label)
  922. {
  923.     bool first = true;
  924.     ITERATE (list<CRef<CSeq_loc> >, it, loc_list) {
  926.         // Append to label for each CSeq_loc in list
  927.         last_id = s_GetLabel(**it, last_id, label, first);
  928.         first = false;
  929.     }
  931.     return last_id;
  932. }
  935. // Builds a label based upon a CSeq_loc and all embedded CSeq_locs
  936. const CSeq_id* s_GetLabel
  937. (const CSeq_loc& loc,
  938.  const CSeq_id*  last_id,
  939.  string*         label,
  940.  bool            first)
  941. {
  942.     // Ensure label is not null
  943.     if (!label) {
  944.         return last_id;
  945.     }
  947.     // Put a comma separator if necessary
  948.     if (!first) {
  949.         *label += ", ";
  950.     }
  952.     // Loop through embedded CSeq_locs and create a label, depending on
  953.     // type of CSeq_loc
  954.     switch (loc.Which()) {
  955.     case CSeq_loc::e_Null:
  956.         *label += "~";
  957.         break;
  958.     case CSeq_loc::e_Empty:
  959.         *label += "{";
  960.         s_GetLabel(loc.GetEmpty(), label);
  961.         last_id = &loc.GetEmpty();
  962.         *label += "}";
  963.         break;
  964.     case CSeq_loc::e_Whole:
  965.         s_GetLabel(loc.GetWhole(), label);
  966.         last_id = &loc.GetWhole();
  967.         break;
  968.     case CSeq_loc::e_Int:
  969.         last_id = s_GetLabel(loc.GetInt(), last_id, label);
  970.         break;
  971.     case CSeq_loc::e_Packed_int:
  972.     {
  973.         *label += "(";
  974.         bool first = true;
  975.         ITERATE(CPacked_seqint::Tdata, it, loc.GetPacked_int().Get()) {
  976.             if (!first) {
  977.                 *label += ", ";
  978.             }
  979.             first = false;
  980.             last_id = s_GetLabel(**it, last_id, label);
  981.         }
  982.         *label += ")";
  983.         break;
  984.     }
  985.     case CSeq_loc::e_Pnt:
  986.         last_id = s_GetLabel(loc.GetPnt(), last_id, label);
  987.         break;
  988.     case CSeq_loc::e_Packed_pnt:
  989.         *label += "(" + loc.GetPacked_pnt().GetId().AsFastaString() + ":";
  990.         {{
  991.              string str;
  992.              ITERATE (CPacked_seqpnt::TPoints, iter,
  993.                       loc.GetPacked_pnt().GetPoints()) {
  994.                  if ( !str.empty() ) {
  995.                      str += ", ";
  996.                  }
  997.                  str += NStr::IntToString(*iter);
  998.              }
  999.              *label += str;
  1000.          }}
  1001.         *label += ")";
  1002.         last_id = &loc.GetPacked_pnt().GetId();
  1003.         break;
  1004.     case CSeq_loc::e_Mix:
  1005.         *label += "[";
  1006.         last_id = s_GetLabel(loc.GetMix().Get(), last_id, label);
  1007.         *label += "]";
  1008.         break;
  1009.     case CSeq_loc::e_Equiv:
  1010.         *label += "[";
  1011.         last_id = s_GetLabel(loc.GetEquiv().Get(), last_id, label);
  1012.         *label += "]";
  1013.         break;
  1014.     case CSeq_loc::e_Bond:
  1015.         last_id = s_GetLabel(loc.GetBond().GetA(), last_id, label);
  1016.         *label += "=";
  1017.         if (loc.GetBond().IsSetB()) {
  1018.             last_id = s_GetLabel(loc.GetBond().GetB(), last_id, label);
  1019.         } else {
  1020.             *label += "?";
  1021.         }
  1022.         break;
  1023.     case CSeq_loc::e_Feat:
  1024.         *label += "(feat)";
  1025.         break;
  1026.     default:
  1027.         *label += "(??)";
  1028.         break;
  1029.     }
  1030.     return last_id;
  1031. }
  1033. bool CSeq_loc::IsPartialLeft (void) const
  1035. {
  1036.     switch (Which ()) {
  1038.         case CSeq_loc::e_Null :
  1039.             return true;
  1041.         case CSeq_loc::e_Int :
  1042.             return GetInt ().IsPartialLeft ();
  1044.         case CSeq_loc::e_Pnt :
  1045.             return GetPnt ().IsPartialLeft ();
  1047.         case CSeq_loc::e_Mix :
  1048.             return GetMix ().IsPartialLeft ();
  1050.         default :
  1051.             break;
  1052.     }
  1054.     return false;
  1055. }
  1057. bool CSeq_loc::IsPartialRight (void) const
  1059. {
  1060.     switch (Which ()) {
  1062.         case CSeq_loc::e_Null :
  1063.             return true;
  1065.         case CSeq_loc::e_Int :
  1066.             return GetInt ().IsPartialRight ();
  1068.         case CSeq_loc::e_Pnt :
  1069.             return GetPnt ().IsPartialRight ();
  1071.         case CSeq_loc::e_Mix :
  1072.             return GetMix ().IsPartialRight ();
  1074.         default :
  1075.             break;
  1076.     }
  1078.     return false;
  1079. }
  1082. void CSeq_loc::SetPartialLeft (bool val)
  1083. {
  1084.     if ( val == IsPartialLeft() ) {
  1085.         return;
  1086.     }
  1088.     switch ( Which() ) {
  1089.         case CSeq_loc::e_Int:
  1090.             SetInt().SetPartialLeft(val);
  1092.         case CSeq_loc::e_Pnt:
  1093.             SetPnt().SetPartialLeft(val);
  1095.         case CSeq_loc::e_Mix :
  1096.             SetMix().SetPartialLeft(val);
  1098.         default :
  1099.             break;
  1100.     }
  1101. }
  1104. void CSeq_loc::SetPartialRight(bool val)
  1105. {
  1106.     if ( val == IsPartialRight() ) {
  1107.         return;
  1108.     }
  1110.     switch ( Which() ) {
  1111.         case CSeq_loc::e_Int:
  1112.             SetInt().SetPartialRight(val);
  1114.         case CSeq_loc::e_Pnt:
  1115.             SetPnt().SetPartialRight(val);
  1117.         case CSeq_loc::e_Mix:
  1118.             SetMix().SetPartialRight(val);
  1120.         default :
  1121.             break;
  1122.     }
  1123. }
  1126. // Appends a label suitable for display (e.g., error messages)
  1127. // label must point to an existing string object
  1128. // Method just returns if label is null
  1129. void CSeq_loc::GetLabel(string* label) const
  1130. {
  1131.     s_GetLabel(*this, 0, label, true);
  1132. }
  1135. // assign the 'id' field of each sub-interval to the supplied id
  1136. void CSeq_loc::SetId(CSeq_id& id)
  1137. {
  1138.     x_InvalidateCache();
  1139.     switch (Which()) {
  1140.     case e_Int:
  1141.         SetInt().SetId(id);
  1142.         break;
  1144.     case e_Pnt:
  1145.         SetPnt().SetId(id);
  1146.         break;
  1148.     case e_Packed_int:
  1149.         NON_CONST_ITERATE (CPacked_seqint::Tdata, iter, SetPacked_int().Set()) {
  1150.             (*iter)->SetId(id);
  1151.         }
  1152.         break;
  1154.     case e_Packed_pnt:
  1155.         SetPacked_pnt().SetId(id);
  1156.         break;
  1158.     case e_Mix:
  1159.         NON_CONST_ITERATE (CSeq_loc_mix::Tdata, iter, SetMix().Set()) {
  1160.             (*iter)->SetId(id);
  1161.         }
  1162.         break;
  1164.     case e_Whole:
  1165.         SetWhole(id);
  1166.         break;
  1168.     case e_Empty:
  1169.         SetEmpty(id);
  1170.         break;
  1172.     case e_Equiv:
  1173.         NON_CONST_ITERATE (CSeq_loc_equiv::Tdata, iter, SetEquiv().Set()) {
  1174.             (*iter)->SetId(id);
  1175.         }
  1176.         break;
  1178.     case e_Bond:
  1179.         if (GetBond().IsSetA()) {
  1180.             SetBond().SetA().SetId(id);
  1181.         }
  1182.         if (GetBond().IsSetB()) {
  1183.             SetBond().SetB().SetId(id);
  1184.         }
  1185.         break;
  1187.     case e_Feat:
  1188.         LOG_POST(Error << "unhandled loc type in CSeq_loc::SetId(): e_Feat");
  1189.         break;
  1191.     default:
  1192.         LOG_POST(Error << "unhandled loc type in CSeq_loc::SetId(): "
  1193.                  << Which());
  1194.         break;
  1195.     }
  1196. }
  1199. bool CSeq_loc::Equals(const CSerialObject& object, ESerialRecursionMode how) const
  1200. {
  1201.     if ( typeid(object) != typeid(*this) ) {
  1202.         ERR_POST(Fatal <<
  1203.             "CSeq_loc::Assign() -- Assignment of incompatible types: " <<
  1204.             typeid(*this).name() << " = " << typeid(object).name());
  1205.     }
  1206.     return CSerialObject::Equals(object, how);
  1207. }
  1210. void CSeq_loc::x_CheckId(const CSeq_id*& id) const
  1211. {
  1212.     switch ( Which() ) {
  1213.     case CSeq_loc::e_not_set:
  1214.     case CSeq_loc::e_Null:
  1215.         {
  1216.             x_UpdateId(id, 0);
  1217.             break;
  1218.         }
  1219.     case CSeq_loc::e_Empty:
  1220.         {
  1221.             x_UpdateId(id, &GetEmpty());
  1222.             break;
  1223.         }
  1224.     case CSeq_loc::e_Whole:
  1225.         {
  1226.             x_UpdateId(id, &GetWhole());
  1227.             break;
  1228.         }
  1229.     case CSeq_loc::e_Int:
  1230.         {
  1231.             const CSeq_interval& loc = GetInt();
  1232.             x_UpdateId(id, &loc.GetId());
  1233.             break;
  1234.         }
  1235.     case CSeq_loc::e_Pnt:
  1236.         {
  1237.             const CSeq_point& pnt = GetPnt();
  1238.             x_UpdateId(id, &pnt.GetId());
  1239.             break;
  1240.         }
  1241.     case CSeq_loc::e_Packed_int:
  1242.         {
  1243.             // Check ID of each interval
  1244.             const CPacked_seqint& ints = GetPacked_int();
  1245.             ITERATE ( CPacked_seqint::Tdata, ii, ints.Get() ) {
  1246.                 const CSeq_interval& loc = **ii;
  1247.                 x_UpdateId(id, &loc.GetId());
  1248.             }
  1249.             break;
  1250.         }
  1251.     case CSeq_loc::e_Packed_pnt:
  1252.         {
  1253.             const CPacked_seqpnt& pnts = GetPacked_pnt();
  1254.             x_UpdateId(id, &pnts.GetId());
  1255.             break;
  1256.         }
  1257.     case CSeq_loc::e_Mix:
  1258.         {
  1259.             // Check ID of each sub-location.
  1260.             const CSeq_loc_mix& mix = GetMix();
  1261.             ITERATE( CSeq_loc_mix::Tdata, li, mix.Get() ) {
  1262.                 (*li)->CheckId(id);
  1263.             }
  1264.             break;
  1265.         }
  1266.     case CSeq_loc::e_Bond:
  1267.         {
  1268.             const CSeq_bond& bond = GetBond();
  1269.             if ( bond.CanGetA() ) {
  1270.                 x_UpdateId(id, &bond.GetA().GetId());
  1271.             }
  1272.             if ( bond.CanGetB() ) {
  1273.                 x_UpdateId(id, &bond.GetB().GetId());
  1274.             }
  1275.             break;
  1276.         }        
  1277.     case CSeq_loc::e_Equiv:
  1278.         {
  1279.             // Doesn't make much sense to test equiv, but ...
  1280.             ITERATE(CSeq_loc_equiv::Tdata, li, GetEquiv().Get()) {
  1281.                 (*li)->CheckId(id);
  1282.             }
  1283.             break;
  1284.         }
  1285.     case CSeq_loc::e_Feat:
  1286.     default:
  1287.         {
  1288.             NCBI_THROW(CException, eUnknown,
  1289.                        "CSeq_loc::CheckId -- "
  1290.                        "unsupported location type");
  1291.         }
  1292.     }
  1293. }
  1296. void CSeq_loc::x_ChangeToMix(const CSeq_loc& other)
  1297. {
  1298.     CRef<CSeq_loc> self(new CSeq_loc);
  1299.     self->Assign(*this);
  1300.     CSeq_loc_mix& mix = SetMix();
  1301.     mix.AddSeqLoc(*self);
  1302.     mix.AddSeqLoc(other);
  1303. }
  1306. void CSeq_loc::x_ChangeToPackedInt(const CSeq_loc& other)
  1307. {
  1308.     _ASSERT(IsInt());
  1309.     _ASSERT(other.IsInt()  ||  other.IsPacked_int());
  1310.     
  1311.     CConstRef<CSeq_interval> self(&GetInt());
  1312.     SetPacked_int().AddInterval(*self);
  1314.     if ( other.IsInt() ) {
  1315.         SetPacked_int().AddInterval(other.GetInt());
  1316.     } else {  // other is packed int
  1317.         SetPacked_int().AddIntervals(other.GetPacked_int());
  1318.     }
  1319. }
  1322. void CSeq_loc::x_ChangeToPackedPnt(const CSeq_loc& other)
  1323. {
  1324.     _ASSERT(IsPnt());
  1325.     _ASSERT(other.IsPnt()  ||  other.IsPacked_pnt());
  1327.     CRef<CSeq_point> pnt(&SetPnt());
  1328.     CPacked_seqpnt& ppnt = SetPacked_pnt();
  1329.     if ( pnt->IsSetStrand() ) {
  1330.         ppnt.SetStrand(pnt->GetStrand());
  1331.     }
  1332.     if ( pnt->IsSetId() ) {
  1333.         ppnt.SetId(pnt->SetId());
  1334.     }
  1335.     if ( pnt->IsSetFuzz() ) {
  1336.         ppnt.SetFuzz(pnt->SetFuzz());
  1337.     }
  1338.     ppnt.AddPoint(pnt->GetPoint());
  1340.     if ( other.IsPnt() ) {
  1341.         ppnt.AddPoint(other.GetPnt().GetPoint());
  1342.     } else { // other is packed point
  1343.         ppnt.AddPoints(other.GetPacked_pnt().GetPoints());
  1344.     }
  1345. }
  1348. template<typename T1, typename T2>
  1349. bool s_CanAdd(const T1& obj1, const T2& obj2)
  1350. {
  1351.     // test strands
  1352.     {{
  1353.         ENa_strand s1 = obj1.CanGetStrand() ? obj1.GetStrand() : eNa_strand_unknown;
  1354.         ENa_strand s2 = obj2.CanGetStrand() ? obj2.GetStrand() : eNa_strand_unknown;
  1355.         if ( s1 != s2 ) {
  1356.             return false;
  1357.         }
  1358.     }}
  1360.     // test ids
  1361.     {{
  1362.         const CSeq_id* id1 = obj1.CanGetId() ? &obj1.GetId() : 0;
  1363.         const CSeq_id* id2 = obj2.CanGetId() ? &obj2.GetId() : 0;
  1364.         if ( ((id1 != id2)  &&  (id1 == 0  ||  id2 == 0))  ||
  1365.              !id1->Match(*id2) ) {
  1366.             return false;
  1367.         }
  1368.     }}
  1370.     // test fuzz
  1371.     {{
  1372.         const CInt_fuzz* f1 = obj1.CanGetFuzz() ? &obj1.GetFuzz() : 0;
  1373.         const CInt_fuzz* f2 = obj2.CanGetFuzz() ? &obj2.GetFuzz() : 0;
  1374.         if ( ((f1 != f2)  &&  (f1 == 0  ||  f2 == 0))  ||
  1375.              !f1->Equals(*f2) ) {
  1376.             return false;
  1377.         }
  1378.     }}
  1380.     return true;
  1381. }
  1384. bool s_CanAdd(const CSeq_loc& loc1, const CSeq_loc& loc2)
  1385. {
  1386.     switch ( loc1.Which() ) {
  1387.     case CSeq_loc::e_Pnt:
  1388.         {
  1389.             switch ( loc2.Which() ) {
  1390.             case CSeq_loc::e_Pnt:
  1391.                 return s_CanAdd(loc1.GetPnt(), loc2.GetPnt());
  1392.             case CSeq_loc::e_Packed_pnt:
  1393.                 return s_CanAdd(loc1.GetPnt(), loc2.GetPacked_pnt());
  1394.             }
  1395.             break;
  1396.         }
  1397.     case CSeq_loc::e_Packed_pnt:
  1398.         {
  1399.             switch ( loc2.Which() ) {
  1400.             case CSeq_loc::e_Pnt:
  1401.                 return s_CanAdd(loc1.GetPacked_pnt(), loc2.GetPnt());
  1402.             case CSeq_loc::e_Packed_pnt:
  1403.                 return s_CanAdd(loc1.GetPacked_pnt(), loc2.GetPacked_pnt());
  1404.             }
  1405.             break;
  1406.         }
  1407.     default:
  1408.         {
  1409.             return false;
  1410.         }
  1411.     }
  1413.     return false;
  1414. }
  1417. void CSeq_loc::Add(const CSeq_loc& other)
  1418. {
  1419.     x_InvalidateCache();
  1420.     switch ( Which() ) {
  1421.     case CSeq_loc::e_not_set:
  1422.         {
  1423.             Assign(other);
  1424.             break;
  1425.         }
  1426.     case CSeq_loc::e_Null:
  1427.         {
  1428.             // ??? skip if other is null?
  1429.             x_ChangeToMix(other);
  1430.             break;
  1431.         }
  1432.     case CSeq_loc::e_Empty:
  1433.         {
  1434.             // ??? skip if other is empty and ids match?
  1435.             x_ChangeToMix(other);
  1436.             break;
  1437.         }
  1438.         break;
  1440.     case CSeq_loc::e_Whole:
  1441.         {
  1442.             x_ChangeToMix(other);
  1443.             break;
  1444.         }
  1445.     case CSeq_loc::e_Int:
  1446.         {
  1447.             if ( other.IsInt()  ||  other.IsPacked_int() ) {
  1448.                 x_ChangeToPackedInt(other);
  1449.             } else {
  1450.                 x_ChangeToMix(other);
  1451.             }
  1452.         }
  1453.         break;
  1454.     case CSeq_loc::e_Pnt:
  1455.         {
  1456.             if ( s_CanAdd(*this, other) ) {
  1457.                 x_ChangeToPackedPnt(other);
  1458.             } else {
  1459.                 x_ChangeToMix(other);
  1460.             }
  1461.             break;
  1462.         }
  1463.     case CSeq_loc::e_Packed_int:
  1464.         {
  1465.             if ( other.IsInt() ) {
  1466.                 SetPacked_int().AddInterval(other.GetInt());
  1467.             } else if ( other.IsPacked_int() ) {
  1468.                 SetPacked_int().AddIntervals(other.GetPacked_int());
  1469.             } else {
  1470.                 x_ChangeToMix(other);
  1471.             }
  1472.             break;
  1473.         }
  1474.     case CSeq_loc::e_Packed_pnt:
  1475.         {
  1476.             if ( s_CanAdd(*this, other) ) {
  1477.                 if ( other.IsPnt() ) {
  1478.                     SetPacked_pnt().AddPoint(other.GetPnt().GetPoint());
  1479.                 } else if ( other.IsPacked_pnt() ) {
  1480.                     SetPacked_pnt().AddPoints(other.GetPacked_pnt().GetPoints());
  1481.                 }
  1482.             } else {
  1483.                 x_ChangeToMix(other);
  1484.             }
  1485.             break;
  1486.         }
  1487.     case CSeq_loc::e_Mix:
  1488.         {
  1489.             SetMix().AddSeqLoc(other);
  1490.             break;
  1491.         }
  1492.     case CSeq_loc::e_Equiv:
  1493.         {
  1494.             SetEquiv().Add(other);
  1495.             break;
  1496.         }
  1497.     case CSeq_loc::e_Bond:
  1498.         {
  1499.             x_ChangeToMix(other);
  1500.             break;
  1501.         }
  1502.     case CSeq_loc::e_Feat:
  1503.     default:
  1504.         {
  1505.             NCBI_THROW(CException, eUnknown,
  1506.                        "CSeq_loc::Add -- "
  1507.                        "unsupported location type");
  1508.         }
  1509.     }
  1510. }
  1513. END_objects_SCOPE // namespace ncbi::objects::
  1514. END_NCBI_SCOPE
  1517. /*
  1518.  * =============================================================================
  1519.  * $Log: Seq_loc.cpp,v $
  1520.  * Revision 1000.3  2004/06/01 19:34:35  gouriano
  1521.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.42
  1522.  *
  1523.  * Revision 6.42  2004/05/19 17:26:25  gorelenk
  1524.  * Added include of PCH - ncbi_pch.hpp
  1525.  *
  1526.  * Revision 6.41  2004/05/07 12:51:13  shomrat
  1527.  * Removed return from function returning void
  1528.  *
  1529.  * Revision 6.40  2004/05/06 16:55:00  shomrat
  1530.  * Added methods to set partial left and right
  1531.  *
  1532.  * Revision 6.39  2004/03/25 15:59:06  gouriano
  1533.  * Added possibility to copy and compare serial object non-recursively
  1534.  *
  1535.  * Revision 6.38  2004/01/29 19:58:52  shomrat
  1536.  * Adding missing cache invalidation
  1537.  *
  1538.  * Revision 6.37  2004/01/28 17:18:11  shomrat
  1539.  * Added methods to ease the construction of objects
  1540.  *
  1541.  * Revision 6.36  2003/11/21 14:45:05  grichenk
  1542.  * Replaced runtime_error with CException
  1543.  *
  1544.  * Revision 6.35  2003/10/15 15:50:36  ucko
  1545.  * CSeq_loc_CI: expose fuzz (if present).
  1546.  *
  1547.  * Revision 6.34  2003/10/14 16:48:53  dicuccio
  1548.  * Added SetId() function.  Added correct printing of packed seq-points in
  1549.  * Getlabel()
  1550.  *
  1551.  * Revision 6.33  2003/09/22 18:38:14  grichenk
  1552.  * Fixed circular seq-locs processing by TestForOverlap()
  1553.  *
  1554.  * Revision 6.32  2003/09/17 18:39:01  grichenk
  1555.  * + GetStart(), GetEnd(), GetCircularLength()
  1556.  *
  1557.  * Revision 6.31  2003/07/21 15:32:11  vasilche
  1558.  * Fixed access to uninitialized member.
  1559.  *
  1560.  * Revision 6.30  2003/06/18 16:00:07  vasilche
  1561.  * Fixed GetTotalRange() in multithreaded app.
  1562.  *
  1563.  * Revision 6.29  2003/06/13 17:21:20  grichenk
  1564.  * Added seq-id caching for single-id seq-locs
  1565.  *
  1566.  * Revision 6.28  2003/04/02 15:17:47  grichenk
  1567.  * Added flag for CSeq_loc_CI to skip/include empty locations.
  1568.  *
  1569.  * Revision 6.27  2003/03/11 15:55:44  kuznets
  1570.  * iterate -> ITERATE
  1571.  *
  1572.  * Revision 6.26  2003/02/24 18:52:13  vasilche
  1573.  * Added clearing of old data in assign.
  1574.  *
  1575.  * Revision 6.25  2003/02/06 22:23:29  vasilche
  1576.  * Added CSeq_id::Assign(), CSeq_loc::Assign().
  1577.  * Added int CSeq_id::Compare() (not safe).
  1578.  * Added caching of CSeq_loc::GetTotalRange().
  1579.  *
  1580.  * Revision 6.24  2003/02/04 15:15:15  grichenk
  1581.  * Overrided Assign() for CSeq_loc and CSeq_id
  1582.  *
  1583.  * Revision 6.23  2003/01/24 20:11:33  vasilche
  1584.  * Fixed trigraph warning on GCC.
  1585.  *
  1586.  * Revision 6.22  2003/01/22 20:17:33  vasilche
  1587.  * Optimized CSeq_loc::GetTotalRange().
  1588.  *
  1589.  * Revision 6.21  2002/12/30 19:37:02  vasilche
  1590.  * Rewrote CSeq_loc::GetTotalRange() to avoid using CSeq_loc_CI -
  1591.  * it's too expensive.
  1592.  *
  1593.  * Revision 6.20  2002/12/23 17:19:27  grichenk
  1594.  * Added GetSeq_loc() to CSeq_loc_CI
  1595.  *
  1596.  * Revision 6.19  2002/12/19 20:24:54  grichenk
  1597.  * Updated usage of CRange<>
  1598.  *
  1599.  * Revision 6.18  2002/12/06 15:36:04  grichenk
  1600.  * Added overlap type for annot-iterators
  1601.  *
  1602.  * Revision 6.17  2002/10/03 20:22:50  ucko
  1603.  * Drop duplicate default arg. spec. for s_GetLabel.
  1604.  *
  1605.  * Revision 6.16  2002/10/03 18:53:03  clausen
  1606.  * Removed extra whitespace
  1607.  *
  1608.  * Revision 6.15  2002/10/03 16:36:09  clausen
  1609.  * Added GetLabel()
  1610.  *
  1611.  * Revision 6.14  2002/09/12 21:19:02  kans
  1612.  * added IsPartialLeft and IsPartialRight
  1613.  *
  1614.  * Revision 6.13  2002/06/06 20:35:28  clausen
  1615.  * Moved methods using object manager to objects/util
  1616.  *
  1617.  * Revision 6.12  2002/05/31 13:33:02  grichenk
  1618.  * GetLength() -- return 0 for e_Null locations
  1619.  *
  1620.  * Revision 6.11  2002/05/06 03:39:12  vakatov
  1621.  * OM/OM1 renaming
  1622.  *
  1623.  * Revision 6.10  2002/05/03 21:28:18  ucko
  1624.  * Introduce T(Signed)SeqPos.
  1625.  *
  1626.  * Revision 6.9  2002/04/22 20:08:31  grichenk
  1627.  * Redesigned GetTotalRange() using CSeq_loc_CI
  1628.  *
  1629.  * Revision 6.8  2002/04/17 15:39:08  grichenk
  1630.  * Moved CSeq_loc_CI to the seq-loc library
  1631.  *
  1632.  * Revision 6.7  2002/01/16 18:56:32  grichenk
  1633.  * Removed CRef<> argument from choice variant setter, updated sources to
  1634.  * use references instead of CRef<>s
  1635.  *
  1636.  * Revision 6.6  2002/01/10 18:21:26  clausen
  1637.  * Added IsOneBioseq, GetStart, and GetId
  1638.  *
  1639.  * Revision 6.5  2001/10/22 11:40:32  clausen
  1640.  * Added Compare() implementation
  1641.  *
  1642.  * Revision 6.4  2001/01/03 18:59:09  vasilche
  1643.  * Added missing include.
  1644.  *
  1645.  * Revision 6.3  2001/01/03 16:39:05  vasilche
  1646.  * Added CAbstractObjectManager - stub for object manager.
  1647.  * CRange extracted to separate file.
  1648.  *
  1649.  * Revision 6.2  2000/12/26 17:28:55  vasilche
  1650.  * Simplified and formatted code.
  1651.  *
  1652.  * Revision 6.1  2000/11/17 21:35:10  vasilche
  1653.  * Added GetLength() method to CSeq_loc class.
  1654.  *
  1655.  *
  1656.  * ===========================================================================
  1657. */