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

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

生物技术

开发平台：

C/C++

Seq_id.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Seq_id.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:34:28  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.81
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: Seq_id.cpp,v 1000.4 2004/06/01 19:34:28 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 ASN data definition file
  43.  *   'seqloc.asn'.
  44.  */
  46. // standard includes
  48. // generated includes
  49. #include <ncbi_pch.hpp>
  50. #include <corelib/ncbiutil.hpp>
  51. #include <objects/seq/Bioseq.hpp>
  52. #include <objects/seq/Seq_inst.hpp>
  54. #include <objects/seqloc/Seq_id.hpp>
  55. #include <objects/seqloc/Textseq_id.hpp>
  56. #include <objects/seqloc/Giimport_id.hpp>
  57. #include <objects/seqloc/Patent_seq_id.hpp>
  58. #include <objects/seqloc/PDB_seq_id.hpp>
  60. #include <objects/biblio/Id_pat.hpp>
  62. #include <objects/general/Object_id.hpp>
  63. #include <objects/general/Dbtag.hpp>
  64. #include <objects/general/Date.hpp>
  65. #include <objects/general/Date_std.hpp>
  67. #include <objects/general/Date.hpp>
  69. // generated classes
  71. BEGIN_NCBI_SCOPE
  72. BEGIN_objects_SCOPE // namespace ncbi::objects::
  75. // constructor
  76. CSeq_id::CSeq_id(void)
  77. {
  78.     return;
  79. }
  81. // destructor
  82. CSeq_id::~CSeq_id(void)
  83. {
  84.     return;
  85. }
  88. const CTextseq_id* CSeq_id::GetTextseq_Id(void) const
  89. {
  90.     switch ( Which() ) {
  91.     case e_Genbank:
  92.         return &GetGenbank();
  93.     case e_Embl:
  94.         return &GetEmbl();
  95.     case e_Ddbj:
  96.         return &GetDdbj();
  97.     case e_Pir:
  98.         return &GetPir();
  99.     case e_Swissprot:
  100.         return &GetSwissprot();
  101.     case e_Other:
  102.         return &GetOther();
  103.     case e_Prf:
  104.         return &GetPrf();
  105.     case e_Tpg:
  106.         return &GetTpg();
  107.     case e_Tpe:
  108.         return &GetTpe();
  109.     case e_Tpd:
  110.         return &GetTpd();
  111.     default:
  112.         return 0;
  113.     }
  114. }
  117. inline
  118. void x_Assign(CObject_id& dst, const CObject_id& src)
  119. {
  120.     switch ( src.Which() ) {
  121.     case CObject_id::e_not_set:
  122.         dst.Reset();
  123.         return;
  124.     case CObject_id::e_Id:
  125.         dst.SetId(src.GetId());
  126.         return;
  127.     case CObject_id::e_Str:
  128.         dst.SetStr(src.GetStr());
  129.         return;
  130.     default:
  131.         THROW1_TRACE(runtime_error, "invalid Object-id variant");
  132.     }
  133. }
  136. inline
  137. void x_Assign(CGiimport_id& dst, const CGiimport_id& src)
  138. {
  139.     dst.SetId(src.GetId());
  140.     if ( src.IsSetDb() ) {
  141.         dst.SetDb(src.GetDb());
  142.     }
  143.     else {
  144.         dst.ResetDb();
  145.     }
  146.     if ( src.IsSetRelease() ) {
  147.         dst.SetRelease(src.GetRelease());
  148.     }
  149.     else {
  150.         dst.ResetRelease();
  151.     }
  152. }
  155. inline
  156. void x_Assign(CTextseq_id& dst, const CTextseq_id& src)
  157. {
  158.     if ( src.IsSetName() ) {
  159.         dst.SetName(src.GetName());
  160.     }
  161.     else {
  162.         dst.ResetName();
  163.     }
  164.     if ( src.IsSetAccession() ) {
  165.         dst.SetAccession(src.GetAccession());
  166.     }
  167.     else {
  168.         dst.ResetAccession();
  169.     }
  170.     if ( src.IsSetRelease() ) {
  171.         dst.SetRelease(src.GetRelease());
  172.     }
  173.     else {
  174.         dst.ResetRelease();
  175.     }
  176.     if ( src.IsSetVersion() ) {
  177.         dst.SetVersion(src.GetVersion());
  178.     }
  179.     else {
  180.         dst.ResetVersion();
  181.     }
  182. }
  185. inline
  186. void x_Assign(CDbtag& dst, const CDbtag& src)
  187. {
  188.     dst.SetDb(src.GetDb());
  189.     x_Assign(dst.SetTag(), src.GetTag());
  190. }
  193. inline
  194. void x_Assign(CPatent_seq_id& dst, const CPatent_seq_id& src)
  195. {
  196.     dst.SetSeqid(src.GetSeqid());
  197.     dst.SetCit().Assign(src.GetCit());
  198. }
  201. inline
  202. void x_Assign(CDate& dst, const CDate& src)
  203. {
  204.     dst.Assign(src);
  205. }
  208. inline
  209. void x_Assign(CPDB_seq_id& dst, const CPDB_seq_id& src)
  210. {
  211.     dst.SetMol().Set(src.GetMol());
  212.     if ( src.IsSetChain() ) {
  213.         dst.SetChain(src.GetChain());
  214.     }
  215.     else {
  216.         dst.ResetChain();
  217.     }
  218.     if ( src.IsSetRel() ) {
  219.         dst.SetRel().Assign(src.GetRel());
  220.     }
  221.     else {
  222.         dst.ResetRel();
  223.     }
  224. }
  227. void CSeq_id::Assign(const CSerialObject& obj, ESerialRecursionMode how)
  228. {
  229.     if ( GetTypeInfo() == obj.GetThisTypeInfo() ) {
  230.         const CSeq_id& id = static_cast<const CSeq_id&>(obj);
  231.         switch ( id.Which() ) {
  232.         case e_not_set:
  233.             Reset();
  234.             return;
  235.         case e_Local:
  236.             x_Assign(SetLocal(), id.GetLocal());
  237.             return;
  238.         case e_Gibbsq:
  239.             SetGibbsq(id.GetGibbsq());
  240.             return;
  241.         case e_Gibbmt:
  242.             SetGibbmt(id.GetGibbmt());
  243.             return;
  244.         case e_Giim:
  245.             x_Assign(SetGiim(), id.GetGiim());
  246.             return;
  247.         case e_Pir:
  248.             x_Assign(SetPir(), id.GetPir());
  249.             return;
  250.         case e_Swissprot:
  251.             x_Assign(SetSwissprot(), id.GetSwissprot());
  252.             return;
  253.         case e_Patent:
  254.             x_Assign(SetPatent(), id.GetPatent());
  255.             return;
  256.         case e_Other:
  257.             x_Assign(SetOther(), id.GetOther());
  258.             return;
  259.         case e_General:
  260.             x_Assign(SetGeneral(), id.GetGeneral());
  261.             return;
  262.         case e_Gi:
  263.             SetGi(id.GetGi());
  264.             return;
  265.         case e_Prf:
  266.             x_Assign(SetPrf(), id.GetPrf());
  267.             return;
  268.         case e_Pdb:
  269.             x_Assign(SetPdb(), id.GetPdb());
  270.             return;
  271.         case e_Genbank:
  272.             x_Assign(SetGenbank(), id.GetGenbank());
  273.             return;
  274.         case e_Embl:
  275.             x_Assign(SetEmbl(), id.GetEmbl());
  276.             return;
  277.         case e_Ddbj:
  278.             x_Assign(SetDdbj(), id.GetDdbj());
  279.             return;
  280.         case e_Tpg:
  281.             x_Assign(SetTpg(), id.GetTpg());
  282.             return;
  283.         case e_Tpe:
  284.             x_Assign(SetTpe(), id.GetTpe());
  285.             return;
  286.         case e_Tpd:
  287.             x_Assign(SetTpd(), id.GetTpd());
  288.             return;
  289.         }
  290.     }
  291.     CSerialObject::Assign(obj, how);
  292. }
  295. // Compare() - are SeqIds equivalent?
  296. CSeq_id::E_SIC CSeq_id::Compare(const CSeq_id& sid2) const
  297. {
  298.     if ( Which() != sid2.Which() ) { // Only one case where this will work
  299.         const CTextseq_id *tsip1 = GetTextseq_Id();
  300.         if ( !tsip1 )
  301.             return e_DIFF;
  303.         const CTextseq_id *tsip2 = sid2.GetTextseq_Id();
  304.         if ( !tsip2 )
  305.             return e_DIFF;
  307.         if ( tsip1->Match(*tsip2) ) // id Textseq_id match
  308.             return e_YES;
  309.         else
  310.             return e_NO;
  311.     }
  313.     switch ( Which() ) { // Now we only need to know one
  314.     case e_Local:
  315.         return GetLocal().Match(sid2.GetLocal()) ? e_YES : e_NO;
  316.     case e_Gibbsq:
  317.         return GetGibbsq() == sid2.GetGibbsq() ? e_YES : e_NO;
  318.     case e_Gibbmt:
  319.         return GetGibbmt() == sid2.GetGibbmt() ? e_YES : e_NO;
  320.     case e_Giim:
  321.         return GetGiim().GetId() == sid2.GetGiim().GetId() ? e_YES : e_NO;
  322.     case e_Pir:
  323.         return GetPir().Match(sid2.GetPir()) ? e_YES : e_NO;
  324.     case e_Swissprot:
  325.         return GetSwissprot().Match(sid2.GetSwissprot()) ? e_YES : e_NO;
  326.     case e_Patent:
  327.         return GetPatent().Match(sid2.GetPatent()) ? e_YES : e_NO;
  328.     case e_Other:
  329.         return GetOther().Match(sid2.GetOther()) ? e_YES : e_NO;
  330.     case e_General:
  331.         return GetGeneral().Match(sid2.GetGeneral()) ? e_YES : e_NO;
  332.     case e_Gi:
  333.         return GetGi() == sid2.GetGi() ? e_YES : e_NO;
  334.     case e_Prf:
  335.         return GetPrf().Match(sid2.GetPrf()) ? e_YES : e_NO;
  336.     case e_Pdb:
  337.         return GetPdb().Match(sid2.GetPdb()) ? e_YES : e_NO;
  338.     case e_Genbank:
  339.         return GetGenbank().Match(sid2.GetGenbank()) ? e_YES : e_NO;
  340.     case e_Embl:
  341.         return GetEmbl().Match(sid2.GetEmbl()) ? e_YES : e_NO;
  342.     case e_Ddbj:
  343.         return GetDdbj().Match(sid2.GetDdbj()) ? e_YES : e_NO;
  344.     case e_Tpg:
  345.         return GetTpg().Match(sid2.GetTpg()) ? e_YES : e_NO;
  346.     case e_Tpe:
  347.         return GetTpe().Match(sid2.GetTpe()) ? e_YES : e_NO;
  348.     case e_Tpd:
  349.         return GetTpd().Match(sid2.GetTpd()) ? e_YES : e_NO;
  350.     default:
  351.         return e_error;
  352.     }
  353. }
  356. int CSeq_id::CompareOrdered(const CSeq_id& sid2) const
  357. {
  358.     int ret = Which() - sid2.Which();
  359.     if ( ret != 0 ) {
  360.         return ret;
  361.     }
  362.     const CTextseq_id *tsip1 = GetTextseq_Id();
  363.     const CTextseq_id *tsip2 = sid2.GetTextseq_Id();
  364.     if ( tsip1 && tsip2 ) {
  365.         return tsip1->Compare(*tsip2);
  366.     }
  367.     switch ( Which() ) { // Now we only need to know one
  368.     case e_Local:
  369.         return GetLocal().Compare(sid2.GetLocal());
  370.     case e_Gibbsq:
  371.         return GetGibbsq() - sid2.GetGibbsq();
  372.     case e_Gibbmt:
  373.         return GetGibbmt() - sid2.GetGibbmt();
  374.     case e_Giim:
  375.         return GetGiim().GetId() - sid2.GetGiim().GetId();
  376.     case e_Patent:
  377.         return GetPatent().Compare(sid2.GetPatent());
  378.     case e_General:
  379.         return GetGeneral().Compare(sid2.GetGeneral());
  380.     case e_Gi:
  381.         return GetGi() - sid2.GetGi();
  382.     case e_Pdb:
  383.         return 0;
  384.     default:
  385.         return this == &sid2? 0: this < &sid2? -1: 1;
  386.     }
  387. }
  390. static const char* const s_TextId[20] = {   // FASTA_LONG formats
  391.     "???" , // not-set = ???
  392.     "lcl",  // local = lcl|integer or string
  393.     "bbs",  // gibbsq = bbs|integer
  394.     "bbm",  // gibbmt = bbm|integer
  395.     "gim",  // giim = gim|integer
  396.     "gb", // genbank = gb|accession|locus
  397.     "emb",  // embl = emb|accession|locus
  398.     "pir",  // pir = pir|accession|name
  399.     "sp", // swissprot = sp|accession|name
  400.     "pat",  // patent = pat|country|patent number (string)|seq number (integer)
  401.     "ref",  // other = ref|accession|name|release - changed from oth to ref
  402.     "gnl",  // general = gnl|database(string)|id (string or number)
  403.     "gi", // gi = gi|integer
  404.     "dbj",  // ddbj = dbj|accession|locus
  405.     "prf",  // prf = prf|accession|name
  406.     "pdb",  // pdb = pdb|entry name (string)|chain id (char)
  407.     "tpg",  // tpg = tpg|accession|name
  408.     "tpe",  // tpe = tpe|accession|name
  409.     "tpd",  // tpd = tpd|accession|name
  410.     ""  // Placeholder for end of list
  411. };
  413. CSeq_id::E_Choice CSeq_id::WhichInverseSeqId(const char* SeqIdCode)
  414. {
  415.     int retval = 0;
  416.     int dex;
  418.     // Last item in list has null byte for first character, so
  419.     // *s_TextId[dex] will be zero at end.
  420.     for (dex = 0;  *s_TextId[dex];  dex++) {
  421.         if ( !NStr::CompareNocase(s_TextId[dex], SeqIdCode) ) {
  422.             break;
  423.         }
  424.     }
  425.     if ( !*s_TextId[dex] ) {
  426.         retval = 0;
  427.     } else {
  428.         retval = dex;
  429.     }
  431.     return static_cast<CSeq_id_Base::E_Choice> (retval);
  432. }
  435. static CSeq_id::EAccessionInfo s_IdentifyNAcc(const string& acc)
  436. {
  437.     _ASSERT(acc[0] == 'N');
  438.     int n = NStr::StringToInt(acc.substr(1), 10, NStr::eCheck_Skip);
  439.     if (n >= 20000) {
  440.         return CSeq_id::eAcc_gb_est;
  441.     } else { // big mess; fortunately, these are all secondary
  442.         switch (n) {
  443.         case 1: case 2: case 11: case 57:
  444.             return CSeq_id::eAcc_gb_embl;
  446.         case 3: case 4: case 6: case 7: case 10: case 14: case 15:
  447.         case 16: case 17: case 21: case 23: case 24: case 26: case 29:
  448.         case 30: case 31: case 32: case 33: case 34: case 36: case 38:
  449.         case 39: case 40: case 42: case 43: case 44: case 45: case 47:
  450.         case 49: case 50: case 51: case 55: case 56: case 59:
  451.             return CSeq_id::eAcc_gb_ddbj;
  453.         case 5: case 9: case 12: case 20: case 22: case 25: case 58:
  454.             return CSeq_id::eAcc_gb_embl_ddbj;
  456.         case 8: case 13: case 18: case 19: case 27: case 41: case 46:
  457.         case 48: case 52: case 54: case 18624:
  458.             return CSeq_id::eAcc_gb_other_nuc;
  460.         case 28: case 35: case 37: case 53: case 61: case 62: case 63:
  461.         case 65: case 66: case 67: case 68: case 69: case 78: case 79:
  462.         case 83: case 88: case 90: case 91: case 92: case 93: case 94:
  463.             return CSeq_id::eAcc_ddbj_other_nuc;
  465.         case 60: case 64:
  466.             return CSeq_id::eAcc_embl_other_nuc;
  468.         case 70:
  469.             return CSeq_id::eAcc_embl_ddbj;
  471.         default: // unassigned or ambiguous
  472.             return CSeq_id::eAcc_unknown;
  473.         }
  474.     }
  475. }
  478. CSeq_id::EAccessionInfo CSeq_id::IdentifyAccession(const string& acc)
  479. {
  480.     SIZE_TYPE digit_pos = acc.find_first_of("0123456789");
  481.     if (digit_pos == NPOS) {
  482.         return eAcc_unknown;
  483.     }
  484.     SIZE_TYPE main_size = acc.find('.');
  485.     if (main_size == NPOS) {
  486.         main_size = acc.size();
  487.     }
  488.     string pfx = acc.substr(0, digit_pos);
  489.     NStr::ToUpper(pfx);
  490.     switch (pfx.size()) {
  491.     case 0:
  492.         if (acc.find_first_not_of("0123456789") == NPOS) { // just digits
  493.             return eAcc_gi;
  494.         } else if (main_size == 4  ||  (main_size > 4  &&  acc[4] == '|')) {
  495.             return eAcc_pdb;
  496.         } else {
  497.             return eAcc_unknown;
  498.         }
  500.     case 1:
  501.         switch (pfx[0]) {
  502.         case 'A':                                return eAcc_embl_patent;
  503.         case 'B':                                return eAcc_gb_gss;
  504.         case 'C':                                return eAcc_ddbj_est;
  505.         case 'D':                                return eAcc_ddbj_dirsub;
  506.         case 'E':                                return eAcc_ddbj_patent;
  507.         case 'F':                                return eAcc_embl_est;
  508.         case 'G':                                return eAcc_gb_sts;
  509.         case 'H': case 'R': case 'T': case 'W':  return eAcc_gb_est;
  510.         case 'I':                                return eAcc_gb_patent;
  511.         case 'J': case 'K': case 'L': case 'M':  return eAcc_gsdb_dirsub;
  512.         case 'N':                                return s_IdentifyNAcc(acc);
  513.         case 'O': case 'P': case 'Q':            return eAcc_swissprot;
  514.         case 'S':                                return eAcc_gb_backbone;
  515.         case 'U':                                return eAcc_gb_dirsub;
  516.         case 'V': case 'X': case 'Y': case 'Z':  return eAcc_embl_dirsub;
  517.         default:                                 return eAcc_unreserved_nuc;
  518.         }
  520.     case 2:
  521.         switch (pfx[0]) {
  522.         case 'A':
  523.             switch (pfx[1]) {
  524.             case 'A': case 'I': case 'W': return eAcc_gb_est;
  525.             case 'B':                     return eAcc_ddbj_dirsub;
  526.             case 'C':                     return eAcc_gb_htgs;
  527.             case 'D':                     return eAcc_gb_gsdb;
  528.             case 'E':                     return eAcc_gb_genome;
  529.             case 'F': case 'Y':           return eAcc_gb_dirsub;
  530.             case 'G': case 'P':           return eAcc_ddbj_genome;
  531.             case 'H':                     return eAcc_gb_con;
  532.             case 'J': case 'M':           return eAcc_embl_dirsub;
  533.             case 'K':                     return eAcc_ddbj_htgs;
  534.             case 'L':                     return eAcc_embl_genome;
  535.             case 'N':                     return eAcc_embl_con;
  536.             case 'Q': case 'Z':           return eAcc_gb_gss;
  537.             case 'R':                     return eAcc_gb_patent;
  538.             case 'S':                     return eAcc_gb_other_nuc;
  539.             case 'T': case 'U': case 'V': return eAcc_ddbj_est;
  540.             case 'X':                     return eAcc_embl_patent;
  541.             default:                      return eAcc_unreserved_nuc;
  542.             }
  544.         case 'B':
  545.             switch (pfx[1]) {
  546.             case 'A':                               return eAcc_ddbj_con;
  547.             case 'B': case 'J': case 'P': case 'W':
  548.             case 'Y':                               return eAcc_ddbj_est;
  549.             case 'C': case 'T':                     return eAcc_gb_cdna;
  550.             case 'D':                               return eAcc_ddbj_patent;
  551.             case 'E': case 'F': case 'G': case 'I':
  552.             case 'M': case 'Q': case 'U':           return eAcc_gb_est;
  553.             case 'H': case 'Z':                     return eAcc_gb_gss;
  554.             case 'K': case 'L':                     return eAcc_gb_tpa_nuc;
  555.             case 'N':                               return eAcc_embl_tpa_nuc;
  556.             case 'R':                               return eAcc_ddbj_tpa_nuc;
  557.             case 'S':                               return eAcc_ddbj_genome;
  558.                 // BS is actually chimp genomes.
  559.             case 'V':                               return eAcc_gb_sts;
  560.             case 'X':                               return eAcc_embl_genome;
  561.             default:                                return eAcc_unreserved_nuc;
  562.             }
  564.         case 'C':
  565.             switch (pfx[1]) {
  566.             case 'A': case 'B': case 'D': case 'F':
  567.             case 'K': case 'N':                     return eAcc_gb_est;
  568.             case 'C': case 'E': case 'G': case 'L': return eAcc_gb_gss;
  569.             case 'H': case 'M':                     return eAcc_gb_con;
  570.             case 'I': case 'J':                     return eAcc_ddbj_est;
  571.                 // no specific assignment for CO-CP yet
  572.             case 'O': case 'P':                     return eAcc_gb_other_nuc;
  573.             case 'Q':                               return eAcc_embl_patent;
  574.             case 'R':                               return eAcc_embl_genome;
  575.             case 'S': case 'T': case 'U':           return eAcc_embl_other_nuc;
  576.             default:                                return eAcc_unreserved_nuc;
  577.             }
  579.         default: return eAcc_unreserved_nuc;
  580.         }
  582.     case 3:
  583.         if (pfx[2] == '_') { // refseq-style
  584.             if      (pfx == "NC_") { return eAcc_refseq_chromosome;      }
  585.             else if (pfx == "NG_") { return eAcc_refseq_genomic;         }
  586.             else if (pfx == "NM_") { return eAcc_refseq_mrna;            }
  587.             else if (pfx == "NP_") { return eAcc_refseq_prot;            }
  588.             else if (pfx == "NR_") { return eAcc_refseq_ncrna;           }
  589.             else if (pfx == "NS_") { return eAcc_refseq_genome; /* ? */  }
  590.             else if (pfx == "NT_") { return eAcc_refseq_contig;          }
  591.             else if (pfx == "NW_") { return eAcc_refseq_wgs_intermed;    }
  592.             // else if (pfx == "NZ_") { return eAcc_refseq_wgs_nuc;         }
  593.             else if (pfx == "XM_") { return eAcc_refseq_mrna_predicted;  }
  594.             else if (pfx == "XP_") { return eAcc_refseq_prot_predicted;  }
  595.             else if (pfx == "XR_") { return eAcc_refseq_ncrna_predicted; }
  596.             else if (pfx == "ZP_") { return eAcc_refseq_wgs_prot;        }
  597.             else                   { return eAcc_refseq_unreserved;      }
  598.         } else { // protein
  599.             switch (pfx[0]) {
  600.             case 'A': return (pfx == "AAE") ? eAcc_gb_patent_prot
  601.                           : eAcc_gb_prot;
  602.             case 'B': return eAcc_ddbj_prot;
  603.             case 'C': return eAcc_embl_prot;
  604.             case 'D': return eAcc_gb_tpa_prot;
  605.             case 'E': return eAcc_gb_wgs_prot;
  606.             case 'F': return eAcc_ddbj_tpa_prot;
  607.             case 'G': return eAcc_ddbj_wgs_prot;
  608.             default:  return eAcc_unreserved_prot;
  609.             }
  610.         }
  612.     case 4:
  613.         switch (pfx[0]) {
  614.         case 'A': return eAcc_gb_wgs_nuc;
  615.         case 'B': return eAcc_ddbj_wgs_nuc;
  616.         case 'C': return eAcc_embl_wgs_nuc;
  617.         default:  return eAcc_unknown;
  618.         }
  620.     case 7:
  621.         if (NStr::StartsWith(acc, "NZ_")) {
  622.             return eAcc_refseq_wgs_nuc;
  623.         } else {
  624.             return eAcc_unknown;
  625.         }
  627.     default:
  628.         return eAcc_unknown;
  629.     }
  630. }
  633. CSeq_id::EAccessionInfo CSeq_id::IdentifyAccession(void) const
  634. {
  635.     EAccessionInfo type = (EAccessionInfo)Which();
  636.     switch (type) {
  637.     case CSeq_id::e_Pir: case CSeq_id::e_Swissprot: case CSeq_id::e_Prf:
  638.     case CSeq_id::e_Pdb:
  639.         return (EAccessionInfo)(type | fAcc_prot); // always just protein
  640.         
  641.     case CSeq_id::e_Genbank: case CSeq_id::e_Embl: case CSeq_id::e_Ddbj:
  642.     case CSeq_id::e_Tpg:     case CSeq_id::e_Tpe:  case CSeq_id::e_Tpd:
  643.     case CSeq_id::e_Other:
  644.     {
  645.         const CTextseq_id* tsid = GetTextseq_Id();
  646.         if (tsid->IsSetAccession()) {
  647.             EAccessionInfo ai = IdentifyAccession(tsid->GetAccession());
  648.             if ((ai & eAcc_type_mask) == e_not_set) {
  649.                 // We *know* what the type should be....
  650.                 return (EAccessionInfo)((ai & eAcc_flag_mask) | type);
  651.             } else if ((ai & eAcc_type_mask) == type) {
  652.                 return ai;
  653.             } else { // misidentified or mislabeled; assume the former
  654.                 return type;
  655.             }
  656.         } else {
  657.             return type;
  658.         }
  659.     }
  660.     
  661.     default:
  662.         return type;
  663.     }
  664. }
  667. static inline
  668. void x_GetLabel_Type(const CSeq_id& id, string* label,
  669.                      CSeq_id::TLabelFlags flags)
  670. {
  671.     CSeq_id::E_Choice choice = id.Which();
  672.     _ASSERT(choice < CSeq_id::e_MaxChoice);
  673.     if (choice >= CSeq_id::e_MaxChoice) {
  674.         return;
  675.     }
  677.     switch (choice) {   
  678.     default:
  679.         *label += s_TextId[choice];
  680.         break;
  682.     case CSeq_id::e_General:
  683.         // for general IDs, use the db-name only
  684.         *label += "gnl";
  685.         break;
  686.     }
  688.     // no extra flag interpretation currently
  689. }
  692. static inline
  693. void x_GetLabel_Content(const CSeq_id& id, string* label,
  694.                         CSeq_id::TLabelFlags flags)
  695. {
  696.     const CTextseq_id* tsid = id.GetTextseq_Id();
  698.     //text id
  699.     if (tsid) {
  700.         string str;
  701.         if (tsid->IsSetAccession()) {
  702.             str = tsid->GetAccession();
  703.         } else if (tsid->IsSetName()) {
  704.             str = tsid->GetName();
  705.         }
  707.         if ( !str.empty() ) {
  708.             if ( (flags & CSeq_id::fLabel_Version)  &&  tsid->IsSetVersion()) {
  709.                 str += "." + NStr::IntToString(tsid->GetVersion());
  710.             }
  711.         }
  712.         *label += str;
  714.     } else { //non-text id
  715.         switch (id.Which()) {   
  716.         case CSeq_id::e_not_set:
  717.             break;
  719.         case CSeq_id::e_Local:
  720.             {{
  721.                 const CObject_id& oid = id.GetLocal();
  722.                 if (oid.Which() == CObject_id::e_Id) {
  723.                     *label += NStr::IntToString(oid.GetId());
  724.                 } else if (oid.Which() == CObject_id::e_Str) {
  725.                     *label += oid.GetStr(); 
  726.                 }
  727.             }}
  728.             break;
  730.         case CSeq_id::e_Gibbsq:
  731.             *label += NStr::IntToString(id.GetGibbsq());
  732.             break;
  734.         case CSeq_id::e_Gibbmt:
  735.             *label += NStr::IntToString(id.GetGibbmt());
  736.             break;
  738.         case CSeq_id::e_Giim:
  739.             *label += NStr::IntToString(id.GetGiim().GetId());
  740.             break;
  742.         case CSeq_id::e_General:
  743.             {{
  744.                 const CDbtag& dbt = id.GetGeneral();
  745.                 *label += dbt.GetDb() + '|';
  746.                 if (dbt.GetTag().Which() == CObject_id::e_Id) {
  747.                     *label += NStr::IntToString(dbt.GetTag().GetId());
  748.                 } else if (dbt.GetTag().Which()==CObject_id::e_Str) {
  749.                     *label += dbt.GetTag().GetStr();
  750.                 }
  751.             }}
  752.             break;
  754.         case CSeq_id::e_Patent:
  755.             {{
  756.                 const CId_pat& idp = id.GetPatent().GetCit();
  757.                 *label += idp.GetCountry() +
  758.                     (idp.GetId().IsNumber() ?
  759.                         idp.GetId().GetNumber() :
  760.                         idp.GetId().GetApp_number()) +
  761.                     NStr::IntToString(id.GetPatent().GetSeqid());
  762.             }}
  763.             break;
  765.         case CSeq_id::e_Gi:
  766.             *label += NStr::IntToString(id.GetGi());
  767.             break;
  769.         case CSeq_id::e_Pdb:
  770.             {{
  771.                 const CPDB_seq_id& pid = id.GetPdb();
  772.                 char chain = (char)pid.GetChain();
  773.                 if (chain == '|') {
  774.                     *label += pid.GetMol().Get() + "|VB";
  775.                 } else if (islower(chain) != 0) {
  776.                     *label += pid.GetMol().Get() + "-" + (char) toupper(chain);
  777.                 } else if ( chain == '' ) {
  778.                     *label += pid.GetMol().Get() + "-";
  779.                 } else {
  780.                     *label += pid.GetMol().Get() + "-" + chain; 
  781.                 }
  782.             }}
  783.             break;
  785.         default:
  786.             break;
  787.         }
  788.     }
  789. }
  792. void CSeq_id::GetLabel(string* label, ELabelType type, TLabelFlags flags) const
  793. {
  794.     if ( !label ) {
  795.         return;
  796.     }
  798.     switch (type) {
  799.     case eFasta:
  800.         *label = AsFastaString();
  801.         break;
  803.     case eBoth:
  804.         x_GetLabel_Type(*this, label, flags);
  805.         *label += "|";
  806.         x_GetLabel_Content(*this, label, flags);
  807.         break;
  809.     case eType:
  810.         x_GetLabel_Type(*this, label, flags);
  811.         break;
  813.     case eContent:
  814.         x_GetLabel_Content(*this, label, flags);
  815.         break;
  816.     }
  817. }
  821. /*Return seqid string with optional version for text seqid type 
  822. (default no version).*/ 
  823. string CSeq_id::GetSeqIdString(bool with_version) const
  824. {
  825.     string label;
  826.     TLabelFlags flags = 0;
  827.     if (with_version) {
  828.         flags |= fLabel_Version;
  829.     }
  830.     GetLabel(&label, eContent, flags);
  831.     return label;
  832. }
  835. void CSeq_id::WriteAsFasta(ostream& out)
  836.     const
  837. {
  838.     E_Choice the_type = Which();
  839.     if (the_type > e_Tpd)  // New SeqId type
  840.         the_type = e_not_set;
  842.     out << s_TextId[the_type] << '|';
  844.     switch (the_type) {
  845.     case e_not_set:
  846.         break;
  847.     case e_Local:
  848.         GetLocal().AsString(out);
  849.         break;
  850.     case e_Gibbsq:
  851.         out << GetGibbsq();
  852.         break;
  853.     case e_Gibbmt:
  854.         out << GetGibbmt();
  855.         break;
  856.     case e_Giim:
  857.         out << (GetGiim().GetId());
  858.         break;
  859.     case e_Genbank:
  860.         GetGenbank().AsFastaString(out);
  861.         break;
  862.     case e_Embl:
  863.         GetEmbl().AsFastaString(out);
  864.         break;
  865.     case e_Pir:
  866.         GetPir().AsFastaString(out);
  867.         break;
  868.     case e_Swissprot:
  869.         GetSwissprot().AsFastaString(out);
  870.         break;
  871.     case e_Patent:
  872.         GetPatent().AsFastaString(out);
  873.         break;
  874.     case e_Other:
  875.         GetOther().AsFastaString(out);
  876.         break;
  877.     case e_General:
  878.         {
  879.             const CDbtag& dbt = GetGeneral();
  880.             out << (dbt.GetDb()) << '|';  // no Upcase per Ostell - Karl 7/2001
  881.             dbt.GetTag().AsString(out);
  882.         }
  883.         break;
  884.     case e_Gi:
  885.         out << GetGi();
  886.         break;
  887.     case e_Ddbj:
  888.         GetDdbj().AsFastaString(out);
  889.         break;
  890.     case e_Prf:
  891.         GetPrf().AsFastaString(out);
  892.         break;
  893.     case e_Pdb:
  894.         GetPdb().AsFastaString(out);
  895.         break;
  896.     case e_Tpg:
  897.         GetTpg().AsFastaString(out);
  898.         break;
  899.     case e_Tpe:
  900.         GetTpe().AsFastaString(out);
  901.         break;
  902.     case e_Tpd:
  903.         GetTpd().AsFastaString(out);
  904.         break;
  905.     default:
  906.         out << "[UnknownSeqIdType]";
  907.         break;
  908.     }
  909. }
  912. const string CSeq_id::AsFastaString(void) const
  913. {
  914.     CNcbiOstrstream str;
  915.     WriteAsFasta(str);
  916.     return CNcbiOstrstreamToString(str);
  917. }
  919. //
  920. // Local functions for producing a sequence ID 'score'
  921. // These functions produce scores in FastA order
  922. //
  923. static int s_ScoreNAForFasta(const CSeq_id* id)
  924. {
  925.     switch (id->Which()) {
  926.     case CSeq_id::e_not_set:
  927.     case CSeq_id::e_Giim:
  928.     case CSeq_id::e_Pir:
  929.     case CSeq_id::e_Swissprot:
  930.     case CSeq_id::e_Prf:       return kMax_Int;
  931.     case CSeq_id::e_Local:     return 230;
  932.     case CSeq_id::e_Gi:        return 120;
  933.     case CSeq_id::e_General:   return 50;
  934.     case CSeq_id::e_Patent:    return 40;
  935.     case CSeq_id::e_Gibbsq:
  936.     case CSeq_id::e_Gibbmt:
  937.     case CSeq_id::e_Pdb:       return 30;
  938.     case CSeq_id::e_Other:     return 15;
  939.     default:                   return 20; // [third party] GenBank/EMBL/DDBJ
  940.     }
  941. }
  944. static int s_ScoreAAForFasta(const CSeq_id* id)
  945. {
  946.     switch (id->Which()) {
  947.     case CSeq_id::e_not_set:
  948.     case CSeq_id::e_Giim:      return kMax_Int;
  949.     case CSeq_id::e_Local:     return 230;
  950.     case CSeq_id::e_Gi:        return 120;
  951.     case CSeq_id::e_General:   return 90;
  952.     case CSeq_id::e_Patent:    return 80;
  953.     case CSeq_id::e_Prf:       return 70;
  954.     case CSeq_id::e_Pdb:       return 50;
  955.     case CSeq_id::e_Gibbsq:
  956.     case CSeq_id::e_Gibbmt:    return 40;
  957.     case CSeq_id::e_Pir:       return 30;
  958.     case CSeq_id::e_Swissprot: return 20;
  959.     case CSeq_id::e_Other:     return 15;
  960.     default:                   return 60; // [third party] GenBank/EMBL/DDBJ
  961.     }
  962. }
  965. //
  966. // GetStringDescr()
  967. // Given a bioseq, return the best possible ID description, in a number of
  968. // appealing formats.  This function can produce FastA-formatted titles or a
  969. // number of sub-titles (GI only, Best Accession with or without version).
  970. //
  971. string CSeq_id::GetStringDescr(const CBioseq& bioseq, EStringFormat fmt)
  972. {
  973.     bool is_na            = bioseq.GetInst().GetMol() != CSeq_inst::eMol_aa;
  974.     CRef<CSeq_id> best_id = FindBestChoice(bioseq.GetId(),
  975.                                            is_na ? s_ScoreNAForFasta
  976.                                            : s_ScoreAAForFasta);
  977.     switch (fmt) {
  978.     case eFormat_FastA:
  979.         {{
  980.             // FastA format
  981.             // Here we have something like:
  982.             //      gi|###|SOME_ACCESSION|title
  983.             bool found_gi = false;
  985.             CNcbiOstrstream out_str;
  986.             ITERATE (CBioseq::TId, id, bioseq.GetId()) {
  987.                 if ((*id)->IsGi()) {
  988.                     (*id)->WriteAsFasta(out_str);
  989.                     found_gi = true;
  990.                     break;
  991.                 }
  992.             }
  994.             if (best_id.NotEmpty()  &&  best_id->Which() != CSeq_id::e_Gi) {
  995.                 if (found_gi) {
  996.                     out_str << '|';
  997.                 }
  998.                 best_id->WriteAsFasta(out_str);
  999.             }
  1001.             return CNcbiOstrstreamToString(out_str);
  1002.         }}
  1003.         break;
  1005.     case eFormat_ForceGI:
  1006.         // eForceGI produces a string containing only the GI in FastA format
  1007.         // so we have:
  1008.         //    gi|####
  1009.         ITERATE (CBioseq::TId, iter, bioseq.GetId()) {
  1010.             if ( (*iter)->IsGi() ) {
  1011.                 CNcbiOstrstream out_str;
  1012.                 (*iter)->WriteAsFasta(out_str);
  1014.                 return CNcbiOstrstreamToString(out_str);
  1015.             }
  1016.         }
  1017.         break;
  1019.     case eFormat_BestWithVersion:
  1020.         // eBestWithVersion produces only the 'best' accession name, with
  1021.         // its version indicator
  1022.         if (best_id.NotEmpty()) {
  1023.             string label;
  1024.             best_id->GetLabel(&label, eDefault, fLabel_Version);
  1025.             return label;
  1026.         }
  1027.         break;
  1028.         
  1029.     case eFormat_BestWithoutVersion:
  1030.         // eBestWithoutVersion produces only the 'best' accession name,
  1031.         // without its version indicator
  1032.         if (best_id.NotEmpty()) {
  1033.             string label;
  1034.             best_id->GetLabel(&label, eDefault, 0);
  1035.             return label;
  1036.         }
  1037.         break;
  1038.     }
  1040.     // catch-all for unusual events
  1041.     return "";
  1042. }
  1045. CSeq_id::CSeq_id(const CDbtag& dbtag, bool set_as_general)
  1046. {
  1047.     int version = -1;
  1048.     string acc;
  1050.     if (dbtag.GetTag().IsStr()) {
  1051.         acc = dbtag.GetTag().GetStr();
  1052.         string::size_type pos = acc.find_last_of(".");
  1053.         if (pos != string::npos) {
  1054.             version = NStr::StringToInt(acc.substr(pos + 1, acc.length() - pos));
  1055.             acc.erase(pos);
  1056.         }
  1057.     }
  1059.     switch (dbtag.GetType()) {
  1060.     case CDbtag::eDbtagType_GenBank:
  1061.         try {
  1062.             int gi = NStr::StringToInt(acc);
  1063.             SetGi(gi);
  1064.         }
  1065.         catch (...) {
  1066.             SetGenbank().SetAccession(acc);
  1067.             if (version != -1) {
  1068.                 SetGenbank().SetVersion(version);
  1069.             }
  1070.         }
  1071.         break;
  1073.     case CDbtag::eDbtagType_EMBL:
  1074.         SetEmbl().SetAccession(acc);
  1075.         if (version != -1) {
  1076.             SetEmbl().SetVersion(version);
  1077.         }
  1078.         break;
  1080.     case CDbtag::eDbtagType_DDBJ:
  1081.         SetDdbj().SetAccession(acc);
  1082.         if (version != -1) {
  1083.             SetDdbj().SetVersion(version);
  1084.         }
  1085.         break;
  1087.     case CDbtag::eDbtagType_GI:
  1088.         if (dbtag.GetTag().IsStr()) {
  1089.             SetGi(NStr::StringToInt(dbtag.GetTag().GetStr()));
  1090.         } else {
  1091.             SetGi(dbtag.GetTag().GetId());
  1092.         }
  1093.         break;
  1095.     case CDbtag::eDbtagType_bad:
  1096.     default:
  1097.         // not understood as a sequence id - leave as e_not_set
  1098.         if (set_as_general) {
  1099.             SetGeneral().Assign(dbtag);
  1100.         }
  1101.         break;
  1102.     }
  1103. }
  1106. //SeqIdFastAConstructors
  1107. CSeq_id::CSeq_id( const string& the_id )
  1108. {
  1109.     // If no vertical bar, tries to interpret the string as a pure
  1110.     // accession, inferring the type from the initial letter(s).
  1111.     if (the_id.find('|') == NPOS) {
  1112.         SIZE_TYPE      dot    = the_id.find('.');
  1113.         string         acc_in = the_id.substr(0, dot);
  1114.         EAccessionInfo info   = IdentifyAccession(acc_in);
  1115.         int            ver    = 0;
  1116.         if (dot != NPOS) {
  1117.             ver = NStr::StringToNumeric(the_id.substr(dot + 1));
  1118.         }
  1119.         if (GetAccType(info) != e_not_set) {
  1120.             x_Init(GetAccType(info), acc_in, kEmptyStr, ver);
  1121.         }
  1122.         return;
  1123.     }
  1125.     // Create an istrstream on string the_id
  1126.     std::istrstream  myin(the_id.c_str() );
  1128.     string the_type_in, acc_in, name_in, version_in, release_in;
  1130.     // Read the part of the_id up to the vertical bar ( "|" )
  1131.     NcbiGetline(myin, the_type_in, '|');
  1132.     // Remove spaces from front and back of the_type_in
  1133.     string the_type_use = NStr::TruncateSpaces(the_type_in, NStr::eTrunc_Both);
  1135.     // Determine the type from the string
  1136.     CSeq_id_Base::E_Choice the_type = WhichInverseSeqId(the_type_use.c_str());
  1138.     // Construct according to type
  1139.     if ( the_type == CSeq_id::e_Local ) {
  1140.         NcbiGetline( myin, acc_in, 0 ); // take rest
  1141.         x_Init( the_type, acc_in );
  1142.         return;
  1143.     }
  1145.     if ( !NcbiGetline( myin, acc_in, '|' ) )
  1146.         return;
  1148.     if ( the_type == CSeq_id::e_General  ||  the_type == CSeq_id::e_Pdb ) {
  1149.         //Take the rest of the line
  1150.         NcbiGetline( myin, name_in, 0 );
  1151.         x_Init( the_type, acc_in, name_in );
  1152.         return;
  1153.     } else if ( the_type == CSeq_id::e_Gi ) {
  1154.         x_Init( the_type, acc_in );
  1155.         return;
  1156.     }
  1158.     if ( NcbiGetline(myin, name_in, '|') ) {
  1159.         if ( NcbiGetline(myin, version_in, '|') ) {
  1160.             NcbiGetline(myin, release_in, '|');
  1161.         }
  1162.     }
  1164.     string version = NStr::TruncateSpaces( version_in, NStr::eTrunc_Both );
  1165.     int ver = 0;
  1167.     if ( ! version.empty() ) {
  1168.         if ( (ver = NStr::StringToNumeric(version) ) < 0) {
  1169.             THROW1_TRACE(invalid_argument,
  1170.                          "Unexpected non-numeric version: " +
  1171.                          version +
  1172.                          "nthe_id: " + the_id);
  1173.         }
  1174.     }
  1175.     x_Init(the_type, acc_in, name_in, ver, release_in);
  1176. }
  1179. // acc_in is just first string, as in text seqid, for
  1180. // wierd cases (patents, pdb) not really an acc
  1181. CSeq_id::CSeq_id
  1182. (CSeq_id_Base::E_Choice the_type,
  1183.  const string&          acc_in,
  1184.  const string&          name_in,
  1185.  const string&          version_in,
  1186.  const string&          release_in )
  1187. {
  1188.     string version = NStr::TruncateSpaces(version_in, NStr::eTrunc_Both);
  1189.     int ver = 0;
  1191.     if ( !version.empty() ) {
  1192.         if ( (ver = NStr::StringToNumeric(version)) < 0 ) {
  1193.             THROW1_TRACE(invalid_argument,
  1194.                          "Unexpected non-numeric version. "
  1195.                          "nthe_type = " + string(s_TextId[the_type]) +
  1196.                          "nacc_in = " + acc_in +
  1197.                          "nname_in = " + name_in +
  1198.                          "version_in = " + version_in +
  1199.                          "nrelease_in = " + release_in);
  1200.         }
  1201.     }
  1203.     x_Init(the_type, acc_in, name_in, ver, release_in);
  1204. }
  1207. static void s_InitThrow
  1208. (const string& message,
  1209.  const string& type,
  1210.  const string& acc,
  1211.  const string& name,
  1212.  const string& version,
  1213.  const string& release)
  1214. {
  1215.     THROW1_TRACE(invalid_argument,
  1216.                  "CSeq_id:: " + message +
  1217.                  "ntype      = " + type +
  1218.                  "naccession = " + acc +
  1219.                  "nname      = " + name +
  1220.                  "nversion   = " + version +
  1221.                  "nrelease   = " + release);
  1222. }
  1225. CSeq_id::CSeq_id
  1226. (const string& the_type_in,
  1227.  const string& acc_in,
  1228.  const string& name_in,
  1229.  const string& version_in,
  1230.  const string& release_in)
  1231. {
  1232.     string the_type_use = NStr::TruncateSpaces(the_type_in, NStr::eTrunc_Both);
  1233.     string version      = NStr::TruncateSpaces(version_in,  NStr::eTrunc_Both);
  1234.     int ver = 0;
  1236.     CSeq_id_Base::E_Choice the_type = WhichInverseSeqId(the_type_use.c_str());
  1238.     if ( !version.empty() ) {
  1239.         if ( (ver = NStr::StringToNumeric(version)) < 0) {
  1240.             s_InitThrow("Unexpected non-numeric version.",
  1241.                         the_type_in, acc_in, name_in, version_in, release_in);
  1242.         }
  1243.     }
  1245.     x_Init(the_type, acc_in, name_in, ver, release_in);
  1246. }
  1249. CSeq_id::CSeq_id
  1250. (const string& the_type_in,
  1251.  const string& acc_in,
  1252.  const string& name_in,
  1253.  int           version,
  1254.  const string& release_in )
  1255. {
  1256.     string the_type_use = NStr::TruncateSpaces(the_type_in, NStr::eTrunc_Both);
  1257.     CSeq_id_Base::E_Choice the_type = WhichInverseSeqId (the_type_use.c_str());
  1259.     x_Init(the_type, acc_in, name_in, version, release_in);
  1260. }
  1263. CSeq_id::CSeq_id
  1264. ( CSeq_id_Base::E_Choice the_type,
  1265.   const string&          acc_in,
  1266.   const string&          name_in,
  1267.   int                    version,
  1268.   const string&          release_in)
  1269. {
  1270.     x_Init(the_type, acc_in, name_in, version, release_in);
  1271. }
  1273. CSeq_id::CSeq_id
  1274. ( CSeq_id_Base::E_Choice the_type,
  1275.   int           the_id)
  1276. {
  1277.   if(the_id<=0)
  1278.     THROW1_TRACE(invalid_argument, "Specified Seq-id value is negative");
  1279.   
  1280.   switch (the_type) {
  1281.   case CSeq_id::e_Local:
  1282.     SetLocal().SetId(the_id);
  1283.     break;
  1284.   case CSeq_id::e_Gibbsq:
  1285.     SetGibbsq(the_id);
  1286.     break;
  1287.   case CSeq_id::e_Gibbmt:
  1288.     SetGibbmt(the_id);
  1289.     break;
  1290.   case CSeq_id::e_Giim:
  1291.     SetGiim().SetId(the_id);
  1292.     break;
  1293.   case CSeq_id::e_Gi:
  1294.     SetGi(the_id);
  1295.     break;
  1296.   default:
  1297.     THROW1_TRACE(invalid_argument, "Specified Seq-id type is not numeric seq-id");
  1298.   }  
  1299. }
  1301. // Karl Sirotkin 7/2001
  1303. void
  1304. CSeq_id::x_Init
  1305. ( CSeq_id_Base::E_Choice the_type,
  1306.   const string&          acc_in,
  1307.   const string&          name_in,
  1308.   int                    version ,
  1309.   const string&          release_in)
  1310. {
  1311.     int the_id;
  1312.     string acc     = NStr::TruncateSpaces(acc_in,     NStr::eTrunc_Both);
  1313.     string name    = NStr::TruncateSpaces(name_in,    NStr::eTrunc_Both);
  1314.     string release = NStr::TruncateSpaces(release_in, NStr::eTrunc_Both);
  1316.     switch (the_type) {
  1317.     case CSeq_id::e_not_set: // Will cause unspecified SeqId to be returned.
  1318.         break;
  1319.     case CSeq_id::e_Local:
  1320.         {
  1321.             CSeq_id::TLocal & loc = SetLocal();
  1322.             string::const_iterator it = acc.begin();
  1324.             if ( (the_id = NStr::StringToNumeric(acc)) >= 0 && *it != '0' ) {
  1325.                 loc.SetId(the_id);
  1326.             } else { // to cover case where embedded vertical bar in
  1327.                 // string, could add code here, to concat a
  1328.                 // '|' and name string, if not null/empty
  1329.                 loc.SetStr(acc);
  1330.             }
  1331.             break;
  1332.         }
  1333.     case CSeq_id::e_Gibbsq:
  1334.         if ( (the_id = NStr::StringToNumeric (acc)) >= 0 ) {
  1335.             SetGibbsq(the_id);
  1336.         } else {
  1337.              s_InitThrow("Unexpected non-numeric accession.",
  1338.                          string(s_TextId[the_type]), acc_in, name_in,
  1339.                          NStr::IntToString(version), release_in);
  1340.         }
  1341.         break;
  1342.     case CSeq_id::e_Gibbmt:
  1343.         if ( (the_id =NStr::StringToNumeric (acc)) >= 0 ) {
  1344.             SetGibbmt(the_id);
  1345.         } else {
  1346.              s_InitThrow("Unexpected non-numeric accession.",
  1347.                          string(s_TextId[the_type]), acc_in, name_in,
  1348.                          NStr::IntToString(version), release_in);
  1349.         }
  1350.         break;
  1351.     case CSeq_id::e_Giim:
  1352.         {
  1353.             CGiimport_id &  giim = SetGiim();
  1354.             if ( (the_id =NStr::StringToNumeric (acc)) >= 0 ) {
  1355.                 giim.SetId(the_id);
  1356.             } else {
  1357.                 s_InitThrow("Unexpected non-numeric accession.",
  1358.                             string(s_TextId[the_type]), acc_in, name_in,
  1359.                             NStr::IntToString(version), release_in);
  1360.             }
  1361.             break;
  1362.         }
  1363.     case CSeq_id::e_Genbank:
  1364.         {
  1365.             CTextseq_id* text
  1366.                 = new CTextseq_id(acc, name, version, release);
  1367.             SetGenbank(*text );
  1368.             break;
  1369.         }
  1370.     case CSeq_id::e_Embl:
  1371.         {
  1372.             CTextseq_id* text
  1373.                = new CTextseq_id(acc, name, version, release);
  1374.             SetEmbl(*text);
  1375.             break;
  1376.         }
  1377.     case CSeq_id::e_Pir:
  1378.         {
  1379.             CTextseq_id* text
  1380.                 = new CTextseq_id(acc, name, version, release, false);
  1381.             SetPir(*text);
  1382.             break;
  1383.         }
  1384.     case CSeq_id::e_Swissprot:
  1385.         {
  1386.             CTextseq_id* text
  1387.                 = new CTextseq_id(acc, name, version, release, false);
  1388.             SetSwissprot(*text);
  1389.             break;
  1390.         }
  1391.     case CSeq_id::e_Tpg:
  1392.         {
  1393.             CTextseq_id* text
  1394.                 = new CTextseq_id(acc, name, version, release);
  1395.             SetTpg(*text);
  1396.             break;
  1397.         }
  1398.     case CSeq_id::e_Tpe:
  1399.         {
  1400.             CTextseq_id* text
  1401.                 = new CTextseq_id(acc, name, version, release);
  1402.             SetTpe(*text);
  1403.             break;
  1404.         }
  1405.     case CSeq_id::e_Tpd:
  1406.         {
  1407.             CTextseq_id* text
  1408.                 = new CTextseq_id(acc, name, version, release);
  1409.             SetTpd(*text);
  1410.             break;
  1411.         }
  1412.     case CSeq_id::e_Patent:
  1413.         {
  1414.             CPatent_seq_id&  pat    = SetPatent();
  1415.             CId_pat&         id_pat = pat.SetCit();
  1416.             CId_pat::C_Id&   id_pat_id = id_pat.SetId();
  1417.             id_pat.SetCountry(acc);
  1419.             const char      app_str[] = "App=";
  1420.             const SIZE_TYPE app_str_len = sizeof(app_str) - 1;
  1421.             if (name.substr(0, app_str_len) == app_str) {
  1422.                 id_pat_id.SetApp_number(name.substr(app_str_len));
  1423.             } else {
  1424.                 id_pat_id.SetNumber(name);
  1425.             }
  1426.             pat.SetSeqid(version);
  1427.             break;
  1428.         }
  1429.     case CSeq_id::e_Other: // RefSeq, allow dot version
  1430.         {
  1431.             CTextseq_id* text
  1432.                 = new CTextseq_id(acc,name,version,release);
  1433.             SetOther(*text);
  1434.             break;
  1435.         }
  1436.     case CSeq_id::e_General:
  1437.         {
  1438.             CDbtag& dbt = SetGeneral();
  1439.             dbt.SetDb(acc);
  1440.             CObject_id& oid = dbt.SetTag();
  1441.             the_id = NStr::StringToNumeric(name);
  1442.             if (the_id >= 0  &&  (name.size() == 1 || name[0] != '0')) {
  1443.                 oid.SetId(the_id);
  1444.             }else{
  1445.                 oid.SetStr(name);
  1446.             }
  1447.             break;
  1448.         }
  1449.     case CSeq_id::e_Gi:
  1450.         the_id = NStr::StringToNumeric(acc);
  1451.         if (the_id >= 0 ) {
  1452.             SetGi(the_id);
  1453.         } else {
  1454.              s_InitThrow("Unexpected non-numeric accession.",
  1455.                          string(s_TextId[the_type]), acc_in, name_in,
  1456.                          NStr::IntToString(version), release_in);
  1457.         }
  1458.         break;
  1459.     case CSeq_id::e_Ddbj:
  1460.         {
  1461.             CTextseq_id* text
  1462.                 = new CTextseq_id(acc,name,version,release);
  1463.             SetDdbj(*text);
  1464.             break;
  1465.         }
  1466.     case CSeq_id::e_Prf:
  1467.         {
  1468.             CTextseq_id* text
  1469.                 = new CTextseq_id(acc,name,version,release,false);
  1470.             SetPrf(*text);
  1471.             break;
  1472.         }
  1473.     case CSeq_id::e_Pdb:
  1474.         {
  1475.             CPDB_seq_id& pdb     = SetPdb();
  1476.             CPDB_mol_id& pdb_mol = pdb.SetMol();
  1477.             pdb_mol.Set(acc);
  1479.             if (name.empty()) {
  1480.                 pdb.SetChain(' ');
  1481.             } else if (name.size() == 1) {
  1482.                 pdb.SetChain(static_cast<unsigned char> (name[0]));
  1483.             } else if ( name.compare("VB") == 0) {
  1484.                 pdb.SetChain('|');
  1485.             } else if (name.size() == 2  &&  name[0] ==  name[1]) {
  1486.                 pdb.SetChain( Locase(static_cast<unsigned char> (name[0])) );
  1487.             } else {
  1488.                 s_InitThrow("Unexpected PDB chain id.",
  1489.                             string(s_TextId[the_type]), acc_in, name_in,
  1490.                             NStr::IntToString(version), release_in);
  1491.             }
  1492.             break;
  1493.         }
  1494.     default:
  1495.         THROW1_TRACE(invalid_argument, "Specified Seq-id type not supported");
  1496.     }
  1497. }
  1500. bool CSeq_id::Equals(const CSerialObject& object, ESerialRecursionMode how) const
  1501. {
  1502.     if ( typeid(object) != typeid(*this) ) {
  1503.         ERR_POST(Fatal <<
  1504.             "CSeq_id::Assign() -- Assignment of incompatible types: " <<
  1505.             typeid(*this).name() << " = " << typeid(object).name());
  1506.     }
  1507.     return CSerialObject::Equals(object, how);
  1508. }
  1511. END_objects_SCOPE // namespace ncbi::objects::
  1512. END_NCBI_SCOPE
  1514. /*
  1515.  * ===========================================================================
  1516.  *
  1517.  * $Log: Seq_id.cpp,v $
  1518.  * Revision 1000.4  2004/06/01 19:34:28  gouriano
  1519.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.81
  1520.  *
  1521.  * Revision 6.81  2004/06/01 15:26:07  johnson
  1522.  * Make CompareOrdered a true model of strict weak ordering
  1523.  *
  1524.  * Revision 6.80  2004/05/28 20:09:44  johnson
  1525.  * Added Compare for seq-id type General (CDbtag)
  1526.  *
  1527.  * Revision 6.79  2004/05/21 14:41:46  dicuccio
  1528.  * Moved database tag for general IDs to content part of label
  1529.  *
  1530.  * Revision 6.78  2004/05/19 17:26:25  gorelenk
  1531.  * Added include of PCH - ncbi_pch.hpp
  1532.  *
  1533.  * Revision 6.77  2004/05/16 16:57:44  dicuccio
  1534.  * Removed insertion of db type in general seq-id labels of type content - led to
  1535.  * duplicates of type
  1536.  *
  1537.  * Revision 6.76  2004/05/14 14:34:02  dicuccio
  1538.  * Include database name in label content if the db-tag is just an integer
  1539.  *
  1540.  * Revision 6.75  2004/03/25 15:59:06  gouriano
  1541.  * Added possibility to copy and compare serial object non-recursively
  1542.  *
  1543.  * Revision 6.74  2004/03/22 16:24:19  ucko
  1544.  * CN is now specifically assigned to GenBank ESTs.
  1545.  *
  1546.  * Revision 6.73  2004/01/22 21:03:58  dicuccio
  1547.  * Separated functionality of enums in GetLabel() into discrete mode and flags
  1548.  *
  1549.  * Revision 6.72  2004/01/22 18:45:46  dicuccio
  1550.  * Added new API: CSeq_id::GetLabel().  Rewired GetSeqIdString() to feed into
  1551.  * GetLabel().  Rewired GetStringDescr() to feed into GetLabel() directly instead
  1552.  * of feeding through GetSeqIdString().
  1553.  *
  1554.  * Revision 6.71  2004/01/21 22:55:47  ucko
  1555.  * GetSeqIdString: drop the database name from general IDs for
  1556.  * compatibility with code that can't handle its presence.
  1557.  *
  1558.  * Revision 6.70  2004/01/21 18:04:20  dicuccio
  1559.  * Added ctor to create a seq-id from a given dbtag, performing conversion to
  1560.  * specific seq-id types where possible
  1561.  *
  1562.  * Revision 6.69  2004/01/20 16:59:38  ucko
  1563.  * CSeq_id::IdentifyAccession: identify IDs consisting solely of digits as GIs.
  1564.  *
  1565.  * Revision 6.68  2004/01/16 17:39:17  vasilche
  1566.  * Fixed parsing 'gnl|xxx|999' format - integer tag detection.
  1567.  *
  1568.  * Revision 6.67  2004/01/16 15:58:19  ucko
  1569.  * CM now specifically assigned to eAcc_gb_con.
  1570.  *
  1571.  * Revision 6.66  2003/12/18 18:55:59  ucko
  1572.  * CSeq_id::IdentifyAccession: CQ is EMBL patents, CR is EMBL genomes,
  1573.  * CS-CU are reserved for future EMBL nucleotide use.
  1574.  *
  1575.  * Revision 6.65  2003/12/16 16:00:16  ucko
  1576.  * CSeq_id::IdentifyAccession: CL is GenBank GSS, CM-CP are GenBank
  1577.  * nucleotides to be assigned to specific projects as needed.
  1578.  *
  1579.  * Revision 6.64  2003/11/10 15:05:42  ucko
  1580.  * +CK to eAcc_gb_est
  1581.  *
  1582.  * Revision 6.63  2003/10/31 20:16:07  ucko
  1583.  * CSeq_id::IdentifyAccession: CI and CJ are both DDBJ EST.
  1584.  *
  1585.  * Revision 6.62  2003/10/24 14:57:03  ucko
  1586.  * IdentifyAccession: CH -> eAcc_gb_con.
  1587.  * GetSeqIdString: include the database name for IDs of type general.
  1588.  *
  1589.  * Revision 6.61  2003/08/25 21:15:41  ucko
  1590.  * Tweak slightly for efficiency.
  1591.  *
  1592.  * Revision 6.60  2003/08/22 15:16:48  dondosha
  1593.  * Correction in CSeq_id constructor, to allow id strings starting with a gi id
  1594.  *
  1595.  * Revision 6.59  2003/08/11 14:37:20  ucko
  1596.  * IdentifyAccession: "CG" is GenBank GSS.
  1597.  *
  1598.  * Revision 6.58  2003/07/14 20:11:59  ucko
  1599.  * +CF (eAcc_gb_est)
  1600.  *
  1601.  * Revision 6.57  2003/07/02 13:46:14  ucko
  1602.  * +CE (eAcc_gb_gss)
  1603.  *
  1604.  * Revision 6.56  2003/06/24 16:33:48  ucko
  1605.  * CSeq_id::IdentifyAccession: always return unknown for accessions that
  1606.  * contain no digits, even if they happen to look like prefixes.
  1607.  *
  1608.  * Revision 6.55  2003/05/09 14:22:56  ucko
  1609.  * CSeq_id::x_Init: treat missing (chain) names as spaces (reported by
  1610.  * Michel Dumontier) and get rid of some unnecessary calls to c_str().
  1611.  *
  1612.  * Revision 6.54  2003/04/30 14:41:01  ucko
  1613.  * CSeq_id::IdentifyAccession: CDnnnnnn -> eAcc_gb_est
  1614.  *
  1615.  * Revision 6.53  2003/03/25 15:37:18  ucko
  1616.  * CSeq_id::IdentifyAccession("CC...") -> eAcc_gb_gss
  1617.  *
  1618.  * Revision 6.52  2003/03/11 15:55:44  kuznets
  1619.  * iterate -> ITERATE
  1620.  *
  1621.  * Revision 6.51  2003/02/06 22:23:29  vasilche
  1622.  * Added CSeq_id::Assign(), CSeq_loc::Assign().
  1623.  * Added int CSeq_id::Compare() (not safe).
  1624.  * Added caching of CSeq_loc::GetTotalRange().
  1625.  *
  1626.  * Revision 6.50  2003/02/04 15:15:12  grichenk
  1627.  * Overrided Assign() for CSeq_loc and CSeq_id
  1628.  *
  1629.  * Revision 6.49  2003/01/18 08:40:03  kimelman
  1630.  * addes seqid constructor for numeric types
  1631.  *
  1632.  * Revision 6.48  2003/01/15 18:27:13  ucko
  1633.  * +AK (accidentally skipped earlier -- sigh)
  1634.  *
  1635.  * Revision 6.47  2003/01/10 15:57:30  ucko
  1636.  * Identify CB as gb_est.
  1637.  *
  1638.  * Revision 6.46  2003/01/08 16:48:03  ucko
  1639.  * +AL (accidentally skipped earlier)
  1640.  *
  1641.  * Revision 6.45  2003/01/07 19:52:15  ucko
  1642.  * Add more refseq types (NR_, NS_, NW_).
  1643.  *
  1644.  * Revision 6.44  2002/12/30 23:44:42  vakatov
  1645.  * CSeq_id::GetStringDescr() -- un-freeze "strstream" to avoid a mem.leak
  1646.  *
  1647.  * Revision 6.43  2002/12/26 16:39:25  vasilche
  1648.  * Object manager class CSeqMap rewritten.
  1649.  *
  1650.  * Revision 6.42  2002/12/03 15:55:12  dicuccio
  1651.  * Corrected processing of text id accessions with no accession set (in
  1652.  * GetSeqIdString()) - use name instead.
  1653.  *
  1654.  * Revision 6.41  2002/11/26 15:13:32  dicuccio
  1655.  * Added CSeq_id::GetStringDescr() - provides text representations of seq-ids in a
  1656.  * number of formats.
  1657.  *
  1658.  * Revision 6.40  2002/10/23 18:23:07  ucko
  1659.  * Add self-classification (using known type information).
  1660.  *
  1661.  * Revision 6.39  2002/10/22 20:19:14  jianye
  1662.  * Added GetSeqIdString()
  1663.  *
  1664.  * Revision 6.38  2002/10/18 16:03:08  ucko
  1665.  * +CA (eAcc_gb_est)
  1666.  *
  1667.  * Revision 6.37  2002/10/03 18:55:04  clausen
  1668.  * Removed extra whitespace
  1669.  *
  1670.  * Revision 6.36  2002/10/03 17:17:11  clausen
  1671.  * Added BestRank() and WorstRank()
  1672.  *
  1673.  * Revision 6.35  2002/10/03 16:03:00  ucko
  1674.  * +BZ (eAcc_gb_gss)
  1675.  *
  1676.  * Revision 6.34  2002/09/23 16:43:46  ucko
  1677.  * Change check for absence of '|' to use string::find.
  1678.  *
  1679.  * Revision 6.33  2002/09/20 19:55:29  ucko
  1680.  * +BY (eAcc_ddbj_est)
  1681.  *
  1682.  * Revision 6.32  2002/08/28 14:07:56  ucko
  1683.  * IdentifyAccession: handle BX (EMBL genome)
  1684.  *
  1685.  * Revision 6.31  2002/08/26 20:44:06  ucko
  1686.  * CSeq_id::IdentifyAccession: +BW (DDBJ EST)
  1687.  *
  1688.  * Revision 6.30  2002/08/19 16:54:30  ucko
  1689.  * IdentifyAccession: add BV (eAcc_gb_sts).
  1690.  *
  1691.  * Revision 6.29  2002/08/19 15:42:14  ucko
  1692.  * IdentifyAccession: add BU (eAcc_gb_est).
  1693.  *
  1694.  * Revision 6.28  2002/08/16 19:27:01  ucko
  1695.  * Recognize new WGS RefSeq accessions.
  1696.  *
  1697.  * Revision 6.27  2002/08/14 15:52:27  ucko
  1698.  * Add BT and XR_.
  1699.  *
  1700.  * Revision 6.26  2002/08/06 18:22:19  ucko
  1701.  * Properly handle versioned PDB accessions.
  1702.  *
  1703.  * Revision 6.25  2002/08/01 20:33:10  ucko
  1704.  * s_IdentifyAccession -> IdentifyAccession; s_ is only for module-static names.
  1705.  *
  1706.  * Revision 6.24  2002/07/30 19:42:44  ucko
  1707.  * Add s_IdentifyAccession, and use it in the string-based constructor if
  1708.  * the input isn't FASTA-format.
  1709.  * Move CVS log to end.
  1710.  *
  1711.  * Revision 6.23  2002/06/06 20:31:33  clausen
  1712.  * Moved methods using object manager to objects/util
  1713.  *
  1714.  * Revision 6.22  2002/05/22 14:03:40  grichenk
  1715.  * CSerialUserOp -- added prefix UserOp_ to Assign() and Equals()
  1716.  *
  1717.  * Revision 6.21  2002/05/06 03:39:12  vakatov
  1718.  * OM/OM1 renaming
  1719.  *
  1720.  * Revision 6.20  2002/05/03 21:28:17  ucko
  1721.  * Introduce T(Signed)SeqPos.
  1722.  *
  1723.  * Revision 6.19  2002/01/16 18:56:32  grichenk
  1724.  * Removed CRef<> argument from choice variant setter, updated sources to
  1725.  * use references instead of CRef<>s
  1726.  *
  1727.  * Revision 6.18  2002/01/10 19:00:04  clausen
  1728.  * Added GetLength
  1729.  *
  1730.  * Revision 6.17  2002/01/09 15:59:30  grichenk
  1731.  * Fixed includes
  1732.  *
  1733.  * Revision 6.16  2001/10/15 23:00:00  vakatov
  1734.  * CSeq_id::x_Init() -- get rid of unreachable "break;"
  1735.  *
  1736.  * Revision 6.15  2001/08/31 20:05:44  ucko
  1737.  * Fix ICC build.
  1738.  *
  1739.  * Revision 6.14  2001/08/31 16:02:10  clausen
  1740.  * Added new constructors for Fasta and added new id types, tpd, tpe, tpg
  1741.  *
  1742.  * Revision 6.13  2001/07/16 16:22:48  grichenk
  1743.  * Added CSerialUserOp class to create Assign() and Equals() methods for
  1744.  * user-defind classes.
  1745.  * Added SerialAssign<>() and SerialEquals<>() functions.
  1746.  *
  1747.  * Revision 6.12  2001/05/24 20:24:27  grichenk
  1748.  * Renamed seq/objmgrstub.hpp -> obgmgr/objmgr_base.hpp
  1749.  * Added Genbank, Embl and Ddbj support in CSeq_id::Compare()
  1750.  * Fixed General output by CSeq_id::WriteAsFasta()
  1751.  *
  1752.  * Revision 6.11  2001/04/17 04:14:49  vakatov
  1753.  * CSeq_id::AsFastaString() --> CSeq_id::WriteAsFasta()
  1754.  *
  1755.  * Revision 6.10  2001/01/03 16:39:05  vasilche
  1756.  * Added CAbstractObjectManager - stub for object manager.
  1757.  * CRange extracted to separate file.
  1758.  *
  1759.  * Revision 6.9  2000/12/26 17:28:55  vasilche
  1760.  * Simplified and formatted code.
  1761.  *
  1762.  * Revision 6.8  2000/12/15 19:30:31  ostell
  1763.  * Used Upcase() in AsFastaString() and changed to PNocase().Equals() style
  1764.  *
  1765.  * Revision 6.7  2000/12/08 22:19:45  ostell
  1766.  * changed MakeFastString to AsFastaString and to use ostream instead of string
  1767.  *
  1768.  * Revision 6.6  2000/12/08 20:45:14  ostell
  1769.  * added MakeFastaString()
  1770.  *
  1771.  * Revision 6.5  2000/12/04 15:09:41  vasilche
  1772.  * Added missing include.
  1773.  *
  1774.  * Revision 6.4  2000/11/30 22:08:18  ostell
  1775.  * finished Match()
  1776.  *
  1777.  * Revision 6.3  2000/11/30 16:13:12  ostell
  1778.  * added support for Textseq_id to Seq_id.Match()
  1779.  *
  1780.  * Revision 6.2  2000/11/28 12:47:41  ostell
  1781.  * fixed first switch statement to break properly
  1782.  *
  1783.  * Revision 6.1  2000/11/21 18:58:29  vasilche
  1784.  * Added Match() methods for CSeq_id, CObject_id and CDbtag.
  1785.  *
  1786.  * ===========================================================================
  1787.  */