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

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

生物技术

开发平台：

C/C++

fasta.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: fasta.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:46:18  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: fasta.cpp,v 1000.2 2004/06/01 19:46:18 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. * Authors:  Aaron Ucko, NCBI;  Anatoliy Kuznetsov, NCBI.
  36. *
  37. * File Description:
  38. *   Reader for FASTA-format sequences.  (The writer is CFastaOStream, in
  39. *   src/objmgr/util/sequence.cpp.)
  40. *
  41. * ===========================================================================
  42. */
  44. #include <ncbi_pch.hpp>
  45. #include <objtools/readers/fasta.hpp>
  46. #include <objtools/readers/reader_exception.hpp>
  48. #include <corelib/ncbiutil.hpp>
  49. #include <util/format_guess.hpp>
  51. #include <objects/general/Object_id.hpp>
  53. #include <objects/seq/Bioseq.hpp>
  54. #include <objects/seq/Delta_ext.hpp>
  55. #include <objects/seq/Delta_seq.hpp>
  56. #include <objects/seq/IUPACaa.hpp>
  57. #include <objects/seq/IUPACna.hpp>
  58. #include <objects/seq/Seq_descr.hpp>
  59. #include <objects/seq/Seq_ext.hpp>
  60. #include <objects/seq/Seq_inst.hpp>
  61. #include <objects/seq/Seq_literal.hpp>
  62. #include <objects/seq/Seqdesc.hpp>
  63. #include <objects/seq/seqport_util.hpp>
  65. #include <objects/seqloc/Seq_id.hpp>
  66. #include <objects/seqloc/Seq_interval.hpp>
  67. #include <objects/seqloc/Seq_loc.hpp>
  68. #include <objects/seqloc/Seq_loc_mix.hpp>
  69. #include <objects/seqloc/Seq_point.hpp>
  71. #include <objects/seqset/Bioseq_set.hpp>
  74. BEGIN_NCBI_SCOPE
  75. BEGIN_SCOPE(objects)
  77. static SIZE_TYPE s_EndOfFastaID(const string& str, SIZE_TYPE pos)
  78. {
  79.     SIZE_TYPE vbar = str.find('|', pos);
  80.     if (vbar == NPOS) {
  81.         return NPOS; // bad
  82.     }
  84.     CSeq_id::E_Choice choice =
  85.         CSeq_id::WhichInverseSeqId(str.substr(pos, vbar - pos).c_str());
  87. #if 1
  88.     if (choice != CSeq_id::e_not_set) {
  89.         SIZE_TYPE vbar_prev = vbar;
  90.         int count;
  91.         for (count=0; ; ++count, vbar_prev = vbar) {
  92.             vbar = str.find('|', vbar_prev + 1);
  93.             if (vbar == NPOS) {
  94.                 break;
  95.             }
  96.             choice = CSeq_id::WhichInverseSeqId(
  97.                 str.substr(vbar_prev + 1, vbar - vbar_prev - 1).c_str());
  98.             if (choice != CSeq_id::e_not_set) {
  99.                 vbar = vbar_prev;
  100.                 break;
  101.             }
  102.         }
  103.     } else {
  104.         return NPOS; // bad
  105.     }
  106. #else
  107.     switch (choice) {
  108.     case CSeq_id::e_Patent: case CSeq_id::e_Other: // 3 args
  109.         vbar = str.find('|', vbar + 1);
  110.         // intentional fall-through - this allows us to correctly
  111.         // calculate the number of '|' separations for FastA IDs
  113.     case CSeq_id::e_Genbank:   case CSeq_id::e_Embl:    case CSeq_id::e_Pir:
  114.     case CSeq_id::e_Swissprot: case CSeq_id::e_General: case CSeq_id::e_Ddbj:
  115.     case CSeq_id::e_Prf:       case CSeq_id::e_Pdb:     case CSeq_id::e_Tpg:
  116.     case CSeq_id::e_Tpe:       case CSeq_id::e_Tpd:
  117.         // 2 args
  118.         if (vbar == NPOS) {
  119.             return NPOS; // bad
  120.         }
  121.         vbar = str.find('|', vbar + 1);
  122.         // intentional fall-through - this allows us to correctly
  123.         // calculate the number of '|' separations for FastA IDs
  125.     case CSeq_id::e_Local: case CSeq_id::e_Gibbsq: case CSeq_id::e_Gibbmt:
  126.     case CSeq_id::e_Giim:  case CSeq_id::e_Gi:
  127.         // 1 arg
  128.         if (vbar == NPOS) {
  129.             if (choice == CSeq_id::e_Other) {
  130.                 // this is acceptable - member is optional
  131.                 break;
  132.             }
  133.             return NPOS; // bad
  134.         }
  135.         vbar = str.find('|', vbar + 1);
  136.         break;
  138.     default: // unrecognized or not set
  139.         return NPOS; // bad
  140.     }
  141. #endif
  143.     return (vbar == NPOS) ? str.size() : vbar;
  144. }
  147. static void s_FixSeqData(CBioseq* seq)
  148. {
  149.     _ASSERT(seq);
  150.     CSeq_inst& inst = seq->SetInst();
  151.     switch (inst.GetRepr()) {
  152.     case CSeq_inst::eRepr_delta:
  153.     {
  154.         TSeqPos length = 0;
  155.         NON_CONST_ITERATE (CDelta_ext::Tdata, it,
  156.                            inst.SetExt().SetDelta().Set()) {
  157.             if ((*it)->IsLiteral()) {
  158.                 CSeq_literal& lit  = (*it)->SetLiteral();
  159.                 CSeq_data&    data = lit.SetSeq_data();
  160.                 if (data.IsIupacna()) {
  161.                     lit.SetLength(data.GetIupacna().Get().size());
  162.                     CSeqportUtil::Pack(&data);
  163.                 } else {
  164.                     string& s = data.SetIupacaa().Set();
  165.                     lit.SetLength(s.size());
  166.                     s.reserve(s.size()); // free extra allocation
  167.                 }
  168.                 length += lit.GetLength();
  169.             }
  170.         }
  171.         break;
  172.     }
  173.     case CSeq_inst::eRepr_raw:
  174.     {
  175.         CSeq_data& data = inst.SetSeq_data();
  176.         if (data.IsIupacna()) {
  177.             inst.SetLength(data.GetIupacna().Get().size());
  178.             CSeqportUtil::Pack(&data);
  179.         } else {
  180.             string& s = data.SetIupacaa().Set();
  181.             inst.SetLength(s.size());
  182.             s.reserve(s.size()); // free extra allocation
  183.         }        
  184.         break;
  185.     }
  186.     default: // especially not_set!
  187.         break;
  188.     }
  189. }
  192. void s_AddData(CSeq_inst& inst, const string& residues)
  193. {
  194.     CRef<CSeq_data> data;
  195.     if (inst.IsSetExt()  &&  inst.GetExt().IsDelta()) {
  196.         CDelta_ext::Tdata& delta_data = inst.SetExt().SetDelta().Set();
  197.         if (delta_data.empty()  ||  !delta_data.back()->IsLiteral()) {
  198.             CRef<CDelta_seq> delta_seq(new CDelta_seq);
  199.             delta_data.push_back(delta_seq);
  200.             data = &delta_seq->SetLiteral().SetSeq_data();
  201.         } else {
  202.             data = &delta_data.back()->SetLiteral().SetSeq_data();
  203.         }
  204.     } else {
  205.         data = &inst.SetSeq_data();
  206.     }
  208.     string* s = 0;
  209.     if (inst.GetMol() == CSeq_inst::eMol_aa) {
  210.         if (data->IsIupacaa()) {
  211.             s = &data->SetIupacaa().Set();
  212.         } else {
  213.             data->SetIupacaa().Set(residues);
  214.         }
  215.     } else {
  216.         if (data->IsIupacna()) {
  217.             s = &data->SetIupacna().Set();
  218.         } else {
  219.             data->SetIupacna().Set(residues);
  220.         }
  221.     }
  223.     if (s) {
  224.         // grow exponentially to avoid O(n^2) behavior
  225.         if (s->capacity() < s->size() + residues.size()) {
  226.             s->reserve(s->capacity()
  227.                        + max(residues.size(), s->capacity() / 2));
  228.         }
  229.         *s += residues;
  230.     }
  231. }
  234. static CSeq_inst::EMol s_ParseFastaDefline(CBioseq::TId& ids, string& title,
  235.                                            const string& line,
  236.                                            TReadFastaFlags flags, int* counter)
  237. {
  238.     SIZE_TYPE       start = 0;
  239.     CSeq_inst::EMol mol   = CSeq_inst::eMol_not_set;
  240.     do {
  241.         ++start;
  242.         SIZE_TYPE space = line.find_first_of(" t", start);
  243.         string    name  = line.substr(start, space - start), local;
  245.         if (flags & fReadFasta_NoParseID) {
  246.             local = name;
  247.         } else {
  248.             // try to parse out IDs
  249.             SIZE_TYPE pos = 0;
  250.             while (pos < name.size()) {
  251.                 SIZE_TYPE end = s_EndOfFastaID(name, pos);
  252.                 if (end == NPOS) {
  253.                     if (pos > 0) {
  254.                         NCBI_THROW2(CObjReaderParseException, eFormat,
  255.                                     "s_ParseFastaDefline: Bad ID "
  256.                                     + name.substr(pos),
  257.                                     pos);
  258.                     } else {
  259.                         local = name;
  260.                         break;
  261.                     }
  262.                 }
  264.                 CRef<CSeq_id> id(new CSeq_id(name.substr(pos, end - pos)));
  265.                 ids.push_back(id);
  266.                 if (mol == CSeq_inst::eMol_not_set
  267.                     &&  !(flags & fReadFasta_ForceType)) {
  268.                     CSeq_id::EAccessionInfo ai = id->IdentifyAccession();
  269.                     if (ai & CSeq_id::fAcc_nuc) {
  270.                         mol = CSeq_inst::eMol_na;
  271.                     } else if (ai & CSeq_id::fAcc_prot) {
  272.                         mol = CSeq_inst::eMol_aa;
  273.                     }
  274.                 }
  275.                 pos = end + 1;
  276.             }
  277.         }
  278.             
  279.         if ( !local.empty() ) {
  280.             ids.push_back(CRef<CSeq_id>
  281.                           (new CSeq_id(CSeq_id::e_Local, local, kEmptyStr)));
  282.         }
  284.         start = line.find('1', start);
  285.         if (space != NPOS  &&  title.empty()) {
  286.             title.assign(line, space + 1,
  287.                          (start == NPOS) ? NPOS : (start - space - 1));
  288.         }
  289.     } while (start != NPOS  &&  (flags & fReadFasta_AllSeqIds));
  291.     if (ids.empty()) {
  292.         CRef<CSeq_id> id(new CSeq_id);
  293.         id->SetLocal().SetId(++*counter);
  294.         ids.push_back(id);
  295.     }
  297.     return mol;
  298. }
  301. static void s_GuessMol(CSeq_inst::EMol& mol, const string& data,
  302.                        TReadFastaFlags flags, istream& in)
  303. {
  304.     if (mol != CSeq_inst::eMol_not_set) {
  305.         return; // already known; no need to guess
  306.     }
  308.     if (mol == CSeq_inst::eMol_not_set  &&  !(flags & fReadFasta_ForceType)) {
  309.         switch (CFormatGuess::SequenceType(data.data(), data.size())) {
  310.         case CFormatGuess::eNucleotide:  mol = CSeq_inst::eMol_na;  return;
  311.         case CFormatGuess::eProtein:     mol = CSeq_inst::eMol_aa;  return;
  312.         default:                         break;
  313.         }
  314.     }
  316.     // ForceType was set, or CFormatGuess failed, so we have to rely on
  317.     // explicit assumptions
  318.     if (flags & fReadFasta_AssumeNuc) {
  319.         _ASSERT(!(flags & fReadFasta_AssumeProt));
  320.         mol = CSeq_inst::eMol_na;
  321.     } else if (flags & fReadFasta_AssumeProt) {
  322.         mol = CSeq_inst::eMol_aa;
  323.     } else { 
  324.         NCBI_THROW2(CObjReaderParseException, eFormat,
  325.                     "ReadFasta: unable to deduce molecule type"
  326.                     " from IDs, flags, or sequence",
  327.                     in.tellg() - CT_POS_TYPE(0));
  328.     }
  329. }
  332. CRef<CSeq_entry> ReadFasta(CNcbiIstream& in, TReadFastaFlags flags,
  333.                            int* counter, vector<CConstRef<CSeq_loc> >* lcv)
  334. {
  335.     if ( !in ) {
  336.         NCBI_THROW2(CObjReaderParseException, eFormat,
  337.                     "ReadFasta: Input stream no longer valid",
  338.                     in.tellg() - CT_POS_TYPE(0));
  339.     } else {
  340.         CT_INT_TYPE c = in.peek();
  341.         if ( !strchr(">#!nr", CT_TO_CHAR_TYPE(c)) ) {
  342.             NCBI_THROW2
  343.                 (CObjReaderParseException, eFormat,
  344.                  "ReadFasta: Input doesn't start with a defline or comment",
  345.                  in.tellg() - CT_POS_TYPE(0));
  346.         }
  347.     }
  349.     CRef<CSeq_entry>       entry(new CSeq_entry);
  350.     CBioseq_set::TSeq_set& sset  = entry->SetSet().SetSeq_set();
  351.     CRef<CBioseq>          seq(0); // current Bioseq
  352.     string                 line;
  353.     TSeqPos                pos = 0, lc_start = 0;
  354.     bool                   was_lc = false;
  355.     CRef<CSeq_id>          best_id;
  356.     CRef<CSeq_loc>         lowercase(0);
  357.     int                    defcounter = 1;
  359.     if ( !counter ) {
  360.         counter = &defcounter;
  361.     }
  363.     while ( !in.eof() ) {
  364.         if ((flags & fReadFasta_OneSeq)  &&  seq.NotEmpty()
  365.             &&  (in.peek() == '>')) {
  366.             break;
  367.         }
  368.         NcbiGetlineEOL(in, line);
  369.         if (in.eof()  &&  line.empty()) {
  370.             break;
  371.         } else if (line.empty()) {
  372.             continue;
  373.         }
  374.         if (line[0] == '>') {
  375.             // new sequence
  376.             if (seq) {
  377.                 s_FixSeqData(seq);
  378.                 if (was_lc) {
  379.                     lowercase->SetPacked_int().AddInterval
  380.                         (*best_id, lc_start, pos);
  381.                 }
  382.             }
  383.             seq = new CBioseq;
  384.             if (flags & fReadFasta_NoSeqData) {
  385.                 seq->SetInst().SetRepr(CSeq_inst::eRepr_not_set);
  386.             } else {
  387.                 seq->SetInst().SetRepr(CSeq_inst::eRepr_raw);
  388.             }
  389.             {{
  390.                 CRef<CSeq_entry> entry2(new CSeq_entry);
  391.                 entry2->SetSeq(*seq);
  392.                 sset.push_back(entry2);
  393.             }}
  394.             string          title;
  395.             CSeq_inst::EMol mol = s_ParseFastaDefline(seq->SetId(), title,
  396.                                                       line, flags, counter);
  397.             if (mol == CSeq_inst::eMol_not_set
  398.                 &&  (flags & fReadFasta_NoSeqData)) {
  399.                 if (flags & fReadFasta_AssumeNuc) {
  400.                     _ASSERT(!(flags & fReadFasta_AssumeProt));
  401.                     mol = CSeq_inst::eMol_na;
  402.                 } else if (flags & fReadFasta_AssumeProt) {
  403.                     mol = CSeq_inst::eMol_aa;
  404.                 }
  405.             }
  406.             seq->SetInst().SetMol(mol);
  408.             if ( !title.empty() ) {
  409.                 CRef<CSeqdesc> desc(new CSeqdesc);
  410.                 desc->SetTitle(title);
  411.                 seq->SetDescr().Set().push_back(desc);
  412.             }
  414.             if (lcv) {
  415.                 pos       = 0;
  416.                 was_lc    = false;
  417.                 best_id   = FindBestChoice(seq->GetId(), CSeq_id::Score);
  418.                 lowercase = new CSeq_loc;
  419.                 lowercase->SetNull();
  420.                 lcv->push_back(lowercase);
  421.             }
  422.         } else if (line[0] == '#'  ||  line[0] == '!') {
  423.             continue; // comment
  424.         } else if ( !seq ) {
  425.             NCBI_THROW2
  426.                 (CObjReaderParseException, eFormat,
  427.                  "ReadFasta: No defline preceding data",
  428.                  in.tellg() - CT_POS_TYPE(0));
  429.         } else if ( !(flags & fReadFasta_NoSeqData) ) {
  430.             // These don't change, but the calls may be relatively expensive,
  431.             // esp. with ref-counted implementations.
  432.             SIZE_TYPE   line_size = line.size();
  433.             const char* line_data = line.data();
  434.             // actual data; may contain embedded junk
  435.             CSeq_inst&  inst      = seq->SetInst();
  436.             string      residues(line_size + 1, '');
  437.             char*       res_data  = const_cast<char*>(residues.data());
  438.             SIZE_TYPE   res_count = 0;
  439.             for (SIZE_TYPE i = 0;  i < line_size;  ++i) {
  440.                 char c = line_data[i];
  441.                 if (isalpha(c)) {
  442.                     if (lowercase) {
  443.                         bool is_lc = islower(c) ? true : false;
  444.                         if (is_lc && !was_lc) {
  445.                             lc_start = pos;
  446.                         } else if (was_lc && !is_lc) {
  447.                             lowercase->SetPacked_int().AddInterval
  448.                                 (*best_id, lc_start, pos);
  449.                         }
  450.                         was_lc = is_lc;
  451.                         ++pos;
  452.                     }
  453.                     res_data[res_count++] = toupper(c);
  454.                 } else if (c == '-'  &&  (flags & fReadFasta_ParseGaps)) {
  455.                     CDelta_ext::Tdata& d = inst.SetExt().SetDelta().Set();
  456.                     if (inst.GetRepr() == CSeq_inst::eRepr_raw) {
  457.                         CRef<CDelta_seq> ds(new CDelta_seq);
  458.                         inst.SetRepr(CSeq_inst::eRepr_delta);
  459.                         if (inst.IsSetSeq_data()) {
  460.                             ds->SetLiteral().SetSeq_data(inst.SetSeq_data());
  461.                             d.push_back(ds);
  462.                             inst.ResetSeq_data();
  463.                         }
  464.                     }
  465.                     if ( res_count ) {
  466.                         residues.resize(res_count);
  467.                         if (inst.GetMol() == CSeq_inst::eMol_not_set) {
  468.                             s_GuessMol(inst.SetMol(), residues, flags, in);
  469.                         }
  470.                         s_AddData(inst, residues);
  471.                     }
  472.                     {{
  473.                         CRef<CDelta_seq> gap(new CDelta_seq);
  474.                         gap->SetLoc().SetNull();
  475.                         d.push_back(gap);
  476.                     }}
  477.                     res_count = 0;
  478.                 } else if (c == ';') {
  479.                     continue; // skip rest of line
  480.                 }
  481.             }
  483.             if (inst.GetMol() == CSeq_inst::eMol_not_set) {
  484.                 s_GuessMol(inst.SetMol(), residues, flags, in);
  485.             }
  486.             
  487.             // Add the accumulated data...
  488.             residues.resize(res_count);
  489.             s_AddData(inst, residues);
  490.         }
  491.     }
  493.     if (seq) {
  494.         s_FixSeqData(seq);
  495.         if (was_lc) {
  496.             lowercase->SetPacked_int().AddInterval(*best_id, lc_start, pos);
  497.         }
  498.     }
  499.     // simplify if possible
  500.     if (sset.size() == 1) {
  501.         entry->SetSeq(*seq);
  502.     }
  503.     return entry;
  504. }
  507. void ReadFastaFileMap(SFastaFileMap* fasta_map, CNcbiIfstream& input)
  508. {
  509.     _ASSERT(fasta_map);
  511.     fasta_map->file_map.resize(0);
  513.     if (!input.is_open()) 
  514.         return;
  516.     while (!input.eof()) {
  517.         SFastaFileMap::SFastaEntry  fasta_entry;
  518.         fasta_entry.stream_offset = input.tellg() - CT_POS_TYPE(0);
  520.         CRef<CSeq_entry> se;
  521.         se = ReadFasta(input, fReadFasta_AssumeNuc | fReadFasta_OneSeq);
  523.         if (!se->IsSeq()) 
  524.             continue;
  526.         const CSeq_entry::TSeq& bioseq = se->GetSeq();
  527.         const CSeq_id* sid = bioseq.GetFirstId();
  528.         fasta_entry.seq_id = sid->AsFastaString();
  529.         if (bioseq.CanGetDescr()) {
  530.             const CSeq_descr& d = bioseq.GetDescr();
  531.             if (d.CanGet()) {
  532.                 const CSeq_descr_Base::Tdata& data = d.Get();
  533.                 if (!data.empty()) {
  534.                     CSeq_descr_Base::Tdata::const_iterator it = 
  535.                                                       data.begin();
  536.                     if (it != data.end()) {
  537.                         CRef<CSeqdesc> ref_desc = *it;
  538.                         ref_desc->GetLabel(&fasta_entry.description, 
  539.                                            CSeqdesc::eContent);
  540.                     }                                
  541.                 }
  542.             }
  543.         }
  544.         fasta_map->file_map.push_back(fasta_entry);
  545.         
  547.     } // while
  549. }
  551. END_SCOPE(objects)
  552. END_NCBI_SCOPE
  554. /*
  555. * ===========================================================================
  556. *
  557. * $Log: fasta.cpp,v $
  558. * Revision 1000.2  2004/06/01 19:46:18  gouriano
  559. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.12
  560. *
  561. * Revision 1.12  2004/05/21 21:42:55  gorelenk
  562. * Added PCH ncbi_pch.hpp
  563. *
  564. * Revision 1.11  2004/02/19 22:57:52  ucko
  565. * Accommodate stricter implementations of CT_POS_TYPE.
  566. *
  567. * Revision 1.10  2003/12/05 03:00:36  ucko
  568. * Validate input better.
  569. *
  570. * Revision 1.9  2003/10/03 15:09:18  ucko
  571. * Tweak sequence string allocation to avoid O(n^2) performance from
  572. * linear resizing.
  573. *
  574. * Revision 1.8  2003/08/25 21:30:09  ucko
  575. * ReadFasta: tweak a bit to improve performance, and fix some bugs in
  576. * parsing gaps.
  577. *
  578. * Revision 1.7  2003/08/11 14:39:54  ucko
  579. * Populate "lowercase" with Packed_seqints rather than general Seq_loc_mixes.
  580. *
  581. * Revision 1.6  2003/08/08 21:29:12  dondosha
  582. * Changed type of lcase_mask in ReadFasta to vector of CConstRefs
  583. *
  584. * Revision 1.5  2003/08/07 21:13:21  ucko
  585. * Support a counter for assigning local IDs to sequences with no ID given.
  586. * Fix some minor bugs in lowercase-character support.
  587. *
  588. * Revision 1.4  2003/08/06 19:08:33  ucko
  589. * Slight interface tweak to ReadFasta: report lowercase locations in a
  590. * vector with one entry per Bioseq rather than a consolidated Seq_loc_mix.
  591. *
  592. * Revision 1.3  2003/06/23 20:49:11  kuznets
  593. * Changed to use Seq_id::AsFastaString() when reading fasta file map.
  594. *
  595. * Revision 1.2  2003/06/08 16:17:00  lavr
  596. * Heed MSVC int->bool performance warning
  597. *
  598. * Revision 1.1  2003/06/04 17:26:22  ucko
  599. * Split out from Seq_entry.cpp.
  600. *
  601. *
  602. * ===========================================================================
  603. */