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

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

生物技术

开发平台：

C/C++

Seq_align.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Seq_align.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:33:39  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.16
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: Seq_align.cpp,v 1000.2 2004/06/01 19:33:39 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:  .......
  36.  *
  37.  * File Description:
  38.  *   .......
  39.  *
  40.  * Remark:
  41.  *   This code was originally generated by application DATATOOL
  42.  *   using specifications from the data definition file
  43.  *   'seqalign.asn'.
  44.  */
  46. // standard includes
  47. #include <ncbi_pch.hpp>
  48. #include <objects/seqalign/seqalign_exception.hpp>
  49. #include <objects/seqalign/Dense_seg.hpp>
  50. #include <objects/seqalign/Dense_diag.hpp>
  51. #include <objects/seqalign/Std_seg.hpp>
  52. #include <objects/seqalign/Seq_align_set.hpp>
  53. #include <objects/seqalign/Score.hpp>
  54. #include <objects/general/Object_id.hpp>
  55. #include <objects/seqloc/Seq_loc.hpp>
  56. #include <objects/seqloc/Seq_interval.hpp>
  57. #include <serial/iterator.hpp>
  59. // generated includes
  60. #include <objects/seqalign/Seq_align.hpp>
  62. // generated classes
  64. BEGIN_NCBI_SCOPE
  66. BEGIN_objects_SCOPE // namespace ncbi::objects::
  68. // destructor
  69. CSeq_align::~CSeq_align(void)
  70. {
  71. }
  74. CSeq_align::TDim CSeq_align::CheckNumRows(void) const
  75. {
  76.     switch (GetSegs().Which()) {
  77.     case C_Segs::e_Denseg:
  78.         return GetSegs().GetDenseg().CheckNumRows();
  79.     case C_Segs::e_Std:
  80.         {
  81.             TDim numrows = 0;
  82.             ITERATE (C_Segs::TStd, std_i, GetSegs().GetStd()) {
  83.                 const TDim& seg_numrows = (*std_i)->CheckNumRows();
  84.                 if (numrows) {
  85.                     if (seg_numrows != numrows) {
  86.                         NCBI_THROW(CSeqalignException, eInvalidAlignment,
  87.                                    "CSeq_align::CheckNumRows(): Number of rows "
  88.                                    "is not the same for each std seg.");
  89.                     }
  90.                 } else {
  91.                     numrows = seg_numrows;
  92.                 }
  93.             }
  94.             return numrows;
  95.         }
  96.     default:
  97.         NCBI_THROW(CSeqalignException, eUnsupported,
  98.                    "CSeq_align::CheckNumRows() currently does not handle "
  99.                    "this type of alignment");
  100.     }
  101. }
  104. CRange<TSeqPos> CSeq_align::GetSeqRange(TDim row) const
  105. {
  106.     switch (GetSegs().Which()) {
  107.     case C_Segs::e_Denseg:
  108.         return GetSegs().GetDenseg().GetSeqRange(row);
  109.     case C_Segs::e_Std:
  110.         {
  111.             CRange<TSeqPos> rng;
  112.             CSeq_id seq_id;
  113.             size_t seg_i = 0;
  114.             ITERATE (C_Segs::TStd, std_i, GetSegs().GetStd()) {
  115.                 TDim row_i = 0;
  116.                 ITERATE (CStd_seg::TLoc, i, (*std_i)->GetLoc()) {
  117.                     const CSeq_loc& loc = **i;
  118.                     if (row_i++ == row) {
  119.                         if (loc.IsInt()) {
  120.                             if ( !seg_i ) {
  121.                                 seq_id.Assign(loc.GetInt().GetId());
  122.                             } else if (seq_id.Compare(loc.GetInt().GetId())
  123.                                        != CSeq_id::e_YES) {
  124.                                 NCBI_THROW(CSeqalignException,
  125.                                            eInvalidRowNumber,
  126.                                            "CSeq_align::GetSeqRange():"
  127.                                            " Row seqids not consistent."
  128.                                            " Cannot determine range.");
  129.                             }
  130.                             rng.CombineWith
  131.                                 (CRange<TSeqPos>
  132.                                  (loc.GetInt().GetFrom(),
  133.                                   loc.GetInt().GetTo()));
  134.                         }
  135.                     }
  136.                 }
  137.                 if (row < 0  ||  row >= row_i) {
  138.                     NCBI_THROW(CSeqalignException, eInvalidRowNumber,
  139.                                "CSeq_align::GetSeqRange():"
  140.                                " Invalid row number");
  141.                 }
  142.                 if (CanGetDim()  &&  row_i != GetDim()) {
  143.                     NCBI_THROW(CSeqalignException, eInvalidAlignment,
  144.                                "CSeq_align::GetSeqRange():"
  145.                                " loc.size is inconsistent with dim");
  146.                 }
  147.                 seg_i++;
  148.             }
  149.             if (rng.Empty()) {
  150.                 NCBI_THROW(CSeqalignException, eInvalidAlignment,
  151.                            "CSeq_align::GetSeqRange(): Row is empty");
  152.             }
  153.             return rng;
  154.         }
  155.     default:
  156.         NCBI_THROW(CSeqalignException, eUnsupported,
  157.                    "CSeq_align::GetSeqRange() currently does not handle "
  158.                    "this type of alignment.");
  159.     }
  160. }
  163. TSeqPos CSeq_align::GetSeqStart(TDim row) const
  164. {
  165.     switch (GetSegs().Which()) {
  166.     case C_Segs::e_Denseg:
  167.         return GetSegs().GetDenseg().GetSeqStart(row);
  168.     case C_Segs::e_Std:
  169.         return GetSeqRange(row).GetFrom();
  170.     default:
  171.         NCBI_THROW(CSeqalignException, eUnsupported,
  172.                    "CSeq_align::GetSeqStart() currently does not handle "
  173.                    "this type of alignment.");
  174.     }
  175. }
  178. TSeqPos CSeq_align::GetSeqStop (TDim row) const
  179. {
  180.     switch (GetSegs().Which()) {
  181.     case C_Segs::e_Denseg:
  182.         return GetSegs().GetDenseg().GetSeqStop(row);
  183.     case C_Segs::e_Std:
  184.         return GetSeqRange(row).GetTo();
  185.     default:
  186.         NCBI_THROW(CSeqalignException, eUnsupported,
  187.                    "CSeq_align::GetSeqStop() currently does not handle "
  188.                    "this type of alignment.");
  189.     }
  190. }
  193. const CSeq_id& CSeq_align::GetSeq_id(TDim row) const
  194. {
  195.     switch (GetSegs().Which()) {
  196.     case C_Segs::e_Denseg:
  197.         {
  198.             if ( GetSegs().GetDenseg().IsSetIds()  &&
  199.                 row < GetSegs().GetDenseg().GetIds().size()) {
  200.                 return *GetSegs().GetDenseg().GetIds()[row];
  201.             }
  202.             break;
  203.         }
  204.     case C_Segs::e_Dendiag:
  205.         {
  206.             // If segments have different number of rows, this will try
  207.             // to find the segment with enough rows to get the id.
  208.             ITERATE(CSeq_align::C_Segs::TDendiag, seg, GetSegs().GetDendiag()) {
  209.                 if( (*seg)->IsSetIds()  &&
  210.                     row < (*seg)->GetIds().size() ) {
  211.                     return *(*seg)->GetIds()[row];
  212.                 }
  213.             }
  214.             break;
  215.         }
  216.     case C_Segs::e_Std:
  217.         {
  218.             // If segments have different number of rows, this will try
  219.             // to find the segment with enough rows to get the id.
  220.             ITERATE(CSeq_align::C_Segs::TStd, seg, GetSegs().GetStd()) {
  221.                 if ( (*seg)->IsSetLoc()  &&
  222.                     row < (*seg)->GetLoc().size() ) {
  223.                     CSeq_loc_CI loc_iter(*(*seg)->GetLoc()[row]);
  224.                     return loc_iter.GetSeq_id();
  225.                 }
  226.             }
  227.             break;
  228.         }
  229.     default:
  230.         NCBI_THROW(CSeqalignException, eUnsupported,
  231.                    "CSeq_align::GetSeq_id() currently does not handle "
  232.                    "this type of alignment.");
  233.     }
  234.     NCBI_THROW(CSeqalignException, eInvalidRowNumber,
  235.                "CSeq_align::GetSeq_id(): "
  236.                "can not get seq-id for the row requested.");
  237.     // return CSeq_id();
  238. }
  240. ///---------------------------------------------------------------------------
  241. /// PRE : name of score to return
  242. /// POST: whether or not we found that score; score converted to int
  243. bool CSeq_align::GetNamedScore(const string &id, int &score) const
  244. {
  245.     if (IsSetScore()) {
  246.         const TScore &scores = GetScore();
  247.         ITERATE (TScore, scoreI, scores) {
  248.             if ((*scoreI)->IsSetId()  &&  (*scoreI)->GetId().IsStr()  &&
  249.                 (*scoreI)->GetId().GetStr() == id) {
  250.                 if ((*scoreI)->GetValue().IsInt()) {
  251.                     score = (*scoreI)->GetValue().GetInt();
  252.                 } else {
  253.                     score = (int) (*scoreI)->GetValue().GetReal();
  254.                 }
  255.                 return true;
  256.             }
  257.         }
  258.     }
  259.     return false;
  260. }
  262. ///---------------------------------------------------------------------------
  263. /// PRE : name of score to return
  264. /// POST: whether or not we found that score; score converted to double
  265. bool CSeq_align::GetNamedScore(const string &id, double &score) const
  266. {
  267.     if (IsSetScore()) {
  268.         const TScore &scores = GetScore();
  269.         ITERATE (TScore, scoreI, scores) {
  270.             if ((*scoreI)->IsSetId()  &&  (*scoreI)->GetId().IsStr()  &&
  271.                 (*scoreI)->GetId().GetStr() == id) {
  272.                 if ((*scoreI)->GetValue().IsInt()) {
  273.                     score = (double) (*scoreI)->GetValue().GetInt();
  274.                 } else {
  275.                     score = (*scoreI)->GetValue().GetReal();
  276.                 }
  277.                 return true;
  278.             }
  279.         }
  280.     }
  281.     return false;
  282. }
  284. void CSeq_align::Validate(bool full_test) const
  285. {
  286.     switch (GetSegs().Which()) {
  287.     case C_Segs::e_Denseg:
  288.         GetSegs().GetDenseg().Validate(full_test);
  289.         break;
  290.     case C_Segs::e_Std:
  291.         CheckNumRows();
  292.         break;
  293.     default:
  294.         NCBI_THROW(CSeqalignException, eUnsupported,
  295.                    "CSeq_align::Validate() currently does not handle "
  296.                    "this type of alignment");
  297.     }
  298. }
  301. ///---------------------------------------------------------------------------
  302. /// PRE : currently only implemented for dense-seg segments
  303. /// POST: same alignment, opposite orientation
  304. void CSeq_align::Reverse(void)
  305. {
  306.     switch (GetSegs().Which()) {
  307.     case C_Segs::e_Denseg:
  308.         SetSegs().SetDenseg().Reverse();
  309.         break;
  310.     default:
  311.         NCBI_THROW(CSeqalignException, eUnsupported,
  312.                    "CSeq_align::Reverse() currently only handles dense-seg "
  313.                    "alignments");
  314.     }
  315. }
  317. ///---------------------------------------------------------------------------
  318. /// PRE : currently only implemented for dense-seg segments; two row numbers
  319. /// POST: same alignment, position of the two rows has been swapped
  320. void CSeq_align::SwapRows(TDim row1, TDim row2)
  321. {
  322.     switch (GetSegs().Which()) {
  323.     case C_Segs::e_Denseg:
  324.         SetSegs().SetDenseg().SwapRows(row1, row2);
  325.         break;
  326.     case C_Segs::e_Disc:
  327.         SetSegs().SetDisc().SwapRows(row1, row2);
  328.         break;
  329.     default:
  330.         NCBI_THROW(CSeqalignException, eUnsupported,
  331.                    "CSeq_align::SwapRows currently only handles dense-seg "
  332.                    "alignments");
  333.     }
  334. }
  336. ///----------------------------------------------------------------------------
  337. /// PRE : the Seq-align has StdSeg segs
  338. /// POST: Seq_align of type Dense-seg is created with m_Widths if necessary
  339. CRef<CSeq_align> 
  340. CSeq_align::CreateDensegFromStdseg(SSeqIdChooser* SeqIdChooser) const
  341. {
  342.     if ( !GetSegs().IsStd() ) {
  343.         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  344.                    "CSeq_align::CreateDensegFromStdseg(): "
  345.                    "Input Seq-align should have segs of type StdSeg!");
  346.     }
  348.     CRef<CSeq_align> sa(new CSeq_align);
  349.     sa->SetType(eType_not_set);
  350.     CDense_seg& ds = sa->SetSegs().SetDenseg();
  352.     typedef CDense_seg::TDim    TNumrow;
  353.     typedef CDense_seg::TNumseg TNumseg;
  355.     vector<TSeqPos>       row_lens;
  356.     CDense_seg::TLens&    seg_lens = ds.SetLens();
  357.     CDense_seg::TStarts&  starts   = ds.SetStarts();
  358.     CDense_seg::TStrands& strands  = ds.SetStrands();
  359.     CDense_seg::TWidths&  widths   = ds.SetWidths();
  360.     vector<bool>          widths_determined;
  362.     TSeqPos row_len;
  363.     TSeqPos from, to;
  364.     ENa_strand strand;
  367.     TNumseg seg = 0;
  368.     TNumrow dim = 0, row = 0;
  369.     ITERATE (C_Segs::TStd, std_i, GetSegs().GetStd()) {
  371.         const CStd_seg& ss = **std_i;
  373.         seg_lens.push_back(0);
  374.         TSeqPos& seg_len = seg_lens.back();
  375.         row_len = 0;
  376.         row_lens.clear();
  377.         widths_determined.push_back(false);
  379.         row = 0;
  380.         ITERATE (CStd_seg::TLoc, i, ss.GetLoc()) {
  382.             const CSeq_id* seq_id = 0;
  383.             // push back initialization values
  384.             if (seg == 0) {
  385.                 widths.push_back(0);
  386.                 strands.push_back(eNa_strand_unknown);
  387.             }
  389.             if ((*i)->IsInt()) {
  390.                 const CSeq_interval& interval = (*i)->GetInt();
  391.                 
  392.                 // determine start and len
  393.                 from = interval.GetFrom();
  394.                 to = interval.GetTo();
  395.                 starts.push_back(from);
  396.                 row_len = to - from + 1;
  397.                 row_lens.push_back(row_len);
  398.                 
  399.                 int width = 0;
  400.                 // try to determine/check the seg_len and width
  401.                 if (!seg_len) {
  402.                     width = 0;
  403.                     seg_len = row_len;
  404.                 } else {
  405.                     if (row_len * 3 == seg_len) {
  406.                         seg_len /= 3;
  407.                         width = 1;
  408.                     } else if (row_len / 3 == seg_len) {
  409.                         width = 3;
  410.                     } else if (row_len != seg_len) {
  411.                         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  412.                                    "CreateDensegFromStdseg(): "
  413.                                    "Std-seg segment lengths not accurate!");
  414.                     }
  415.                 }
  416.                 if (width > 0) {
  417.                     widths_determined[seg] = true;
  418.                     if (widths[row] > 0  &&  widths[row] != width) {
  419.                         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  420.                                    "CreateDensegFromStdseg(): "
  421.                                    "Std-seg segment lengths not accurate!");
  422.                     } else {
  423.                         widths[row] = width;
  424.                     }
  425.                 }
  427.                 // get the id
  428.                 seq_id = &(*i)->GetInt().GetId();
  430.                 // determine/check the strand
  431.                 if (interval.CanGetStrand()) {
  432.                     strand = interval.GetStrand();
  433.                     if (seg == 0  ||  strands[row] == eNa_strand_unknown) {
  434.                         strands[row] = strand;
  435.                     } else {
  436.                         if (strands[row] != strand) {
  437.                             NCBI_THROW(CSeqalignException,
  438.                                        eInvalidInputAlignment,
  439.                                        "CreateDensegFromStdseg(): "
  440.                                        "Inconsistent strands!");
  441.                         }
  442.                     }
  443.                 } else {
  444.                     strand = eNa_strand_unknown;
  445.                 }
  447.                     
  448.             } else if ((*i)->IsEmpty()) {
  449.                 starts.push_back(-1);
  450.                 if (seg == 0) {
  451.                     strands[row] = eNa_strand_unknown;
  452.                 }
  453.                 seq_id = &(*i)->GetEmpty();
  454.                 row_lens.push_back(0);
  456.             }
  458.             // determine/check the id
  459.             if (seg == 0) {
  460.                 CRef<CSeq_id> id(new CSeq_id);
  461.                 SerialAssign(*id, *seq_id);
  462.                 ds.SetIds().push_back(id);
  463.             } else {
  464.                 CSeq_id& id = *ds.SetIds()[row];
  465.                 if (!SerialEquals(id, *seq_id)) {
  466.                     if (SeqIdChooser) {
  467.                         SeqIdChooser->ChooseSeqId(id, *seq_id);
  468.                     } else {
  469.                         string errstr =
  470.                             string("CreateDensegFromStdseg(): Seq-ids: ") +
  471.                             id.AsFastaString() + " and " +
  472.                             seq_id->AsFastaString() + " are not identical!" +
  473.                             " Without the OM it cannot be determined if they belong to"
  474.                             " the same sequence."
  475.                             " Define and pass ChooseSeqId to resolve seq-ids.";
  476.                         NCBI_THROW(CSeqalignException, eInvalidInputAlignment, errstr);
  477.                     }
  478.                 }
  479.             }
  481.             // next row
  482.             row++;
  483.             if (seg == 0) {
  484.                 dim++;
  485.             }
  486.         }
  487.         if (dim != ss.GetDim()  ||  row != dim) {
  488.             NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  489.                        "CreateDensegFromStdseg(): "
  490.                        "Inconsistent dimentions!");
  491.         }
  493.         if (widths_determined[seg]) {
  494.             // go back and determine/check widths
  495.             for (row = 0; row < dim; row++) {
  496.                 if ((row_len = row_lens[row]) > 0) {
  497.                     int width = 0;
  498.                     if (row_len == seg_len * 3) {
  499.                         width = 3;
  500.                     } else if (row_len == seg_len) {
  501.                         width = 1;
  502.                     }
  503.                     if (widths[row] > 0  &&  widths[row] != width) {
  504.                         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  505.                                    "CreateDensegFromStdseg(): "
  506.                                    "Std-seg segment lengths not accurate!");
  507.                     } else {
  508.                         widths[row] = width;
  509.                     }
  510.                 }
  511.             }
  512.         }
  514.         // next seg
  515.         seg++;
  516.     }
  518.     ds.SetDim(dim);
  519.     ds.SetNumseg(seg);
  521.     // go back and finish lens determination
  522.     bool widths_failure = false;
  523.     bool widths_success = false;
  524.     for (seg = 0; seg < ds.GetNumseg(); seg++) {
  525.         if (!widths_determined[seg]) {
  526.             for(row = 0; row < dim; row++) {
  527.                 if (starts[seg * dim + row] >= 0) {
  528.                     int width = widths[row];
  529.                     if (width == 3) {
  530.                         seg_lens[seg] /= 3;
  531.                     } else if (width == 0) {
  532.                         widths_failure = true;
  533.                     }
  534.                     break;
  535.                 }
  536.             }
  537.         } else {
  538.             widths_success = true;
  539.         }
  540.     }
  542.     if (widths_failure) {
  543.         if (widths_success) {
  544.             NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  545.                        "CreateDensegFromStdseg(): "
  546.                        "Some widths cannot be determined!");
  547.         } else {
  548.             ds.ResetWidths();
  549.         }
  550.     }
  551.     
  552.     // finish the strands
  553.     for (seg = 1; seg < ds.GetNumseg(); seg++) {
  554.         for (row = 0; row < dim; row++) {
  555.             strands.push_back(strands[row]);
  556.         }
  557.     }
  559.     return sa;
  560. }
  563. ///----------------------------------------------------------------------------
  564. /// PRE : the Seq-align is a Dense-seg of aligned nucleotide sequences
  565. /// POST: Seq_align of type Dense-seg is created with each of the m_Widths 
  566. ///       equal to 3 and m_Lengths devided by 3.
  567. CRef<CSeq_align> 
  568. CSeq_align::CreateTranslatedDensegFromNADenseg() const
  569. {
  570.     if ( !GetSegs().IsDenseg() ) {
  571.         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  572.                    "CSeq_align::CreateTranslatedDensegFromNADenseg(): "
  573.                    "Input Seq-align should have segs of type Dense-seg!");
  574.     }
  575.     
  576.     CRef<CSeq_align> sa(new CSeq_align);
  577.     sa->SetType(eType_not_set);
  579.     if (GetSegs().GetDenseg().IsSetWidths()) {
  580.         NCBI_THROW(CSeqalignException, eInvalidInputAlignment,
  581.                    "CSeq_align::CreateTranslatedDensegFromNADenseg(): "
  582.                    "Widths already exist for the original alignment");
  583.     }
  585.     // copy from the original
  586.     sa->Assign(*this);
  588.     CDense_seg& ds = sa->SetSegs().SetDenseg();
  590.     // fix the lengths
  591.     const CDense_seg::TLens& orig_lens = GetSegs().GetDenseg().GetLens();
  592.     CDense_seg::TLens&       lens      = ds.SetLens();
  594.     for (CDense_seg::TNumseg numseg = 0; numseg < ds.GetNumseg(); numseg++) {
  595.         if (orig_lens[numseg] % 3) {
  596.             string errstr =
  597.                 string("CSeq_align::CreateTranslatedDensegFromNADenseg(): ") +
  598.                 "Length of segment " + NStr::IntToString(numseg) +
  599.                 " is not divisible by 3.";
  600.             NCBI_THROW(CSeqalignException, eInvalidInputAlignment, errstr);
  601.         } else {
  602.             lens[numseg] = orig_lens[numseg] / 3;
  603.         }
  604.     }
  606.     // add the widths
  607.     ds.SetWidths().resize(ds.GetDim(), 3);
  609. #if _DEBUG
  610.     ds.Validate(true);
  611. #endif
  613.     return sa;
  614. }
  617. END_objects_SCOPE // namespace ncbi::objects::
  619. END_NCBI_SCOPE
  622. /*
  623. * ===========================================================================
  624. *
  625. * $Log: Seq_align.cpp,v $
  626. * Revision 1000.2  2004/06/01 19:33:39  gouriano
  627. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.16
  628. *
  629. * Revision 1.16  2004/05/19 17:25:43  gorelenk
  630. * Added include of PCH - ncbi_pch.hpp
  631. *
  632. * Revision 1.15  2004/05/05 19:16:25  johnson
  633. * Added SwapRows method for 'disc' seq-align / seq-align-set
  634. *
  635. * Revision 1.14  2004/04/27 19:17:13  johnson
  636. * Added GetNamedScore helper function
  637. *
  638. * Revision 1.13  2004/04/19 17:27:22  grichenk
  639. * Added GetSeq_id(TDim row)
  640. *
  641. * Revision 1.12  2004/04/12 16:51:02  vasilche
  642. * Fixed uninitialized variables.
  643. *
  644. * Revision 1.11  2004/03/09 17:27:42  kuznets
  645. * Bug fix(compilation): CSeq_align::CreateDensegFromStdseg MSVC
  646. *
  647. * Revision 1.10  2004/03/09 17:14:33  todorov
  648. * changed the C-style callback to a functor
  649. *
  650. * Revision 1.9  2004/02/23 15:31:24  todorov
  651. * +TChooseSeqIdCallback to abstract resolving seq-ids in CreateDensegFromStdseg()
  652. *
  653. * Revision 1.8  2004/02/13 17:10:24  todorov
  654. * - inconsistent ids exception in CreateDensegFromStdseg
  655. *
  656. * Revision 1.7  2004/01/09 16:32:06  todorov
  657. * +SetType(eType_not_set)
  658. *
  659. * Revision 1.6  2003/12/16 22:54:31  todorov
  660. * +CreateTranslatedDensegFromNADenseg
  661. *
  662. * Revision 1.5  2003/12/11 22:34:05  todorov
  663. * Implementation of GetSeq{Start,Stop}
  664. *
  665. * Revision 1.4  2003/09/16 15:31:14  todorov
  666. * Added validation methods. Added seq range methods
  667. *
  668. * Revision 1.3  2003/08/26 20:28:38  johnson
  669. * added 'SwapRows' method
  670. *
  671. * Revision 1.2  2003/08/19 21:11:13  todorov
  672. * +CreateDensegFromStdseg
  673. *
  674. * Revision 1.1  2003/08/13 18:12:03  johnson
  675. * added 'Reverse' method
  676. *
  677. *
  678. * ===========================================================================
  679. */
  680. /* Original file checksum: lines: 64, chars: 1885, CRC32: 4e5d1825 */