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

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

生物技术

开发平台：

C/C++

utils.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: utils.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:45:35  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: utils.cpp,v 1000.1 2004/06/01 19:45: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:  Mati Shomrat, NCBI
  36. *
  37. * File Description:
  38. *   shared utility functions
  39. *
  40. */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbistd.hpp>
  44. #include <objects/general/Date.hpp>
  45. #include <objects/general/User_object.hpp>
  46. #include <objects/general/User_field.hpp>
  47. #include <objects/general/Object_id.hpp>
  48. #include <objects/seq/Bioseq.hpp>
  49. #include <objects/seq/Seq_inst.hpp>
  50. #include <objects/seq/Seq_ext.hpp>
  51. #include <objects/seq/Delta_ext.hpp>
  52. #include <objects/seq/Delta_seq.hpp>
  53. #include <objects/seq/Seq_literal.hpp>
  54. #include <objects/seq/MolInfo.hpp>
  55. #include <objects/seq/seqport_util.hpp>
  56. #include <objects/seqloc/Seq_loc.hpp>
  57. #include <objmgr/scope.hpp>
  58. #include <objmgr/bioseq_handle.hpp>
  59. #include <objmgr/seqdesc_ci.hpp>
  60. #include <objmgr/util/sequence.hpp>
  62. #include "utils.hpp"
  65. BEGIN_NCBI_SCOPE
  66. BEGIN_SCOPE(objects)
  69. string ExpandTildes(const string& s, ETildeStyle style)
  70. {
  71.     if ( style == eTilde_tilde ) {
  72.         return s;
  73.     }
  75.     SIZE_TYPE start = 0, tilde, length = s.length();
  76.     string result;
  78.     while ( (start < length)  &&  (tilde = s.find('~', start)) != NPOS ) {
  79.         result += s.substr(start, tilde - start);
  80.         char next = (tilde + 1) < length ? s[tilde + 1] : 0;
  81.         switch ( style ) {
  82.         case eTilde_space:
  83.             if ( (tilde + 1 < length  &&  isdigit(next) )  ||
  84.                  (tilde + 2 < length  &&  (next == ' '  ||  next == '(')  &&
  85.                   isdigit(s[tilde + 2]))) {
  86.                 result += '~';
  87.             } else {
  88.                 result += ' ';
  89.             }
  90.             start = tilde + 1;
  91.             break;
  92.             
  93.         case eTilde_newline:
  94.             if ( tilde + 1 < length  &&  s[tilde + 1] == '~' ) {
  95.                 result += '~';
  96.                 start = tilde + 2;
  97.             } else {
  98.                 result += 'n';
  99.                 start = tilde + 1;
  100.             }
  101.             break;
  102.             
  103.         default: // just keep it, for lack of better ideas
  104.             result += '~';
  105.             start = tilde + 1;
  106.             break;
  107.         }
  108.     }
  109.     result += s.substr(start);
  110.     return result;
  111. }
  114. void StripSpaces(string& str)
  115. {
  116.     if ( str.empty() ) {
  117.         return;
  118.     }
  120.     string::iterator new_str = str.begin();
  121.     NON_CONST_ITERATE(string, it, str) {
  122.         *new_str++ = *it;
  123.         if ( (*it == ' ')  ||  (*it == 't')  ||  (*it == '(') ) {
  124.             for (++it; *it == ' ' || *it == 't'; ++it) continue;
  125.             if (*it == ')' || *it == ',') {
  126.                 new_str--;
  127.             }
  128.         } else {
  129.             it++;
  130.         }
  131.     }
  132.     str.erase(new_str, str.end());
  133. }
  136. bool RemovePeriodFromEnd(string& str, bool keep_ellipsis)
  137. {
  138.     static const string period = ".";
  139.     static const string ellipsis = "...";
  141.     if ( NStr::EndsWith(str, period) ) {
  142.         if ( !keep_ellipsis  ||  !NStr::EndsWith(str, ellipsis) ) {
  143.             str.erase(str.length() - 1);
  144.             return true;
  145.         }
  146.     }
  148.     return false;
  149. }
  152. static bool s_IsWholeWord(const string& str, size_t pos, const string& word)
  153. {
  154.     // NB: To preserve the behavior of the C toolkit we only test on the left.
  155.     // This was an old bug in the C toolkit that was never fixed and by now
  156.     // has become the expected behavior.
  157.     return (pos > 0) ?
  158.         isspace(str[pos - 1])  ||  ispunct(str[pos - 1]) : true;
  159. }
  162. void JoinNoRedund(string& to, const string& prefix, const string& str)
  163. {
  164.     if ( str.empty() ) {
  165.         return;
  166.     }
  168.     if ( to.empty() ) {
  169.         to += str;
  170.         return;
  171.     }
  172.     
  173.     size_t pos = NPOS;
  174.     for ( pos = NStr::Find(to, str);
  175.           pos != NPOS  &&  !s_IsWholeWord(to, pos, str);
  176.           pos += str.length());
  178.     if ( pos == NPOS  ||  !s_IsWholeWord(to, pos, str) ) {
  179.         to += prefix;
  180.         to += str;
  181.     }
  182. }
  185. string JoinNoRedund(const list<string>& l, const string& delim)
  186. {
  187.     if ( l.empty() ) {
  188.         return kEmptyStr;
  189.     }
  191.     string result = l.front();
  192.     list<string>::const_iterator it = l.begin();
  193.     while ( ++it != l.end() ) {
  194.         JoinNoRedund(result, delim, *it);
  195.     }
  197.     return result;
  198. }
  201. // Validate the correct format of an accession string.
  202. bool ValidateAccession(const string& acc)
  203. {
  204.     if ( acc.empty() ) {
  205.         return false;
  206.     }
  208.     if ( acc.length() >= 16 ) {
  209.         return false;
  210.     }
  212.     // first character must be uppercase letter
  213.     if ( !(isalpha(acc[0])  &&  isupper(acc[0])) ) {
  214.         return false;
  215.     }
  217.     size_t num_alpha   = 0,
  218.            num_undersc = 0,
  219.            num_digits  = 0;
  221.     const char* ptr = acc.c_str();
  222.     if ( NStr::StartsWith(acc, "NZ_") ) {
  223.         ptr += 3;
  224.     }
  225.     for ( ; isalpha(*ptr); ++ptr, ++num_alpha );
  226.     for ( ; *ptr == '_'; ++ptr, ++num_undersc );
  227.     for ( ; isdigit(*ptr); ++ptr, ++num_digits );
  229.     if ( (*ptr != '')  &&  (*ptr != ' ')  &&  (*ptr != '.') ) {
  230.         return false;
  231.     }
  233.     switch ( num_undersc ) {
  234.     case 0:
  235.         {{
  236.             if ( (num_alpha == 1  &&  num_digits == 5)  ||
  237.                  (num_alpha == 2  &&  num_digits == 6)  ||
  238.                  (num_alpha == 3  &&  num_digits == 5)  || 
  239.                  (num_alpha == 4  &&  num_digits == 8) ) {
  240.                 return true;
  241.             }
  242.         }}
  243.         break;
  245.     case 1:
  246.         {{
  247.             // RefSeq accession
  248.             if ( (num_alpha != 2)  ||
  249.                  (num_digits != 6  &&  num_digits != 8  &&  num_digits != 9) ) {
  250.                 return false;
  251.             }
  252.             
  253.             char first_letter = acc[0];
  254.             char second_letter = acc[1];
  256.             if ( first_letter == 'N' ) {
  257.                 if ( second_letter == 'C'  ||  second_letter == 'G'  ||
  258.                      second_letter == 'M'  ||  second_letter == 'R'  ||
  259.                      second_letter == 'P'  ||  second_letter == 'W'  ||
  260.                      second_letter == 'T' ) {
  261.                     return true;
  262.                 }
  263.             } else if ( first_letter == 'X' ) {
  264.                 if ( second_letter == 'M'  ||  second_letter == 'R'  ||
  265.                      second_letter == 'P' ) {
  266.                     return true;
  267.                 }
  268.             } else if ( first_letter == 'Z' ) {
  269.                 if ( second_letter == 'P' ) {
  270.                     return true;
  271.                 }
  272.             }
  273.         }}
  274.         break;
  276.     default:
  277.         return false;
  278.     }
  280.     return false;
  281. }
  284. void DateToString(const CDate& date, string& str,  bool is_cit_sub)
  285. {
  286.     static const string regular_format  = "%{%2D%|01%}-%{%3N%|JUN%}-%Y";
  287.     static const string cit_sub_format = "%{%2D%|??%}-%{%3N%|???%}-%Y";
  289.     const string& format = is_cit_sub ? cit_sub_format : regular_format;
  291.     string date_str;
  292.     date.GetDate(&date_str, format);
  293.     NStr::ToUpper(date_str);
  295.     str.append(date_str);
  296. }
  299. void GetDeltaSeqSummary(const CBioseq_Handle& seq, SDeltaSeqSummary& summary)
  300. {
  301.     if ( !seq.IsSetInst()                                ||
  302.          !seq.IsSetInst_Repr()                           ||
  303.          !(seq.GetInst_Repr() == CSeq_inst::eRepr_delta) ||
  304.          !seq.IsSetInst_Ext()                            ||
  305.          !seq.GetInst_Ext().IsDelta() ) {
  306.         return;
  307.     }
  309.     SDeltaSeqSummary temp;
  310.     CScope& scope = seq.GetScope();
  312.     const CDelta_ext::Tdata& segs = seq.GetInst_Ext().GetDelta().Get();
  313.     temp.num_segs = segs.size();
  314.     
  315.     size_t len = 0;
  317.     CNcbiOstrstream text;
  319.     CDelta_ext::Tdata::const_iterator curr = segs.begin();
  320.     CDelta_ext::Tdata::const_iterator end = segs.end();
  321.     CDelta_ext::Tdata::const_iterator next;
  322.     for ( ; curr != end; curr = next ) {
  323.         {{
  324.             // set next to one after curr
  325.             next = curr; ++next;
  326.         }}
  327.         size_t from = len + 1;
  328.         switch ( (*curr)->Which() ) {
  329.         case CDelta_seq::e_Loc:
  330.             {{
  331.                 const CDelta_seq::TLoc& loc = (*curr)->GetLoc();
  332.                 if ( loc.IsNull() ) {  // gap
  333.                     ++temp.num_gaps;
  334.                     text << "* " << from << ' ' << len 
  335.                          << " gap of unknown length~";
  336.                 } else {
  337.                     size_t tlen = sequence::GetLength(loc, &scope);
  338.                     len += tlen;
  339.                     temp.residues += tlen;
  340.                     text << "* " << from << " " << len << ": contig of " 
  341.                         << tlen << " bp in length~";
  342.                 }
  343.             }}  
  344.             break;
  345.         case CDelta_seq::e_Literal:
  346.             {{
  347.                 const CDelta_seq::TLiteral& lit = (*curr)->GetLiteral();
  348.                 size_t lit_len = lit.CanGetLength() ? lit.GetLength() : 0;
  349.                 len += lit_len;
  350.                 if ( lit.CanGetSeq_data() ) {
  351.                     temp.residues += lit_len;
  352.                     while ( next != end  &&  (*next)->IsLiteral()  &&
  353.                         (*next)->GetLiteral().CanGetSeq_data() ) {
  354.                         const CDelta_seq::TLiteral& next_lit = (*next)->GetLiteral();
  355.                         size_t next_len = next_lit.CanGetLength() ?
  356.                             next_lit.GetLength() : 0;
  357.                         lit_len += next_len;
  358.                         len += next_len;
  359.                         temp.residues += next_len;
  360.                         ++next;
  361.                     }
  362.                     text << "* " << from << " " << len << ": contig of " 
  363.                          << lit_len << " bp in length~";
  364.                 } else {
  365.                     bool unk = false;
  366.                     ++temp.num_gaps;
  367.                     if ( lit.CanGetFuzz() ) {
  368.                         const CSeq_literal::TFuzz& fuzz = lit.GetFuzz();
  369.                         if ( fuzz.IsLim()  &&  
  370.                              fuzz.GetLim() == CInt_fuzz::eLim_unk ) {
  371.                             unk = true;
  372.                             ++temp.num_faked_gaps;
  373.                             if ( from > len ) {
  374.                                 text << "*                    gap of unknown length~";
  375.                             } else {
  376.                                 text << "* " << from << " " << len 
  377.                                      << ": gap of unknown length~";
  378.                             }
  379.                         }
  380.                     }
  381.                     if ( !unk ) {
  382.                         text << "* " << from << " " << len << ": gap of "
  383.                              << lit_len << " bp~";
  384.                     }
  385.                 }
  386.             }}
  387.             break;
  389.         default:
  390.             break;
  391.         }
  392.     }
  393.     summary = temp;
  394.     summary.text = CNcbiOstrstreamToString(text);
  395. }
  398. const string& GetTechString(int tech)
  399. {
  400.     static const string concept_trans_str = "conceptual translation";
  401.     static const string seq_pept_str = "direct peptide sequencing";
  402.     static const string both_str = "conceptual translation with partial peptide sequencing";
  403.     static const string seq_pept_overlap_str = "sequenced peptide, ordered by overlap";
  404.     static const string seq_pept_homol_str = "sequenced peptide, ordered by homology";
  405.     static const string concept_trans_a_str = "conceptual translation supplied by author";
  406.     
  407.     switch ( tech ) {
  408.     case CMolInfo::eTech_concept_trans:
  409.         return concept_trans_str;
  411.     case CMolInfo::eTech_seq_pept :
  412.         return seq_pept_str;
  414.     case CMolInfo::eTech_both:
  415.         return both_str;
  417.     case CMolInfo::eTech_seq_pept_overlap:
  418.         return seq_pept_overlap_str;
  420.     case CMolInfo::eTech_seq_pept_homol:
  421.         return seq_pept_homol_str;
  423.     case CMolInfo::eTech_concept_trans_a:
  424.         return concept_trans_a_str;
  426.     default:
  427.         return kEmptyStr;
  428.     }
  430.     return kEmptyStr;
  431. }
  434. bool s_IsModelEvidanceUop(const CUser_object& uo)
  435. {
  436.     return (uo.CanGetType()  &&  uo.GetType().IsStr()  &&
  437.         uo.GetType().GetStr() == "ModelEvidence");
  438. }
  441. const CUser_object* s_FindModelEvidanceUop(const CUser_object& uo)
  442. {
  443.     if ( s_IsModelEvidanceUop(uo) ) {
  444.         return &uo;
  445.     }
  447.     const CUser_object* temp = 0;
  448.     ITERATE (CUser_object::TData, ufi, uo.GetData()) {
  449.         const CUser_field& uf = **ufi;
  450.         if ( !uf.CanGetData() ) {
  451.             continue;
  452.         }
  453.         const CUser_field::TData& data = uf.GetData();
  455.         switch ( data.Which() ) {
  456.         case CUser_field::TData::e_Object:
  457.             temp = s_FindModelEvidanceUop(data.GetObject());
  458.             break;
  460.         case CUser_field::TData::e_Objects:
  461.             ITERATE (CUser_field::TData::TObjects, obj, data.GetObjects()) {
  462.                 temp = s_FindModelEvidanceUop(**obj);
  463.                 if ( temp != 0 ) {
  464.                     break;
  465.                 }
  466.             }
  467.             break;
  469.         default:
  470.             break;
  471.         }
  472.         if ( temp != 0 ) {
  473.             break;
  474.         }
  475.     }
  477.     return temp;
  478. }
  481. bool s_GetModelEvidance(const CBioseq_Handle& bsh, SModelEvidance& me)
  482. {
  483.     const CUser_object* moduop = 0;
  484.     bool result = false;
  486.     for (CSeqdesc_CI it(bsh, CSeqdesc::e_User);  it;  ++it) {
  487.         const CUser_object* modup = s_FindModelEvidanceUop(it->GetUser());
  488.         if ( modup != 0 ) {
  489.             result = true;
  490.             const CUser_field* ufp = 0;
  491.             if ( moduop->HasField("Contig Name") ) {
  492.                 ufp = &(moduop->GetField("Contig Name"));
  493.                 if ( ufp->CanGetData()  &&  ufp->GetData().IsStr() ) {
  494.                     me.name = ufp->GetData().GetStr();
  495.                 }
  496.             }
  497.             if ( moduop->HasField("Method") ) {
  498.                 ufp = &(moduop->GetField("Method"));
  499.                 if ( ufp->CanGetData()  &&  ufp->GetData().IsStr() ) {
  500.                     me.method = ufp->GetData().GetStr();
  501.                 }
  502.             }
  503.             if ( moduop->HasField("mRNA") ) {
  504.                 me.mrnaEv = true;
  505.             }
  506.             if ( moduop->HasField("EST") ) {
  507.                 me.estEv = true;
  508.             }
  509.         }
  510.     }
  512.     return result;
  513. }
  516. bool GetModelEvidance(const CBioseq_Handle& bsh, SModelEvidance& me)
  517. {
  518.     if ( s_GetModelEvidance(bsh, me) ) {
  519.         return true;
  520.     }
  522.     if ( CSeq_inst::IsAa(bsh.GetInst_Mol()) ) {
  523.         CBioseq_Handle nuc = sequence::GetNucleotideParent(bsh);
  524.         if ( nuc  ) {
  525.             return s_GetModelEvidance(nuc, me);
  526.         }
  527.     }
  529.     return false;
  530. }
  533. // in Ncbistdaa order
  534. static const char* kAANames[] = {
  535.     "---", "Ala", "Asx", "Cys", "Asp", "Glu", "Phe", "Gly", "His", "Ile",
  536.     "Lys", "Leu", "Met", "Asn", "Pro", "Glu", "Arg", "Ser", "Thr", "Val",
  537.     "Trp", "OTHER", "Tyr", "Glx", "Sec", "TERM"
  538. };
  541. const char* GetAAName(unsigned char aa, bool is_ascii)
  542. {
  543.     if (is_ascii) {
  544.         aa = CSeqportUtil::GetMapToIndex
  545.             (CSeq_data::e_Ncbieaa, CSeq_data::e_Ncbistdaa, aa);
  546.     }
  547.     return (aa < sizeof(kAANames)/sizeof(*kAANames)) ? kAANames[aa] : "OTHER";
  548. }
  551. END_SCOPE(objects)
  552. END_NCBI_SCOPE
  555. /*
  556. * ===========================================================================
  557. *
  558. * $Log: utils.cpp,v $
  559. * Revision 1000.1  2004/06/01 19:45:35  gouriano
  560. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  561. *
  562. * Revision 1.10  2004/05/26 14:08:14  shomrat
  563. * ValidateAccession allow 2 letters + underscore + 9 digits
  564. *
  565. * Revision 1.9  2004/05/21 21:42:54  gorelenk
  566. * Added PCH ncbi_pch.hpp
  567. *
  568. * Revision 1.8  2004/05/07 15:23:14  shomrat
  569. * + RemovePeriodFromEnd
  570. *
  571. * Revision 1.7  2004/04/22 15:54:47  shomrat
  572. * Use CBioseq_Handle instead of CBioseq
  573. *
  574. * Revision 1.6  2004/04/07 14:29:16  shomrat
  575. * + GetAAName
  576. *
  577. * Revision 1.5  2004/03/25 20:47:26  shomrat
  578. * Use handles
  579. *
  580. * Revision 1.4  2004/03/18 15:35:17  shomrat
  581. * Fixes in JoinNoRedund
  582. *
  583. * Revision 1.3  2004/03/08 20:55:32  shomrat
  584. * Use case sensetive search when looking for redundent content
  585. *
  586. * Revision 1.2  2004/02/11 16:57:34  shomrat
  587. * added JoinNoRedund functions
  588. *
  589. * Revision 1.1  2003/12/17 20:25:01  shomrat
  590. * Initial Revision (adapted from flat lib)
  591. *
  592. *
  593. * ===========================================================================
  594. */