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

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

生物技术

开发平台：

C/C++

readfeat.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: readfeat.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:46:24  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.35
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*
  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:  Jonathan Kans
  36.  *
  37.  * File Description:
  38.  *   Feature table reader
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistd.hpp>
  44. #include <corelib/ncbithr.hpp>
  46. #include <serial/iterator.hpp>
  47. #include <serial/objistrasn.hpp>
  49. // Objects includes
  50. #include <objects/general/Int_fuzz.hpp>
  51. #include <objects/general/Object_id.hpp>
  52. #include <objects/general/Dbtag.hpp>
  54. #include <objects/seqloc/Seq_id.hpp>
  55. #include <objects/seqloc/Seq_loc.hpp>
  56. #include <objects/seqloc/Seq_interval.hpp>
  57. #include <objects/seqloc/Seq_point.hpp>
  59. #include <objects/seq/Seq_annot.hpp>
  60. #include <objects/seq/Annotdesc.hpp>
  61. #include <objects/seq/Annot_descr.hpp>
  62. #include <objects/seqfeat/SeqFeatData.hpp>
  64. #include <objects/seqfeat/Seq_feat.hpp>
  65. #include <objects/seqfeat/BioSource.hpp>
  66. #include <objects/seqfeat/Org_ref.hpp>
  67. #include <objects/seqfeat/OrgName.hpp>
  68. #include <objects/seqfeat/SubSource.hpp>
  69. #include <objects/seqfeat/OrgMod.hpp>
  70. #include <objects/seqfeat/Gene_ref.hpp>
  71. #include <objects/seqfeat/Cdregion.hpp>
  72. #include <objects/seqfeat/Code_break.hpp>
  73. #include <objects/seqfeat/Genetic_code.hpp>
  74. #include <objects/seqfeat/Genetic_code_table.hpp>
  75. #include <objects/seqfeat/RNA_ref.hpp>
  76. #include <objects/seqfeat/Trna_ext.hpp>
  77. #include <objects/seqfeat/Imp_feat.hpp>
  78. #include <objects/seqfeat/Gb_qual.hpp>
  80. #include <objtools/readers/readfeat.hpp>
  82. #include <algorithm>
  84. BEGIN_NCBI_SCOPE
  86. BEGIN_objects_SCOPE // namespace ncbi::objects::
  88. class /* NCBI_XOBJREAD_EXPORT */ CFeature_table_reader_imp
  89. {
  90. public:
  91.     enum EQual {
  92.         eQual_allele,
  93.         eQual_anticodon,
  94.         eQual_bond_type,
  95.         eQual_bound_moiety,
  96.         eQual_citation,
  97.         eQual_clone,
  98.         eQual_codon_start,
  99.         eQual_cons_splice,
  100.         eQual_db_xref,
  101.         eQual_direction,
  102.         eQual_EC_number,
  103.         eQual_evidence,
  104.         eQual_exception,
  105.         eQual_frequency,
  106.         eQual_function,
  107.         eQual_gene,
  108.         eQual_gene_desc,
  109.         eQual_gene_syn,
  110.         eQual_go_component,
  111.         eQual_go_function,
  112.         eQual_go_process,
  113.         eQual_insertion_seq,
  114.         eQual_label,
  115.         eQual_locus_tag,
  116.         eQual_macronuclear,
  117.         eQual_map,
  118.         eQual_MEDLINE,
  119.         eQual_mod_base,
  120.         eQual_muid,
  121.         eQual_note,
  122.         eQual_number,
  123.         eQual_operon,
  124.         eQual_organism,
  125.         eQual_partial,
  126.         eQual_PCR_conditions,
  127.         eQual_phenotype,
  128.         eQual_pmid,
  129.         eQual_product,
  130.         eQual_prot_desc,
  131.         eQual_prot_note,
  132.         eQual_protein_id,
  133.         eQual_pseudo,
  134.         eQual_PubMed,
  135.         eQual_region_name,
  136.         eQual_replace,
  137.         eQual_rpt_family,
  138.         eQual_rpt_type,
  139.         eQual_rpt_unit,
  140.         eQual_site_type,
  141.         eQual_standard_name,
  142.         eQual_transcript_id,
  143.         eQual_transl_except,
  144.         eQual_transl_table,
  145.         eQual_translation,
  146.         eQual_transposon,
  147.         eQual_usedin
  148.     };
  150.     enum EOrgRef {
  151.         eOrgRef_organism,
  152.         eOrgRef_organelle,
  153.         eOrgRef_div,
  154.         eOrgRef_lineage,
  155.         eOrgRef_gcode,
  156.         eOrgRef_mgcode
  157.     };
  159.     typedef map< string, CSeqFeatData::ESubtype > TFeatReaderMap;
  160.     typedef map< string, EQual > TQualReaderMap;
  161.     typedef map< string, EOrgRef > TOrgRefReaderMap;
  162.     typedef map< string, CBioSource::EGenome > TGenomeReaderMap;
  163.     typedef map< string, CSubSource::ESubtype > TSubSrcReaderMap;
  164.     typedef map< string, COrgMod::ESubtype > TOrgModReaderMap;
  165.     typedef map< string, CSeqFeatData::EBond > TBondReaderMap;
  166.     typedef map< string, CSeqFeatData::ESite > TSiteReaderMap;
  167.     typedef map< string, int > TTrnaReaderMap;
  168.     typedef vector< string > TSingleQualList;
  170.     // constructor
  171.     CFeature_table_reader_imp(void);
  172.     // destructor
  173.     ~CFeature_table_reader_imp(void);
  175.     // read 5-column feature table and return Seq-annot
  176.     CRef<CSeq_annot> ReadSequinFeatureTable (CNcbiIstream& ifs,
  177.                                              const string& seqid,
  178.                                              const string& annotname,
  179.                                              const CFeature_table_reader::TFlags flags);
  181.     // create single feature from key
  182.     CRef<CSeq_feat> CreateSeqFeat (const string& feat,
  183.                                    CSeq_loc& location,
  184.                                    const CFeature_table_reader::TFlags flags);
  186.     // add single qualifier to feature
  187.     void AddFeatQual (CRef<CSeq_feat> sfp,
  188.                       const string& qual,
  189.                       const string& val,
  190.                       const CFeature_table_reader::TFlags flags);
  192. private:
  193.     // Prohibit copy constructor and assignment operator
  194.     CFeature_table_reader_imp(const CFeature_table_reader_imp& value);
  195.     CFeature_table_reader_imp& operator=(const CFeature_table_reader_imp& value);
  197.     bool x_ParseFeatureTableLine (const string& line, Int4* startP, Int4* stopP,
  198.                                   bool* partial5P, bool* partial3P, bool* ispointP,
  199.                                   string& featP, string& qualP, string& valP, Int4 offset);
  201.     bool x_AddIntervalToFeature (CRef<CSeq_feat> sfp, CSeq_loc_mix *mix,
  202.                                  const string& seqid, Int4 start,
  203.                                  Int4 stop, bool partial5, bool partial3);
  205.     bool x_AddQualifierToFeature (CRef<CSeq_feat> sfp,
  206.                                   const string& qual, const string& val);
  208.     bool x_AddQualifierToGene     (CSeqFeatData& sfdata,
  209.                                    EQual qtype, const string& val);
  210.     bool x_AddQualifierToCdregion (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
  211.                                    EQual qtype, const string& val);
  212.     bool x_AddQualifierToRna      (CSeqFeatData& sfdata,
  213.                                    EQual qtype, const string& val);
  214.     bool x_AddQualifierToImp      (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
  215.                                    EQual qtype, const string& qual, const string& val);
  216.     bool x_AddQualifierToBioSrc   (CSeqFeatData& sfdata,
  217.                                    EOrgRef rtype, const string& val);
  218.     bool x_AddQualifierToBioSrc   (CSeqFeatData& sfdata,
  219.                                    CSubSource::ESubtype stype, const string& val);
  220.     bool x_AddQualifierToBioSrc   (CSeqFeatData& sfdata,
  221.                                    COrgMod::ESubtype mtype, const string& val);
  223.     int x_ParseTrnaString (const string& val);
  225.     TFeatReaderMap    m_FeatKeys;
  226.     TQualReaderMap    m_QualKeys;
  227.     TOrgRefReaderMap  m_OrgRefKeys;
  228.     TGenomeReaderMap  m_GenomeKeys;
  229.     TSubSrcReaderMap  m_SubSrcKeys;
  230.     TOrgModReaderMap  m_OrgModKeys;
  231.     TBondReaderMap    m_BondKeys;
  232.     TSiteReaderMap    m_SiteKeys;
  233.     TTrnaReaderMap    m_TrnaKeys;
  234.     TSingleQualList   m_SingleKeys;
  235. };
  237. auto_ptr<CFeature_table_reader_imp> CFeature_table_reader::sm_Implementation;
  239. void CFeature_table_reader::x_InitImplementation()
  240. {
  241.     DEFINE_STATIC_FAST_MUTEX(s_Implementation_mutex);
  243.     CFastMutexGuard   LOCK(s_Implementation_mutex);
  244.     if ( !sm_Implementation.get() ) {
  245.         sm_Implementation.reset(new CFeature_table_reader_imp());
  246.     }
  247. }
  250. typedef struct featinit {
  251.     const char *           key;
  252.     CSeqFeatData::ESubtype subtype;
  253. } FeatInit;
  255. static FeatInit feat_key_to_subtype [] = {
  256.     { "-10_signal",         CSeqFeatData::eSubtype_10_signal          },
  257.     { "-35_signal",         CSeqFeatData::eSubtype_35_signal          },
  258.     { "3'clip",             CSeqFeatData::eSubtype_3clip              },
  259.     { "3'UTR",              CSeqFeatData::eSubtype_3UTR               },
  260.     { "5'clip",             CSeqFeatData::eSubtype_5clip              },
  261.     { "5'UTR",              CSeqFeatData::eSubtype_5UTR               },
  262.     { "attenuator",         CSeqFeatData::eSubtype_attenuator         },
  263.     { "Bond",               CSeqFeatData::eSubtype_bond               },
  264.     { "CAAT_signal",        CSeqFeatData::eSubtype_CAAT_signal        },
  265.     { "CDS",                CSeqFeatData::eSubtype_cdregion           },
  266.     { "Cit",                CSeqFeatData::eSubtype_pub                },
  267.     { "Comment",            CSeqFeatData::eSubtype_comment            },
  268.     { "conflict",           CSeqFeatData::eSubtype_conflict           },
  269.     { "C_region",           CSeqFeatData::eSubtype_C_region           },
  270.     { "D-loop",             CSeqFeatData::eSubtype_D_loop             },
  271.     { "D_segment",          CSeqFeatData::eSubtype_D_segment          },
  272.     { "enhancer",           CSeqFeatData::eSubtype_enhancer           },
  273.     { "exon",               CSeqFeatData::eSubtype_exon               },
  274.     { "GC_signal",          CSeqFeatData::eSubtype_GC_signal          },
  275.     { "gene",               CSeqFeatData::eSubtype_gene               },
  276.     { "Het",                CSeqFeatData::eSubtype_het                },
  277.     { "iDNA",               CSeqFeatData::eSubtype_iDNA               },
  278.     { "intron",             CSeqFeatData::eSubtype_intron             },
  279.     { "J_segment",          CSeqFeatData::eSubtype_J_segment          },
  280.     { "LTR",                CSeqFeatData::eSubtype_LTR                },
  281.     { "mat_peptide",        CSeqFeatData::eSubtype_mat_peptide_aa     },
  282.     { "mat_peptide_nt",     CSeqFeatData::eSubtype_mat_peptide        },
  283.     { "misc_binding",       CSeqFeatData::eSubtype_misc_binding       },
  284.     { "misc_difference",    CSeqFeatData::eSubtype_misc_difference    },
  285.     { "misc_feature",       CSeqFeatData::eSubtype_misc_feature       },
  286.     { "misc_recomb",        CSeqFeatData::eSubtype_misc_recomb        },
  287.     { "misc_RNA",           CSeqFeatData::eSubtype_otherRNA           },
  288.     { "misc_signal",        CSeqFeatData::eSubtype_misc_signal        },
  289.     { "misc_structure",     CSeqFeatData::eSubtype_misc_structure     },
  290.     { "modified_base",      CSeqFeatData::eSubtype_modified_base      },
  291.     { "mRNA",               CSeqFeatData::eSubtype_mRNA               },
  292.     { "NonStdRes",          CSeqFeatData::eSubtype_non_std_residue    },
  293.     { "Num",                CSeqFeatData::eSubtype_num                },
  294.     { "N_region",           CSeqFeatData::eSubtype_N_region           },
  295.     { "old_sequence",       CSeqFeatData::eSubtype_old_sequence       },
  296.     { "operon",             CSeqFeatData::eSubtype_operon             },
  297.     { "oriT",               CSeqFeatData::eSubtype_oriT               },
  298.     { "polyA_signal",       CSeqFeatData::eSubtype_polyA_signal       },
  299.     { "polyA_site",         CSeqFeatData::eSubtype_polyA_site         },
  300.     { "precursor_RNA",      CSeqFeatData::eSubtype_preRNA             },
  301.     { "pre_RNA",            CSeqFeatData::eSubtype_preRNA             },
  302.     { "preprotein",         CSeqFeatData::eSubtype_preprotein         },
  303.     { "primer_bind",        CSeqFeatData::eSubtype_primer_bind        },
  304.     { "prim_transcript",    CSeqFeatData::eSubtype_prim_transcript    },
  305.     { "promoter",           CSeqFeatData::eSubtype_promoter           },
  306.     { "Protein",            CSeqFeatData::eSubtype_prot               },
  307.     { "protein_bind",       CSeqFeatData::eSubtype_protein_bind       },
  308.     { "RBS",                CSeqFeatData::eSubtype_RBS                },
  309.     { "REFERENCE",          CSeqFeatData::eSubtype_pub                },
  310.     { "Region",             CSeqFeatData::eSubtype_region             },
  311.     { "repeat_region",      CSeqFeatData::eSubtype_repeat_region      },
  312.     { "repeat_unit",        CSeqFeatData::eSubtype_repeat_unit        },
  313.     { "rep_origin",         CSeqFeatData::eSubtype_rep_origin         },
  314.     { "rRNA",               CSeqFeatData::eSubtype_rRNA               },
  315.     { "Rsite",              CSeqFeatData::eSubtype_rsite              },
  316.     { "satellite",          CSeqFeatData::eSubtype_satellite          },
  317.     { "scRNA",              CSeqFeatData::eSubtype_scRNA              },
  318.     { "SecStr",             CSeqFeatData::eSubtype_psec_str           },
  319.     { "sig_peptide",        CSeqFeatData::eSubtype_sig_peptide_aa     },
  320.     { "sig_peptide_nt",     CSeqFeatData::eSubtype_sig_peptide        },
  321.     { "Site",               CSeqFeatData::eSubtype_site               },
  322.     { "Site-ref",           CSeqFeatData::eSubtype_site_ref           },
  323.     { "snoRNA",             CSeqFeatData::eSubtype_snoRNA             },
  324.     { "snRNA",              CSeqFeatData::eSubtype_snRNA              },
  325.     { "source",             CSeqFeatData::eSubtype_biosrc             },
  326.     { "Src",                CSeqFeatData::eSubtype_biosrc             },
  327.     { "stem_loop",          CSeqFeatData::eSubtype_stem_loop          },
  328.     { "STS",                CSeqFeatData::eSubtype_STS                },
  329.     { "S_region",           CSeqFeatData::eSubtype_S_region           },
  330.     { "TATA_signal",        CSeqFeatData::eSubtype_TATA_signal        },
  331.     { "terminator",         CSeqFeatData::eSubtype_terminator         },
  332.     { "transit_peptide",    CSeqFeatData::eSubtype_transit_peptide_aa },
  333.     { "transit_peptide_nt", CSeqFeatData::eSubtype_transit_peptide    },
  334.     { "tRNA",               CSeqFeatData::eSubtype_tRNA               },
  335.     { "TxInit",             CSeqFeatData::eSubtype_txinit             },
  336.     { "unsure",             CSeqFeatData::eSubtype_unsure             },
  337.     { "User",               CSeqFeatData::eSubtype_user               },
  338.     { "variation",          CSeqFeatData::eSubtype_variation          },
  339.     { "virion",             CSeqFeatData::eSubtype_virion             },
  340.     { "V_region",           CSeqFeatData::eSubtype_V_region           },
  341.     { "V_segment",          CSeqFeatData::eSubtype_V_segment          },
  342.     { "Xref",               CSeqFeatData::eSubtype_seq                }
  343. };
  345. typedef struct qualinit {
  346.     const char *                         key;
  347.     CFeature_table_reader_imp::EQual subtype;
  348. } QualInit;
  350. static QualInit qual_key_to_subtype [] = {
  351.     { "allele",               CFeature_table_reader_imp::eQual_allele               },
  352.     { "anticodon",            CFeature_table_reader_imp::eQual_anticodon            },
  353.     { "bond_type",            CFeature_table_reader_imp::eQual_bond_type            },
  354.     { "bound_moiety",         CFeature_table_reader_imp::eQual_bound_moiety         },
  355.     { "citation",             CFeature_table_reader_imp::eQual_citation             },
  356.     { "clone",                CFeature_table_reader_imp::eQual_clone                },
  357.     { "codon_start",          CFeature_table_reader_imp::eQual_codon_start          },
  358.     { "cons_splice",          CFeature_table_reader_imp::eQual_cons_splice          },
  359.     { "db_xref",              CFeature_table_reader_imp::eQual_db_xref              },
  360.     { "direction",            CFeature_table_reader_imp::eQual_direction            },
  361.     { "EC_number",            CFeature_table_reader_imp::eQual_EC_number            },
  362.     { "evidence",             CFeature_table_reader_imp::eQual_evidence             },
  363.     { "exception",            CFeature_table_reader_imp::eQual_exception            },
  364.     { "frequency",            CFeature_table_reader_imp::eQual_frequency            },
  365.     { "function",             CFeature_table_reader_imp::eQual_function             },
  366.     { "gene",                 CFeature_table_reader_imp::eQual_gene                 },
  367.     { "gene_desc",            CFeature_table_reader_imp::eQual_gene_desc            },
  368.     { "gene_syn",             CFeature_table_reader_imp::eQual_gene_syn             },
  369.     { "go_component",         CFeature_table_reader_imp::eQual_go_component         },
  370.     { "go_function",          CFeature_table_reader_imp::eQual_go_function          },
  371.     { "go_process",           CFeature_table_reader_imp::eQual_go_process           },
  372.     { "insertion_seq",        CFeature_table_reader_imp::eQual_insertion_seq        },
  373.     { "label",                CFeature_table_reader_imp::eQual_label                },
  374.     { "locus_tag",            CFeature_table_reader_imp::eQual_locus_tag            },
  375.     { "macronuclear",         CFeature_table_reader_imp::eQual_macronuclear         },
  376.     { "map",                  CFeature_table_reader_imp::eQual_map                  },
  377.     { "mod_base",             CFeature_table_reader_imp::eQual_mod_base             },
  378.     { "note",                 CFeature_table_reader_imp::eQual_note                 },
  379.     { "number",               CFeature_table_reader_imp::eQual_number               },
  380.     { "operon",               CFeature_table_reader_imp::eQual_operon               },
  381.     { "organism",             CFeature_table_reader_imp::eQual_organism             },
  382.     { "partial",              CFeature_table_reader_imp::eQual_partial              },
  383.     { "PCR_conditions",       CFeature_table_reader_imp::eQual_PCR_conditions       },
  384.     { "phenotype",            CFeature_table_reader_imp::eQual_phenotype            },
  385.     { "product",              CFeature_table_reader_imp::eQual_product              },
  386.     { "protein_id",           CFeature_table_reader_imp::eQual_protein_id           },
  387.     { "prot_desc",            CFeature_table_reader_imp::eQual_prot_desc            },
  388.     { "pseudo",               CFeature_table_reader_imp::eQual_pseudo               },
  389.     { "replace",              CFeature_table_reader_imp::eQual_replace              },
  390.     { "rpt_family",           CFeature_table_reader_imp::eQual_rpt_family           },
  391.     { "rpt_type",             CFeature_table_reader_imp::eQual_rpt_type             },
  392.     { "rpt_unit",             CFeature_table_reader_imp::eQual_rpt_unit             },
  393.     { "standard_name",        CFeature_table_reader_imp::eQual_standard_name        },
  394.     { "transcript_id",        CFeature_table_reader_imp::eQual_transcript_id        },
  395.     { "transl_except",        CFeature_table_reader_imp::eQual_transl_except        },
  396.     { "transl_table",         CFeature_table_reader_imp::eQual_transl_table         },
  397.     { "translation",          CFeature_table_reader_imp::eQual_translation          },
  398.     { "transposon",           CFeature_table_reader_imp::eQual_transposon           },
  399.     { "usedin",               CFeature_table_reader_imp::eQual_usedin               }
  400. };
  402. typedef struct orgrefinit {
  403.     const char *                       key;
  404.     CFeature_table_reader_imp::EOrgRef subtype;
  405. } OrgRefInit;
  407. static OrgRefInit orgref_key_to_subtype [] = {
  408.     { "div",        CFeature_table_reader_imp::eOrgRef_div       },
  409.     { "gcode",      CFeature_table_reader_imp::eOrgRef_gcode     },
  410.     { "lineage",    CFeature_table_reader_imp::eOrgRef_lineage   },
  411.     { "mgcode",     CFeature_table_reader_imp::eOrgRef_mgcode    },
  412.     { "organelle",  CFeature_table_reader_imp::eOrgRef_organelle },
  413.     { "organism",   CFeature_table_reader_imp::eOrgRef_organism  }
  414. };
  416. typedef struct genomeinit {
  417.     const char *        key;
  418.     CBioSource::EGenome subtype;
  419. } GenomeInit;
  421. static GenomeInit genome_key_to_subtype [] = {
  422.     { "unknown",                   CBioSource::eGenome_unknown          },
  423.     { "genomic",                   CBioSource::eGenome_genomic          },
  424.     { "chloroplast",               CBioSource::eGenome_chloroplast      },
  425.     { "plastid:chloroplast",       CBioSource::eGenome_chloroplast      },
  426.     { "chromoplast",               CBioSource::eGenome_chromoplast      },
  427.     { "plastid:chromoplast",       CBioSource::eGenome_chromoplast      },
  428.     { "kinetoplast",               CBioSource::eGenome_kinetoplast      },
  429.     { "mitochondrion:kinetoplast", CBioSource::eGenome_kinetoplast      },
  430.     { "mitochondrion",             CBioSource::eGenome_mitochondrion    },
  431.     { "plastid",                   CBioSource::eGenome_plastid          },
  432.     { "macronuclear",              CBioSource::eGenome_macronuclear     },
  433.     { "extrachrom",                CBioSource::eGenome_extrachrom       },
  434.     { "plasmid",                   CBioSource::eGenome_plasmid          },
  435.     { "transposon",                CBioSource::eGenome_transposon       },
  436.     { "insertion_seq",             CBioSource::eGenome_insertion_seq    },
  437.     { "cyanelle",                  CBioSource::eGenome_cyanelle         },
  438.     { "plastid:cyanelle",          CBioSource::eGenome_cyanelle         },
  439.     { "proviral",                  CBioSource::eGenome_proviral         },
  440.     { "virion",                    CBioSource::eGenome_virion           },
  441.     { "nucleomorph",               CBioSource::eGenome_nucleomorph      },
  442.     { "apicoplast",                CBioSource::eGenome_apicoplast       },
  443.     { "plastid:apicoplast",        CBioSource::eGenome_apicoplast       },
  444.     { "plastid:leucoplast",        CBioSource::eGenome_leucoplast       },
  445.     { "plastid:proplastid",        CBioSource::eGenome_proplastid       },
  446.     { "endogenous_virus",          CBioSource::eGenome_endogenous_virus }
  447. };
  449. typedef struct subsrcinit {
  450.     const char *         key;
  451.     CSubSource::ESubtype subtype;
  452. } SubSrcInit;
  454. static SubSrcInit subsrc_key_to_subtype [] = {
  455.     { "cell_line",            CSubSource::eSubtype_cell_line             },
  456.     { "cell_type",            CSubSource::eSubtype_cell_type             },
  457.     { "chromosome",           CSubSource::eSubtype_chromosome            },
  458.     { "clone",                CSubSource::eSubtype_clone                 },
  459.     { "clone_lib",            CSubSource::eSubtype_clone_lib             },
  460.     { "country",              CSubSource::eSubtype_country               },
  461.     { "dev_stage",            CSubSource::eSubtype_dev_stage             },
  462.     { "endogenous_virus",     CSubSource::eSubtype_endogenous_virus_name },
  463.     { "environmental_sample", CSubSource::eSubtype_environmental_sample  },
  464.     { "frequency",            CSubSource::eSubtype_frequency             },
  465.     { "genotype",             CSubSource::eSubtype_genotype              },
  466.     { "germline",             CSubSource::eSubtype_germline              },
  467.     { "haplotype",            CSubSource::eSubtype_haplotype             },
  468.     { "insertion_seq",        CSubSource::eSubtype_insertion_seq_name    },
  469.     { "isolation_source",     CSubSource::eSubtype_isolation_source      },
  470.     { "lab_host",             CSubSource::eSubtype_lab_host              },
  471.     { "map",                  CSubSource::eSubtype_map                   },
  472.     { "plasmid",              CSubSource::eSubtype_plasmid_name          },
  473.     { "plastid",              CSubSource::eSubtype_plastid_name          },
  474.     { "pop_variant",          CSubSource::eSubtype_pop_variant           },
  475.     { "rearranged",           CSubSource::eSubtype_rearranged            },
  476.     { "segment",              CSubSource::eSubtype_segment               },
  477.     { "sex",                  CSubSource::eSubtype_sex                   },
  478.     { "subclone",             CSubSource::eSubtype_subclone              },
  479.     { "tissue_lib ",          CSubSource::eSubtype_tissue_lib            },
  480.     { "tissue_type",          CSubSource::eSubtype_tissue_type           },
  481.     { "transgenic",           CSubSource::eSubtype_transgenic            },
  482.     { "transposon",           CSubSource::eSubtype_transposon_name       }
  483. };
  485. typedef struct orgmodinit {
  486.     const char *      key;
  487.     COrgMod::ESubtype subtype;
  488. } OrgModInit;
  490. static OrgModInit orgmod_key_to_subtype [] = {
  491.     { "acronym",          COrgMod::eSubtype_acronym          },
  492.     { "anamorph",         COrgMod::eSubtype_anamorph         },
  493.     { "authority",        COrgMod::eSubtype_authority        },
  494.     { "biotype",          COrgMod::eSubtype_biotype          },
  495.     { "biovar",           COrgMod::eSubtype_biovar           },
  496.     { "breed",            COrgMod::eSubtype_breed            },
  497.     { "chemovar",         COrgMod::eSubtype_chemovar         },
  498.     { "common",           COrgMod::eSubtype_common           },
  499.     { "cultivar",         COrgMod::eSubtype_cultivar         },
  500.     { "dosage",           COrgMod::eSubtype_dosage           },
  501.     { "ecotype",          COrgMod::eSubtype_ecotype          },
  502.     { "forma_specialis",  COrgMod::eSubtype_forma_specialis  },
  503.     { "forma",            COrgMod::eSubtype_forma            },
  504.     { "gb_acronym",       COrgMod::eSubtype_gb_acronym       },
  505.     { "gb_anamorph",      COrgMod::eSubtype_gb_anamorph      },
  506.     { "gb_synonym",       COrgMod::eSubtype_gb_synonym       },
  507.     { "group",            COrgMod::eSubtype_group            },
  508.     { "isolate",          COrgMod::eSubtype_isolate          },
  509.     { "nat_host",         COrgMod::eSubtype_nat_host         },
  510.     { "pathovar",         COrgMod::eSubtype_pathovar         },
  511.     { "serogroup",        COrgMod::eSubtype_serogroup        },
  512.     { "serotype",         COrgMod::eSubtype_serotype         },
  513.     { "serovar",          COrgMod::eSubtype_serovar          },
  514.     { "specimen_voucher", COrgMod::eSubtype_specimen_voucher },
  515.     { "strain",           COrgMod::eSubtype_strain           },
  516.     { "sub_species",      COrgMod::eSubtype_sub_species      },
  517.     { "subgroup",         COrgMod::eSubtype_subgroup         },
  518.     { "substrain",        COrgMod::eSubtype_substrain        },
  519.     { "subtype",          COrgMod::eSubtype_subtype          },
  520.     { "synonym",          COrgMod::eSubtype_synonym          },
  521.     { "teleomorph",       COrgMod::eSubtype_teleomorph       },
  522.     { "type",             COrgMod::eSubtype_type             },
  523.     { "variety",          COrgMod::eSubtype_variety          }
  524. };
  526. typedef struct bondinit {
  527.     const char *        key;
  528.     CSeqFeatData::EBond subtype;
  529. } BondInit;
  531. static BondInit bond_key_to_subtype [] = {
  532.     { "disulfide",         CSeqFeatData::eBond_disulfide  },
  533.     { "thiolester",        CSeqFeatData::eBond_thiolester },
  534.     { "xlink",             CSeqFeatData::eBond_xlink      },
  535.     { "thioether",         CSeqFeatData::eBond_thioether  },
  536.     { "",                  CSeqFeatData::eBond_other      }
  537. };
  539. typedef struct siteinit {
  540.     const char *        key;
  541.     CSeqFeatData::ESite subtype;
  542. } SiteInit;
  544. static SiteInit site_key_to_subtype [] = {
  545.     { "active",                      CSeqFeatData::eSite_active                      },
  546.     { "binding",                     CSeqFeatData::eSite_binding                     },
  547.     { "cleavage",                    CSeqFeatData::eSite_cleavage                    },
  548.     { "inhibit",                     CSeqFeatData::eSite_inhibit                     },
  549.     { "modified",                    CSeqFeatData::eSite_modified                    },
  550.     { "glycosylation",               CSeqFeatData::eSite_glycosylation               },
  551.     { "myristoylation",              CSeqFeatData::eSite_myristoylation              },
  552.     { "mutagenized",                 CSeqFeatData::eSite_mutagenized                 },
  553.     { "metal binding",               CSeqFeatData::eSite_metal_binding               },
  554.     { "phosphorylation",             CSeqFeatData::eSite_phosphorylation             },
  555.     { "acetylation",                 CSeqFeatData::eSite_acetylation                 },
  556.     { "amidation",                   CSeqFeatData::eSite_amidation                   },
  557.     { "methylation",                 CSeqFeatData::eSite_methylation                 },
  558.     { "hydroxylation",               CSeqFeatData::eSite_hydroxylation               },
  559.     { "sulfatation",                 CSeqFeatData::eSite_sulfatation                 },
  560.     { "oxidative deamination",       CSeqFeatData::eSite_oxidative_deamination       },
  561.     { "pyrrolidone carboxylic acid", CSeqFeatData::eSite_pyrrolidone_carboxylic_acid },
  562.     { "gamma carboxyglutamic acid",  CSeqFeatData::eSite_gamma_carboxyglutamic_acid  },
  563.     { "blocked",                     CSeqFeatData::eSite_blocked                     },
  564.     { "lipid binding",               CSeqFeatData::eSite_lipid_binding               },
  565.     { "np binding",                  CSeqFeatData::eSite_np_binding                  },
  566.     { "DNA binding",                 CSeqFeatData::eSite_dna_binding                 },
  567.     { "signal peptide",              CSeqFeatData::eSite_signal_peptide              },
  568.     { "transit peptide",             CSeqFeatData::eSite_transit_peptide             },
  569.     { "transmembrane region",        CSeqFeatData::eSite_transmembrane_region        },
  570.     { "",                            CSeqFeatData::eSite_other                       }
  571. };
  573. typedef struct trnainit {
  574.     const char * key;
  575.     int          subtype;
  576. } TrnaInit;
  578. static TrnaInit trna_key_to_subtype [] = {
  579.     { "Ala",   'A' },
  580.     { "Asx",   'B' },
  581.     { "Cys",   'C' },
  582.     { "Asp",   'D' },
  583.     { "Glu",   'E' },
  584.     { "Phe",   'F' },
  585.     { "Gly",   'G' },
  586.     { "His",   'H' },
  587.     { "Ile",   'I' },
  588.     { "Lys",   'K' },
  589.     { "Leu",   'L' },
  590.     { "Met",   'M' },
  591.     { "fMet",  'M' },
  592.     { "Asn",   'N' },
  593.     { "Pro",   'P' },
  594.     { "Gln",   'Q' },
  595.     { "Arg",   'R' },
  596.     { "Ser",   'S' },
  597.     { "Thr",   'T' },
  598.     { "Val",   'V' },
  599.     { "Trp",   'W' },
  600.     { "Xxx",   'X' },
  601.     { "OTHER", 'X' },
  602.     { "Tyr",   'Y' },
  603.     { "Glx",   'Z' },
  604.     { "Sec",   'U' },
  605.     { "Ter",   '*' },
  606.     { "TERM",  '*' }
  607. };
  609. typedef struct singleinit {
  610.     const char * key;
  611. } SingleInit;
  613. static SingleInit single_key_list [] = {
  614.     { "pseudo"               },
  615.     { "germline"             },
  616.     { "rearranged"           },
  617.     { "transgenic"           },
  618.     { "environmental_sample" }
  619. };
  621. // constructor
  622. CFeature_table_reader_imp::CFeature_table_reader_imp(void)
  623. {
  624.     // initialize common CFeature_table_reader_imp tables
  625.     for (int i = 0; i < sizeof (feat_key_to_subtype) / sizeof (FeatInit); i++) {
  626.         string str = string (feat_key_to_subtype [i].key);
  627.         m_FeatKeys [string (feat_key_to_subtype [i].key)] = feat_key_to_subtype [i].subtype;
  628.     }
  630.     for (int i = 0; i < sizeof (qual_key_to_subtype) / sizeof (QualInit); i++) {
  631.         string str = string (qual_key_to_subtype [i].key);
  632.         m_QualKeys [string (qual_key_to_subtype [i].key)] = qual_key_to_subtype [i].subtype;
  633.     }
  635.     for (int i = 0; i < sizeof (orgref_key_to_subtype) / sizeof (OrgRefInit); i++) {
  636.         string str = string (orgref_key_to_subtype [i].key);
  637.         m_OrgRefKeys [string (orgref_key_to_subtype [i].key)] = orgref_key_to_subtype [i].subtype;
  638.     }
  640.     for (int i = 0; i < sizeof (genome_key_to_subtype) / sizeof (GenomeInit); i++) {
  641.         string str = string (genome_key_to_subtype [i].key);
  642.         m_GenomeKeys [string (genome_key_to_subtype [i].key)] = genome_key_to_subtype [i].subtype;
  643.     }
  645.     for (int i = 0; i < sizeof (subsrc_key_to_subtype) / sizeof (SubSrcInit); i++) {
  646.         string str = string (subsrc_key_to_subtype [i].key);
  647.         m_SubSrcKeys [string (subsrc_key_to_subtype [i].key)] = subsrc_key_to_subtype [i].subtype;
  648.     }
  650.     for (int i = 0; i < sizeof (orgmod_key_to_subtype) / sizeof (OrgModInit); i++) {
  651.         string str = string (orgmod_key_to_subtype [i].key);
  652.         m_OrgModKeys [string (orgmod_key_to_subtype [i].key)] = orgmod_key_to_subtype [i].subtype;
  653.     }
  655.     for (int i = 0; i < sizeof (bond_key_to_subtype) / sizeof (BondInit); i++) {
  656.         string str = string (bond_key_to_subtype [i].key);
  657.         m_BondKeys [string (bond_key_to_subtype [i].key)] = bond_key_to_subtype [i].subtype;
  658.     }
  660.     for (int i = 0; i < sizeof (site_key_to_subtype) / sizeof (SiteInit); i++) {
  661.         string str = string (site_key_to_subtype [i].key);
  662.         m_SiteKeys [string (site_key_to_subtype [i].key)] = site_key_to_subtype [i].subtype;
  663.     }
  665.     for (int i = 0; i < sizeof (trna_key_to_subtype) / sizeof (TrnaInit); i++) {
  666.         string str = string (trna_key_to_subtype [i].key);
  667.         m_TrnaKeys [string (trna_key_to_subtype [i].key)] = trna_key_to_subtype [i].subtype;
  668.     }
  670.     for (int i = 0; i < sizeof (single_key_list) / sizeof (SingleInit); i++) {
  671.         string str = string (single_key_list [i].key);
  672.         m_SingleKeys.push_back (str);
  673.     }
  674. }
  676. // destructor
  677. CFeature_table_reader_imp::~CFeature_table_reader_imp(void)
  678. {
  679. }
  682. bool CFeature_table_reader_imp::x_ParseFeatureTableLine (const string& line, Int4* startP, Int4* stopP,
  683.                                                          bool* partial5P, bool* partial3P, bool* ispointP,
  684.                                                          string& featP, string& qualP, string& valP, Int4 offset)
  686. {
  687.     SIZE_TYPE      numtkns;
  688.     bool           badNumber = false;
  689.     bool           ispoint = false;
  690.     size_t         len;
  691.     bool           partial5 = false;
  692.     bool           partial3 = false;
  693.     Int4           startv = -1;
  694.     Int4           stopv = -1;
  695.     Int4           swp;
  696.     string         start, stop, feat, qual, val, stnd;
  697.     vector<string> tkns;
  699.     if (line.empty ()) return false;
  701.     tkns.clear ();
  702.     NStr::Tokenize (line, "t", tkns);
  703.     numtkns = tkns.size ();
  705.     if (numtkns > 0) {
  706.         start = tkns [0];
  707.     }
  708.     if (numtkns > 1) {
  709.         stop = tkns [1];
  710.     }
  711.     if (numtkns > 2) {
  712.         feat = tkns [2];
  713.     }
  714.     if (numtkns > 3) {
  715.         qual = tkns [3];
  716.     }
  717.     if (numtkns > 4) {
  718.         val = tkns [4];
  719.     }
  720.     if (numtkns > 5) {
  721.         stnd = tkns [5];
  722.     }
  724.     if (! start.empty ()) {
  725.         if (start [0] == '<') {
  726.             partial5 = true;
  727.             start.erase (0, 1);
  728.         }
  729.         len = start.length ();
  730.         if (len > 1 && start [len - 1] == '^') {
  731.           ispoint = true;
  732.           start [len - 1] = '';
  733.         }
  734.         try {
  735.             startv = NStr::StringToLong (start);
  736.         } catch (...) {
  737.             badNumber = true;
  738.         }
  739.     }
  741.     if (! stop.empty ()) {
  742.         if (stop [0] == '>') {
  743.             partial3 = true;
  744.             stop.erase (0, 1);
  745.         }
  746.         try {
  747.             stopv = NStr::StringToLong (stop);
  748.         } catch (CStringException) {
  749.             badNumber = true;
  750.         }
  751.     }
  753.     if (badNumber) {
  754.         startv = -1;
  755.         stopv = -1;
  756.     } else {
  757.         startv--;
  758.         stopv--;
  759.         if (! stnd.empty ()) {
  760.             if (stnd == "minus" || stnd == "-" || stnd == "complement") {
  761.                 if (start < stop) {
  762.                     swp = startv;
  763.                     startv = stopv;
  764.                     stopv = swp;
  765.                 }
  766.             }
  767.         }
  768.     }
  770.     *startP = startv + offset;
  771.     *stopP = stopv + offset;
  772.     *partial5P = partial5;
  773.     *partial3P = partial3;
  774.     *ispointP = ispoint;
  775.     featP = feat;
  776.     qualP = qual;
  777.     valP = val;
  779.     return true;
  780. }
  783. bool CFeature_table_reader_imp::x_AddQualifierToGene (CSeqFeatData& sfdata,
  784.                                                       EQual qtype, const string& val)
  786. {
  787.     CGene_ref& grp = sfdata.SetGene ();
  788.     switch (qtype) {
  789.         case eQual_gene:
  790.             grp.SetLocus (val);
  791.             return true;
  792.         case eQual_allele:
  793.             grp.SetAllele (val);
  794.             return true;
  795.         case eQual_gene_desc:
  796.             grp.SetDesc (val);
  797.             return true;
  798.         case eQual_gene_syn:
  799.             {
  800.                 CGene_ref::TSyn& syn = grp.SetSyn ();
  801.                 syn.push_back (val);
  802.                 return true;
  803.             }
  804.         case eQual_map:
  805.             grp.SetMaploc (val);
  806.             return true;
  807.         case eQual_locus_tag:
  808.             grp.SetLocus_tag (val);
  809.             return true;
  810.         default:
  811.             break;
  812.     }
  813.     return false;
  814. }
  817. bool CFeature_table_reader_imp::x_AddQualifierToCdregion (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
  818.                                                           EQual qtype, const string& val)
  820. {
  821.     CCdregion& crp = sfdata.SetCdregion ();
  822.     switch (qtype) {
  823.         case eQual_codon_start:
  824.             {
  825.                 int frame = NStr::StringToInt (val);
  826.                 switch (frame) {
  827.                     case 0:
  828.                         crp.SetFrame (CCdregion::eFrame_not_set);
  829.                         break;
  830.                     case 1:
  831.                         crp.SetFrame (CCdregion::eFrame_one);
  832.                         break;
  833.                     case 2:
  834.                         crp.SetFrame (CCdregion::eFrame_two);
  835.                         break;
  836.                     case 3:
  837.                         crp.SetFrame (CCdregion::eFrame_three);
  838.                         break;
  839.                     default:
  840.                         break;
  841.                 }
  842.                 return true;
  843.             }
  844.         case eQual_EC_number:
  845.             {
  846.                 CProt_ref& prp = sfp->SetProtXref ();
  847.                 CProt_ref::TEc& ec = prp.SetEc ();
  848.                 ec.push_back (val);
  849.                 return true;
  850.             }
  851.         case eQual_function:
  852.             {
  853.                 CProt_ref& prp = sfp->SetProtXref ();
  854.                 CProt_ref::TActivity& fun = prp.SetActivity ();
  855.                 fun.push_back (val);
  856.                 return true;
  857.             }
  858.         case eQual_product:
  859.             {
  860.                 CProt_ref& prp = sfp->SetProtXref ();
  861.                 CProt_ref::TName& prod = prp.SetName ();
  862.                 prod.push_back (val);
  863.                 return true;
  864.             }
  865.         case eQual_prot_desc:
  866.             {
  867.                 CProt_ref& prp = sfp->SetProtXref ();
  868.                 prp.SetDesc (val);
  869.                 return true;
  870.             }
  871.         case eQual_prot_note:
  872.             return true;
  873.         case eQual_transl_except:
  874.             return true;
  875.         default:
  876.             break;
  877.     }
  878.     return false;
  879. }
  882. int CFeature_table_reader_imp::x_ParseTrnaString (const string& val)
  884. {
  885.     string fst, scd;
  887.     scd = val;
  888.     if (NStr::StartsWith (val, "tRNA-")) {
  889.         NStr::SplitInTwo (val, "-", fst, scd);
  890.     }
  892.     if (m_TrnaKeys.find (scd) != m_TrnaKeys.end ()) {
  893.         return m_TrnaKeys [scd];
  894.     }
  896.     return 0;
  897. }
  900. bool CFeature_table_reader_imp::x_AddQualifierToRna (CSeqFeatData& sfdata,
  901.                                                      EQual qtype, const string& val)
  903. {
  904.     CRNA_ref& rrp = sfdata.SetRna ();
  905.     CRNA_ref::EType rnatyp = rrp.GetType ();
  906.     switch (rnatyp) {
  907.         case CRNA_ref::eType_premsg:
  908.         case CRNA_ref::eType_mRNA:
  909.         case CRNA_ref::eType_rRNA:
  910.         case CRNA_ref::eType_snRNA:
  911.         case CRNA_ref::eType_scRNA:
  912.         case CRNA_ref::eType_snoRNA:
  913.         case CRNA_ref::eType_other:
  914.             switch (qtype) {
  915.                 case eQual_product:
  916.                     {
  917.                         CRNA_ref::TExt& tex = rrp.SetExt ();
  918.                         CRNA_ref::C_Ext::E_Choice exttype = tex.Which ();
  919.                         if (exttype == CRNA_ref::C_Ext::e_TRNA) return false;
  920.                         tex.SetName (val);
  921.                         return true;
  922.                     }
  923.                 default:
  924.                     break;
  925.             }
  926.             break;
  927.         case CRNA_ref::eType_tRNA:
  928.             switch (qtype) {
  929.                 case eQual_product: {
  930.                         CRNA_ref::TExt& tex = rrp.SetExt ();
  931.                         CRNA_ref::C_Ext::E_Choice exttype = tex.Which ();
  932.                         if (exttype == CRNA_ref::C_Ext::e_Name) return false;
  933.                         CTrna_ext& trx = tex.SetTRNA ();
  934.                         int aaval = x_ParseTrnaString (val);
  935.                         if (aaval > 0) {
  936.                             CTrna_ext::TAa& taa = trx.SetAa ();
  937.                             taa.SetNcbieaa (aaval);
  938.                             trx.SetAa (taa);
  939.                             tex.SetTRNA (trx);
  940.                             return true;
  941.                         }
  942.                     }
  943.                     break;
  944.                 default:
  945.                     break;
  946.             }
  947.             break;
  948.         default:
  949.             break;
  950.     }
  951.     return false;
  952. }
  955. bool CFeature_table_reader_imp::x_AddQualifierToImp (CRef<CSeq_feat> sfp, CSeqFeatData& sfdata,
  956.                                                      EQual qtype, const string& qual, const string& val)
  958. {
  959.     switch (qtype) {
  960.         case eQual_allele:
  961.         case eQual_bound_moiety:
  962.         case eQual_clone:
  963.         case eQual_cons_splice:
  964.         case eQual_direction:
  965.         case eQual_EC_number:
  966.         case eQual_frequency:
  967.         case eQual_function:
  968.         case eQual_insertion_seq:
  969.         case eQual_label:
  970.         case eQual_map:
  971.         case eQual_number:
  972.         case eQual_operon:
  973.         case eQual_organism:
  974.         case eQual_PCR_conditions:
  975.         case eQual_phenotype:
  976.         case eQual_product:
  977.         case eQual_replace:
  978.         case eQual_rpt_family:
  979.         case eQual_rpt_type:
  980.         case eQual_rpt_unit:
  981.         case eQual_standard_name:
  982.         case eQual_transposon:
  983.         case eQual_usedin:
  984.             {
  985.                 CSeq_feat::TQual& qlist = sfp->SetQual ();
  986.                 CRef<CGb_qual> gbq (new CGb_qual);
  987.                 gbq->SetQual (qual);
  988.                 gbq->SetVal (val);
  989.                 qlist.push_back (gbq);
  990.                 return true;
  991.             }
  992.         default:
  993.             break;
  994.     }
  995.     return false;
  996. }
  999. bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
  1000.                                                         EOrgRef rtype, const string& val)
  1002. {
  1003.     CBioSource& bsp = sfdata.SetBiosrc ();
  1005.     switch (rtype) {
  1006.         case eOrgRef_organism:
  1007.             {
  1008.                 CBioSource::TOrg& orp = bsp.SetOrg ();
  1009.                 orp.SetTaxname (val);
  1010.                 return true;
  1011.             }
  1012.         case eOrgRef_organelle:
  1013.             {
  1014.                 if (m_GenomeKeys.find (val) != m_GenomeKeys.end ()) {
  1015.                     CBioSource::EGenome gtype = m_GenomeKeys [val];
  1016.                     bsp.SetGenome (gtype);
  1017.                     return true;
  1018.                 }
  1019.             }
  1020.         case eOrgRef_div:
  1021.             {
  1022.                 CBioSource::TOrg& orp = bsp.SetOrg ();
  1023.                 COrg_ref::TOrgname& onp = orp.SetOrgname ();
  1024.                 onp.SetDiv (val);
  1025.                 return true;
  1026.             }
  1027.         case eOrgRef_lineage:
  1028.             {
  1029.                 CBioSource::TOrg& orp = bsp.SetOrg ();
  1030.                 COrg_ref::TOrgname& onp = orp.SetOrgname ();
  1031.                 onp.SetLineage (val);
  1032.                 return true;
  1033.             }
  1034.         case eOrgRef_gcode:
  1035.             {
  1036.                 CBioSource::TOrg& orp = bsp.SetOrg ();
  1037.                 COrg_ref::TOrgname& onp = orp.SetOrgname ();
  1038.                 int code = NStr::StringToInt (val);
  1039.                 onp.SetGcode (code);
  1040.                 return true;
  1041.             }
  1042.         case eOrgRef_mgcode:
  1043.             {
  1044.                 CBioSource::TOrg& orp = bsp.SetOrg ();
  1045.                 COrg_ref::TOrgname& onp = orp.SetOrgname ();
  1046.                 int code = NStr::StringToInt (val);
  1047.                 onp.SetMgcode (code);
  1048.                 return true;
  1049.             }
  1050.         default:
  1051.             break;
  1052.     }
  1053.     return false;
  1054. }
  1057. bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
  1058.                                                         CSubSource::ESubtype stype, const string& val)
  1060. {
  1061.     CBioSource& bsp = sfdata.SetBiosrc ();
  1062.     CBioSource::TSubtype& slist = bsp.SetSubtype ();
  1063.     CRef<CSubSource> ssp (new CSubSource);
  1064.     ssp->SetSubtype (stype);
  1065.     ssp->SetName (val);
  1066.     slist.push_back (ssp);
  1067.     return true;
  1068. }
  1071. bool CFeature_table_reader_imp::x_AddQualifierToBioSrc (CSeqFeatData& sfdata,
  1072.                                                         COrgMod::ESubtype  mtype, const string& val)
  1074. {
  1075.     CBioSource& bsp = sfdata.SetBiosrc ();
  1076.     CBioSource::TOrg& orp = bsp.SetOrg ();
  1077.     COrg_ref::TOrgname& onp = orp.SetOrgname ();
  1078.     COrgName::TMod& mlist = onp.SetMod ();
  1079.     CRef<COrgMod> omp (new COrgMod);
  1080.     omp->SetSubtype (mtype);
  1081.     omp->SetSubname (val);
  1082.     mlist.push_back (omp);
  1083.     return true;
  1084. }
  1087. bool CFeature_table_reader_imp::x_AddQualifierToFeature (CRef<CSeq_feat> sfp,
  1088.                                                          const string& qual, const string& val)
  1090. {
  1091.     CSeqFeatData&          sfdata = sfp->SetData ();
  1092.     CSeqFeatData::E_Choice typ = sfdata.Which ();
  1094.     if (typ == CSeqFeatData::e_Biosrc) {
  1096.         if (m_OrgRefKeys.find (qual) != m_OrgRefKeys.end ()) {
  1098.             EOrgRef rtype = m_OrgRefKeys [qual];
  1099.             if (x_AddQualifierToBioSrc (sfdata, rtype, val)) return true;
  1101.         } else if (m_SubSrcKeys.find (qual) != m_SubSrcKeys.end ()) {
  1103.             CSubSource::ESubtype stype = m_SubSrcKeys [qual];
  1104.             if (x_AddQualifierToBioSrc (sfdata, stype, val)) return true;
  1106.         } else if (m_OrgModKeys.find (qual) != m_OrgModKeys.end ()) {
  1108.             COrgMod::ESubtype  mtype = m_OrgModKeys [qual];
  1109.             if (x_AddQualifierToBioSrc (sfdata, mtype, val)) return true;
  1110.         }
  1112.     } else if (m_QualKeys.find (qual) != m_QualKeys.end ()) {
  1114.         EQual qtype = m_QualKeys [qual];
  1115.         switch (typ) {
  1116.             case CSeqFeatData::e_Gene:
  1117.                 if (x_AddQualifierToGene (sfdata, qtype, val)) return true;
  1118.                 break;
  1119.             case CSeqFeatData::e_Cdregion:
  1120.                 if (x_AddQualifierToCdregion (sfp, sfdata, qtype, val)) return true;
  1121.                 break;
  1122.             case CSeqFeatData::e_Rna:
  1123.                 if (x_AddQualifierToRna (sfdata, qtype, val)) return true;
  1124.                 break;
  1125.            case CSeqFeatData::e_Imp:
  1126.                 if (x_AddQualifierToImp (sfp, sfdata, qtype, qual, val)) return true;
  1127.                 break;
  1128.             case CSeqFeatData::e_Region:
  1129.                 if (qtype == eQual_region_name) {
  1130.                     sfdata.SetRegion (val);
  1131.                     return true;
  1132.                 }
  1133.                 break;
  1134.             case CSeqFeatData::e_Bond:
  1135.                 if (qtype == eQual_bond_type) {
  1136.                     if (m_BondKeys.find (val) != m_BondKeys.end ()) {
  1137.                         CSeqFeatData::EBond btyp = m_BondKeys [val];
  1138.                         sfdata.SetBond (btyp);
  1139.                         return true;
  1140.                     }
  1141.                 }
  1142.                 break;
  1143.             case CSeqFeatData::e_Site:
  1144.                 if (qtype == eQual_site_type) {
  1145.                     if (m_SiteKeys.find (val) != m_SiteKeys.end ()) {
  1146.                         CSeqFeatData::ESite styp = m_SiteKeys [val];
  1147.                         sfdata.SetSite (styp);
  1148.                         return true;
  1149.                     }
  1150.                 }
  1151.                 break;
  1152.             default:
  1153.                 break;
  1154.         }
  1155.         switch (qtype) {
  1156.             case eQual_pseudo:
  1157.                 sfp->SetPseudo (true);
  1158.                 return true;
  1159.             case eQual_partial:
  1160.                 sfp->SetPartial (true);
  1161.                 return true;
  1162.             case eQual_exception:
  1163.                 sfp->SetExcept (true);
  1164.                 sfp->SetExcept_text (val);
  1165.                 return true;
  1166.             case eQual_evidence:
  1167.                 if (val == "experimental") {
  1168.                     sfp->SetExp_ev (CSeq_feat::eExp_ev_experimental);
  1169.                 } else if (val == "not_experimental" || val == "non_experimental" ||
  1170.                            val == "not-experimental" || val == "non-experimental") {
  1171.                     sfp->SetExp_ev (CSeq_feat::eExp_ev_not_experimental);
  1172.                 }
  1173.                 return true;
  1174.             case eQual_note:
  1175.                 {
  1176.                     if (sfp->CanGetComment ()) {
  1177.                         const CSeq_feat::TComment& comment = sfp->GetComment ();
  1178.                         CSeq_feat::TComment revised = comment + "; " + val;
  1179.                         sfp->SetComment (revised);
  1180.                     } else {
  1181.                         sfp->SetComment (val);
  1182.                     }
  1183.                     return true;
  1184.                 }
  1185.             case eQual_allele:
  1186.             case eQual_bound_moiety:
  1187.             case eQual_clone:
  1188.             case eQual_cons_splice:
  1189.             case eQual_direction:
  1190.             case eQual_EC_number:
  1191.             case eQual_frequency:
  1192.             case eQual_function:
  1193.             case eQual_insertion_seq:
  1194.             case eQual_label:
  1195.             case eQual_map:
  1196.             case eQual_number:
  1197.             case eQual_operon:
  1198.             case eQual_organism:
  1199.             case eQual_PCR_conditions:
  1200.             case eQual_phenotype:
  1201.             case eQual_product:
  1202.             case eQual_protein_id:
  1203.             case eQual_replace:
  1204.             case eQual_rpt_family:
  1205.             case eQual_rpt_type:
  1206.             case eQual_rpt_unit:
  1207.             case eQual_standard_name:
  1208.             case eQual_transcript_id:
  1209.             case eQual_transposon:
  1210.             case eQual_usedin:
  1211.                 {
  1212.                     CSeq_feat::TQual& qlist = sfp->SetQual ();
  1213.                     CRef<CGb_qual> gbq (new CGb_qual);
  1214.                     gbq->SetQual (qual);
  1215.                     gbq->SetVal (val);
  1216.                     qlist.push_back (gbq);
  1217.                     return true;
  1218.                 }
  1219.             case eQual_gene:
  1220.                 {
  1221.                     CGene_ref& grp = sfp->SetGeneXref ();
  1222.                     if (val == "-") {
  1223.                         grp.SetLocus ("");
  1224.                     } else {
  1225.                         grp.SetLocus (val);
  1226.                     }
  1227.                     return true;
  1228.                 }
  1229.             case eQual_gene_desc:
  1230.                 {
  1231.                     CGene_ref& grp = sfp->SetGeneXref ();
  1232.                     grp.SetDesc (val);
  1233.                     return true;
  1234.                 }
  1235.             case eQual_gene_syn:
  1236.                 {
  1237.                     CGene_ref& grp = sfp->SetGeneXref ();
  1238.                     CGene_ref::TSyn& syn = grp.SetSyn ();
  1239.                     syn.push_back (val);
  1240.                     return true;
  1241.                 }
  1242.             case eQual_locus_tag:
  1243.                 {
  1244.                     CGene_ref& grp = sfp->SetGeneXref ();
  1245.                     grp.SetLocus_tag (val);
  1246.                     return true;
  1247.                 }
  1248.             case eQual_db_xref:
  1249.                 {
  1250.                     string db, tag;
  1251.                     if (NStr::SplitInTwo (val, ":", db, tag)) {
  1252.                         CSeq_feat::TDbxref& dblist = sfp->SetDbxref ();
  1253.                         CRef<CDbtag> dbt (new CDbtag);
  1254.                         dbt->SetDb (db);
  1255.                         CRef<CObject_id> oid (new CObject_id);
  1256.                         oid->SetStr (tag);
  1257.                         dbt->SetTag (*oid);
  1258.                         dblist.push_back (dbt);
  1259.                         return true;
  1260.                     }
  1261.                     return true;
  1262.                 }
  1263.             default:
  1264.                 break;
  1265.         }
  1266.     }
  1267.     return false;
  1268. }
  1271. bool CFeature_table_reader_imp::x_AddIntervalToFeature (CRef<CSeq_feat> sfp, CSeq_loc_mix *mix,
  1272.                                                         const string& seqid, Int4 start, Int4 stop,
  1273.                                                         bool partial5, bool partial3)
  1275. {
  1276.     CSeq_interval::TStrand strand = eNa_strand_plus;
  1278.     if (start > stop) {
  1279.         Int4 flip = start;
  1280.         start = stop;
  1281.         stop = flip;
  1282.         strand = eNa_strand_minus;
  1283.     }
  1285.     if (start == stop) {
  1286.         // just a point
  1287.         CRef<CSeq_loc> loc(new CSeq_loc);
  1288.         CSeq_point& point = loc->SetPnt();
  1289.         point.SetPoint(start);
  1290.         point.SetStrand(strand);
  1291.         CSeq_id seq_id(seqid);
  1292.         point.SetId().Assign (seq_id);
  1293.         mix->Set().push_back(loc);
  1294.     } else {
  1295.         // interval
  1296.         CRef<CSeq_loc> loc(new CSeq_loc);
  1297.         CSeq_interval& ival = loc->SetInt();
  1298.         ival.SetFrom(start);
  1299.         ival.SetTo(stop);
  1300.         ival.SetStrand(strand);
  1301.         CSeq_id seq_id(seqid);
  1302.         ival.SetId().Assign (seq_id);
  1303.         mix->Set().push_back(loc);
  1304.     }
  1306.     if (partial5 || partial3) {
  1307.         sfp->SetPartial (true);
  1308.     }
  1310.     return true;
  1311. }
  1314. CRef<CSeq_annot> CFeature_table_reader_imp::ReadSequinFeatureTable (
  1315.     CNcbiIstream& ifs,
  1316.     const string& seqid,
  1317.     const string& annotname,
  1318.     const CFeature_table_reader::TFlags flags
  1319. )
  1321. {
  1322.     string line;
  1323.     string feat, qual, val;
  1324.     Int4 start, stop;
  1325.     bool partial5, partial3, ispoint;
  1326.     Int4 offset = 0;
  1327.     CSeqFeatData::ESubtype sbtyp = CSeqFeatData::eSubtype_bad;
  1328.     CSeqFeatData::E_Choice typ = CSeqFeatData::e_not_set;
  1329.     CRef<CSeq_annot> sap(new CSeq_annot);
  1330.     CSeq_annot::C_Data::TFtable& ftable = sap->SetData().SetFtable();
  1331.     CRef<CSeq_feat> sfp;
  1332.     CSeq_loc_mix *mix = 0;
  1333.     CT_POS_TYPE pos(0);
  1335.     if (! annotname.empty ()) {
  1336.       CAnnot_descr& descr = sap->SetDesc ();
  1337.       CRef<CAnnotdesc> annot(new CAnnotdesc);
  1338.       annot->SetName (annotname);
  1339.       descr.Set().push_back (annot);
  1340.     }
  1342.     while (ifs.good ()) {
  1344.         pos = ifs.tellg ();
  1345.         NcbiGetlineEOL (ifs, line);
  1347.         if (! line.empty ()) {
  1348.             if (line [0] == '>') {
  1350.                 // if next feature table, reposition and return current sap
  1352.                 ifs.seekg (pos);
  1353.                 return sap;
  1355.             } else if (line [0] == '[') {
  1357.                 // set offset !!!!!!!!
  1359.             } else if (x_ParseFeatureTableLine (line, &start, &stop, &partial5, &partial3,
  1360.                                                 &ispoint, feat, qual, val, offset)) {
  1362.                 // process line in feature table
  1364.                 if ((! feat.empty ()) && start >= 0 && stop >= 0) {
  1366.                     // process start - stop - feature line
  1368.                     if (m_FeatKeys.find (feat) != m_FeatKeys.end ()) {
  1369.                         sbtyp = m_FeatKeys [feat];
  1370.                         if (sbtyp != CSeqFeatData::eSubtype_bad) {
  1372.                             // populate *sfp here...
  1374.                             sfp.Reset (new CSeq_feat);
  1375.                             sfp->ResetLocation ();
  1377.                             typ = CSeqFeatData::GetTypeFromSubtype (sbtyp);
  1378.                             sfp->SetData ().Select (typ);
  1379.                             CSeqFeatData& sfdata = sfp->SetData ();
  1380.                             if (typ == CSeqFeatData::e_Rna) {
  1381.                                 CRNA_ref& rrp = sfdata.SetRna ();
  1382.                                 CRNA_ref::EType rnatyp = CRNA_ref::eType_unknown;
  1383.                                 switch (sbtyp) {
  1384.                                     case CSeqFeatData::eSubtype_preRNA :
  1385.                                         rnatyp = CRNA_ref::eType_premsg;
  1386.                                         break;
  1387.                                     case CSeqFeatData::eSubtype_mRNA :
  1388.                                         rnatyp = CRNA_ref::eType_mRNA;
  1389.                                         break;
  1390.                                     case CSeqFeatData::eSubtype_tRNA :
  1391.                                         rnatyp = CRNA_ref::eType_tRNA;
  1392.                                         break;
  1393.                                     case CSeqFeatData::eSubtype_rRNA :
  1394.                                         rnatyp = CRNA_ref::eType_rRNA;
  1395.                                         break;
  1396.                                     case CSeqFeatData::eSubtype_snRNA :
  1397.                                         rnatyp = CRNA_ref::eType_snRNA;
  1398.                                         break;
  1399.                                     case CSeqFeatData::eSubtype_scRNA :
  1400.                                         rnatyp = CRNA_ref::eType_scRNA;
  1401.                                         break;
  1402.                                     case CSeqFeatData::eSubtype_snoRNA :
  1403.                                         rnatyp = CRNA_ref::eType_snoRNA;
  1404.                                         break;
  1405.                                     case CSeqFeatData::eSubtype_otherRNA :
  1406.                                         rnatyp = CRNA_ref::eType_other;
  1407.                                         break;
  1408.                                     default :
  1409.                                         break;
  1410.                                 }
  1411.                                 rrp.SetType (rnatyp);
  1413.                             } else if (typ == CSeqFeatData::e_Imp) {
  1414.                                 CImp_feat_Base& imp = sfdata.SetImp ();
  1415.                                 imp.SetKey (feat);
  1416.                             }
  1418.                             ftable.push_back (sfp);
  1420.                             // now create location
  1422.                             CRef<CSeq_loc> location (new CSeq_loc);
  1423.                             mix = &(location->SetMix ());
  1424.                             sfp->SetLocation (*location);
  1426.                             // and add first interval
  1428.                             x_AddIntervalToFeature (sfp, mix, seqid, start, stop, partial5, partial3);
  1430.                         }
  1431.                     } else {
  1433.                         // unrecognized feature key
  1435.                         if ((flags & CFeature_table_reader::fReportBadKey) != 0) {
  1436.                             ERR_POST (Warning << "Unrecognized feature " << feat);
  1437.                         }
  1439.                         if ((flags & CFeature_table_reader::fKeepBadKey) != 0) {
  1440.                             sfp.Reset (new CSeq_feat);
  1441.                             sfp->ResetLocation ();
  1442.                             sfp->SetData ().Select (CSeqFeatData::e_Imp);
  1443.                             CSeqFeatData& sfdata = sfp->SetData ();
  1444.                             CImp_feat_Base& imp = sfdata.SetImp ();
  1445.                             imp.SetKey (feat);
  1446.                             ftable.push_back (sfp);
  1447.                             CRef<CSeq_loc> location (new CSeq_loc);
  1448.                             mix = &(location->SetMix ());
  1449.                             sfp->SetLocation (*location);
  1450.                             x_AddIntervalToFeature (sfp, mix, seqid, start, stop, partial5, partial3);
  1451.                         }
  1452.                     }
  1454.                 } else if (start >= 0 && stop >= 0 && feat.empty () && qual.empty () && val.empty ()) {
  1456.                     // process start - stop multiple interval line
  1458.                     x_AddIntervalToFeature (sfp, mix, seqid, start, stop, partial5, partial3);
  1460.                 } else if ((! qual.empty ()) && (! val.empty ())) {
  1462.                     // process qual - val qualifier line
  1464.                     if (! x_AddQualifierToFeature (sfp, qual, val)) {
  1466.                         // unrecognized qualifier key
  1468.                         if ((flags & CFeature_table_reader::fReportBadKey) != 0) {
  1469.                             ERR_POST (Warning << "Unrecognized qualifier " << qual);
  1470.                         }
  1472.                         if ((flags & CFeature_table_reader::fKeepBadKey) != 0) {
  1473.                             CSeq_feat::TQual& qlist = sfp->SetQual ();
  1474.                             CRef<CGb_qual> gbq (new CGb_qual);
  1475.                             gbq->SetQual (qual);
  1476.                             gbq->SetVal (val);
  1477.                             qlist.push_back (gbq);
  1478.                         }
  1479.                     }
  1481.                 } else if ((! qual.empty ()) && (val.empty ())) {
  1483.                     // check for the few qualifiers that do not need a value
  1485.                     if (find (m_SingleKeys.begin (), m_SingleKeys.end (), qual) != m_SingleKeys.end ()) {
  1487.                         x_AddQualifierToFeature (sfp, qual, val);
  1489.                     }
  1490.                 } else if (! feat.empty ()) {
  1491.                 
  1492.                     // unrecognized location
  1494.                     if ((flags & CFeature_table_reader::fReportBadKey) != 0) {
  1495.                         ERR_POST (Warning << "Bad location on feature " << feat <<
  1496.                                  " (start " << start << ", stop " << stop << ")");
  1497.                     }
  1498.                 }
  1499.             }
  1500.         }
  1501.     }
  1503.     return sap;
  1504. }
  1507. CRef<CSeq_feat> CFeature_table_reader_imp::CreateSeqFeat (
  1508.     const string& feat,
  1509.     CSeq_loc& location,
  1510.     const CFeature_table_reader::TFlags flags
  1511. )
  1513. {
  1514.     CRef<CSeq_feat> sfp (new CSeq_feat);
  1516.     if (! feat.empty ()) {
  1517.         if (m_FeatKeys.find (feat) != m_FeatKeys.end ()) {
  1518.             CSeqFeatData::ESubtype sbtyp = m_FeatKeys [feat];
  1519.             CSeqFeatData::E_Choice typ = CSeqFeatData::GetTypeFromSubtype (sbtyp);
  1520.             sfp->SetData ().Select (typ);
  1521.             CSeqFeatData& sfdata = sfp->SetData ();
  1522.             sfp->SetLocation (location);
  1523.             if (typ == CSeqFeatData::e_Rna) {
  1524.                 CRNA_ref& rrp = sfdata.SetRna ();
  1525.                 CRNA_ref::EType rnatyp = CRNA_ref::eType_unknown;
  1526.                 switch (sbtyp) {
  1527.                     case CSeqFeatData::eSubtype_preRNA :
  1528.                         rnatyp = CRNA_ref::eType_premsg;
  1529.                         break;
  1530.                     case CSeqFeatData::eSubtype_mRNA :
  1531.                         rnatyp = CRNA_ref::eType_mRNA;
  1532.                         break;
  1533.                     case CSeqFeatData::eSubtype_tRNA :
  1534.                         rnatyp = CRNA_ref::eType_tRNA;
  1535.                         break;
  1536.                     case CSeqFeatData::eSubtype_rRNA :
  1537.                         rnatyp = CRNA_ref::eType_rRNA;
  1538.                         break;
  1539.                     case CSeqFeatData::eSubtype_snRNA :
  1540.                         rnatyp = CRNA_ref::eType_snRNA;
  1541.                         break;
  1542.                     case CSeqFeatData::eSubtype_scRNA :
  1543.                         rnatyp = CRNA_ref::eType_scRNA;
  1544.                         break;
  1545.                     case CSeqFeatData::eSubtype_snoRNA :
  1546.                         rnatyp = CRNA_ref::eType_snoRNA;
  1547.                         break;
  1548.                     case CSeqFeatData::eSubtype_otherRNA :
  1549.                         rnatyp = CRNA_ref::eType_other;
  1550.                         break;
  1551.                     default :
  1552.                         break;
  1553.                 }
  1554.                 rrp.SetType (rnatyp);
  1556.             } else if (typ == CSeqFeatData::e_Imp) {
  1557.                 CImp_feat_Base& imp = sfdata.SetImp ();
  1558.                 imp.SetKey (feat);
  1559.             }
  1560.             sfp->SetLocation (location);
  1561.  
  1562.         } else {
  1564.             // unrecognized feature key
  1566.             if ((flags & CFeature_table_reader::fReportBadKey) != 0) {
  1567.                 ERR_POST (Warning << "Unrecognized feature " << feat);
  1568.             }
  1570.             if ((flags & CFeature_table_reader::fKeepBadKey) != 0) {
  1571.                 sfp.Reset (new CSeq_feat);
  1572.                 sfp->ResetLocation ();
  1573.                 sfp->SetData ().Select (CSeqFeatData::e_Imp);
  1574.                 CSeqFeatData& sfdata = sfp->SetData ();
  1575.                 CImp_feat_Base& imp = sfdata.SetImp ();
  1576.                 imp.SetKey (feat);
  1577.                 sfp->SetLocation (location);
  1578.             }
  1579.         }
  1580.     }
  1582.     return sfp;
  1583. }
  1586. void CFeature_table_reader_imp::AddFeatQual (
  1587.     CRef<CSeq_feat> sfp,
  1588.     const string& qual,
  1589.     const string& val,
  1590.     const CFeature_table_reader::TFlags flags
  1591. )
  1593. {
  1594.     if ((! qual.empty ()) && (! val.empty ())) {
  1596.         if (! x_AddQualifierToFeature (sfp, qual, val)) {
  1598.             // unrecognized qualifier key
  1600.             if ((flags & CFeature_table_reader::fReportBadKey) != 0) {
  1601.                 ERR_POST (Warning << "Unrecognized qualifier " << qual);
  1602.             }
  1604.             if ((flags & CFeature_table_reader::fKeepBadKey) != 0) {
  1605.                 CSeq_feat::TQual& qlist = sfp->SetQual ();
  1606.                 CRef<CGb_qual> gbq (new CGb_qual);
  1607.                 gbq->SetQual (qual);
  1608.                 gbq->SetVal (val);
  1609.                 qlist.push_back (gbq);
  1610.             }
  1611.         }
  1613.     } else if ((! qual.empty ()) && (val.empty ())) {
  1615.         // check for the few qualifiers that do not need a value
  1617.         if (find (m_SingleKeys.begin (), m_SingleKeys.end (), qual) != m_SingleKeys.end ()) {
  1619.             x_AddQualifierToFeature (sfp, qual, val);
  1621.         }
  1622.     }
  1623. }
  1626. // public access functions
  1628. CRef<CSeq_annot> CFeature_table_reader::ReadSequinFeatureTable (
  1629.     CNcbiIstream& ifs,
  1630.     const string& seqid,
  1631.     const string& annotname,
  1632.     const TFlags flags
  1633. )
  1635. {
  1636.     // just read features from 5-column table
  1638.     CRef<CSeq_annot> sap = x_GetImplementation ().ReadSequinFeatureTable (ifs, seqid, annotname, flags);
  1640.     // go through all features and demote single interval seqlocmix to seqlocint
  1642.     for (CTypeIterator<CSeq_feat> fi(*sap); fi; ++fi) {
  1643.         CSeq_feat& feat = *fi;
  1644.         CSeq_loc& location = feat.SetLocation ();
  1645.         if (location.IsMix ()) {
  1646.             CSeq_loc_mix& mx = location.SetMix ();
  1647.             switch (mx.Get ().size ()) {
  1648.                 case 0:
  1649.                     location.SetNull ();
  1650.                     break;
  1651.                 case 1:
  1652.                     feat.SetLocation (*mx.Set ().front ());
  1653.                     break;
  1654.                 default:
  1655.                     break;
  1656.             }
  1657.         }
  1658.     }
  1660.     return sap;
  1661. }
  1663. CRef<CSeq_annot> CFeature_table_reader::ReadSequinFeatureTable (
  1664.     CNcbiIstream& ifs,
  1665.     const TFlags flags
  1666. )
  1668. {
  1669.     string line, fst, scd, seqid, annotname;
  1670.     CT_POS_TYPE pos(0);
  1672.     // first look for >Feature line, extract seqid and optional annotname
  1674.     while (seqid.empty () && ifs.good ()) {
  1676.         pos = ifs.tellg ();
  1677.         NcbiGetlineEOL (ifs, line);
  1679.         if (! line.empty ()) {
  1680.             if (line [0] == '>') {
  1681.                 if (NStr::StartsWith (line, ">Feature")) {
  1682.                     NStr::SplitInTwo (line, " ", fst, scd);
  1683.                     NStr::SplitInTwo (scd, " ", seqid, annotname);
  1684.                 }
  1685.             }
  1686.         }
  1687.     }
  1689.     // then read features from 5-column table
  1691.     return ReadSequinFeatureTable (ifs, seqid, annotname, flags);
  1693. }
  1695. CRef<CSeq_feat> CFeature_table_reader::CreateSeqFeat (
  1696.     const string& feat,
  1697.     CSeq_loc& location,
  1698.     const TFlags flags
  1699. )
  1701. {
  1702.     return x_GetImplementation ().CreateSeqFeat (feat, location, flags);
  1703. }
  1706. void CFeature_table_reader::AddFeatQual (
  1707.     CRef<CSeq_feat> sfp,
  1708.     const string& qual,
  1709.     const string& val,
  1710.     const CFeature_table_reader::TFlags flags
  1711. )
  1713. {
  1714.     x_GetImplementation ().AddFeatQual (sfp, qual, val, flags);
  1715. }
  1718. END_objects_SCOPE
  1719. END_NCBI_SCOPE