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

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

生物技术

开发平台：

C/C++

taxon1.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: taxon1.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:35:15  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.25
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: taxon1.cpp,v 1000.3 2004/06/01 19:35:15 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Vladimir Soussov, Michael Domrachev
  36.  *
  37.  * File Description:
  38.  *     NCBI Taxonomy information retreival library implementation
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistr.hpp>
  44. #include <objects/taxon1/taxon1.hpp>
  45. #include <objects/seqfeat/seqfeat__.hpp>
  46. #include <connect/ncbi_conn_stream.hpp>
  47. #include <serial/serial.hpp>
  48. #include <serial/enumvalues.hpp>
  49. #include <serial/objistr.hpp>
  50. #include <serial/objostr.hpp>
  52. #include <algorithm>
  54. #include "cache.hpp"
  57. BEGIN_NCBI_SCOPE
  58. BEGIN_objects_SCOPE // namespace ncbi::objects::
  61. static const char s_achInvalTaxid[] = "Invalid tax id specified";
  64. CTaxon1::CTaxon1()
  65.     : m_pServer(NULL),
  66.       m_pOut(NULL),
  67.       m_pIn(NULL),
  68.       m_plCache(NULL),
  69.       m_bWithSynonyms(false)
  70. {
  71.     return;
  72. }
  75. CTaxon1::~CTaxon1()
  76. {
  77.     Reset();
  78. }
  81. void
  82. CTaxon1::Reset()
  83. {
  84.     SetLastError(NULL);
  85.     delete m_pIn;
  86.     delete m_pOut;
  87.     delete m_pServer;
  88.     m_pIn = NULL;
  89.     m_pOut = NULL;
  90.     m_pServer = NULL;
  91.     delete m_plCache;
  92.     m_plCache = NULL;
  93. }
  96. bool
  97. CTaxon1::Init(void)
  98. {
  99.     static const STimeout def_timeout = { 120, 0 };
  100.     return CTaxon1::Init(&def_timeout);
  101. }
  103. bool
  104. CTaxon1::Init(unsigned cache_capacity)
  105. {
  106.     static const STimeout def_timeout = { 120, 0 };
  107.     return CTaxon1::Init(&def_timeout, 5, cache_capacity);
  108. }
  110. bool
  111. CTaxon1::Init(const STimeout* timeout, unsigned reconnect_attempts,
  112.       unsigned cache_capacity)
  113. {
  114.     SetLastError(NULL);
  115.     if( m_pServer ) { // Already inited
  116.         SetLastError( "ERROR: Init(): Already initialized" );
  117.         return false;
  118.     }
  119.     try {
  120.         // Open connection to Taxonomy service
  121.         CTaxon1_req req;
  122.         CTaxon1_resp resp;
  124.         if ( timeout ) {
  125.             m_timeout_value = *timeout;
  126.             m_timeout = &m_timeout_value;
  127.         } else {
  128.             m_timeout = 0;
  129.         }
  131.         m_nReconnectAttempts = reconnect_attempts;
  132.         m_pchService = "TaxService";
  133.         const char* tmp;
  134.         if( ( (tmp=getenv("NI_TAXONOMY_SERVICE_NAME")) != NULL ) ||
  135.     ( (tmp=getenv("NI_SERVICE_NAME_TAXONOMY")) != NULL ) ) {
  136.             m_pchService = tmp;
  137.         }
  138.         auto_ptr<CObjectOStream> pOut;
  139.         auto_ptr<CObjectIStream> pIn;
  140.         auto_ptr<CConn_ServiceStream>
  141.             pServer( new CConn_ServiceStream(m_pchService, fSERV_Any,
  142.                                              0, 0, m_timeout) );
  144. #ifdef USE_TEXT_ASN
  145.         m_eDataFormat = eSerial_AsnText;
  146. #else
  147.         m_eDataFormat = eSerial_AsnBinary;
  148. #endif
  149.         pOut.reset( CObjectOStream::Open(m_eDataFormat, *pServer) );
  150.         pIn.reset( CObjectIStream::Open(m_eDataFormat, *pServer) );
  152.         req.SetInit();
  154.         m_pServer = pServer.release();
  155.         m_pIn = pIn.release();
  156.         m_pOut = pOut.release();
  158.         if( SendRequest( req, resp ) ) {
  159.             if( resp.IsInit() ) {
  160.                 // Init is done
  161.                 m_plCache = new COrgRefCache( *this );
  162.                 if( m_plCache->Init( cache_capacity ) ) {
  163.                     return true;
  164.                 }
  165.                 delete m_plCache;
  166.                 m_plCache = NULL;
  167.             } else { // Set error
  168.                 SetLastError( "ERROR: Response type is not Init" );
  169.             }
  170.         }
  171.     } catch( exception& e ) {
  172.         SetLastError( e.what() );
  173.     }
  174.     // Clean streams
  175.     delete m_pIn;
  176.     delete m_pOut;
  177.     delete m_pServer;
  178.     m_pIn = NULL;
  179.     m_pOut = NULL;
  180.     m_pServer = NULL;
  181.     return false;
  182. }
  184. void
  185. CTaxon1::Fini(void)
  186. {
  187.     SetLastError(NULL);
  188.     if( m_pServer ) {
  189.         CTaxon1_req req;
  190.         CTaxon1_resp resp;
  192.         req.SetFini();
  194.         if( SendRequest( req, resp ) ) {
  195.             if( !resp.IsFini() ) {
  196.                 SetLastError( "Response type is not Fini" );
  197.             }
  198.         }
  199.     }
  200.     Reset();
  201. }
  203. CRef< CTaxon2_data >
  204. CTaxon1::GetById(int tax_id)
  205. {
  206.     SetLastError(NULL);
  207.     if( tax_id > 0 ) {
  208.         // Check if this taxon is in cache
  209.         CTaxon2_data* pData = 0;
  210.         if( m_plCache->LookupAndInsert( tax_id, &pData ) && pData ) {
  211.             CTaxon2_data* pNewData = new CTaxon2_data();
  213.             SerialAssign<CTaxon2_data>( *pNewData, *pData );
  215.             return CRef<CTaxon2_data>(pNewData);
  216.         }
  217.     } else {
  218.         SetLastError( s_achInvalTaxid );
  219.     }
  220.     return CRef<CTaxon2_data>(NULL);
  221. }
  223. class PFindMod {
  224. public:
  225.     void SetModToMatch( const CRef< COrgMod >& mod ) {
  226. CanonizeName( mod->GetSubname(), m_sName );
  227. m_nType = mod->GetSubtype();
  228.     }
  230.     bool operator()( const CRef< COrgMod >& mod ) const {
  231. if( m_nType == mod->GetSubtype() ) {
  232.     string sCanoName;
  233.     CanonizeName( mod->GetSubname(), sCanoName );
  234.     return ( sCanoName == m_sName );
  235. }
  236. return false;
  237.     }
  239.     void CanonizeName( const string& in, string& out ) const {
  240. bool bSpace = true;
  241. char prevc = '';
  242. for( size_t i = 0; i < in.size(); ++i ) {
  243.     if( bSpace ) {
  244. if( !isspace(in[i]) ) {
  245.     bSpace = false;
  246.     if( prevc )
  247. out += tolower(prevc);
  248.     prevc = in[i];
  249. }
  250.     } else {
  251. if( prevc )
  252.     out += tolower(prevc);
  253. if( isspace(in[i]) ) {
  254.     prevc = ' ';
  255.     bSpace = true;
  256. } else {
  257.     prevc = in[i];
  258. }
  259.     }
  260. }
  261. if( prevc && prevc != ' ' )
  262.     out += tolower(prevc);
  263.     }
  265. private:
  266.     string  m_sName;
  267.     int     m_nType;
  268. };
  270. class PFindConflict {
  271. public:
  272.     void SetTypeToMatch( int type ) {
  273. m_nType = type;
  274. switch( type ) {
  275. case COrgMod::eSubtype_strain:
  276. case COrgMod::eSubtype_variety:
  277. //case COrgMod::eSubtype_sub_species:
  278.     m_bSubSpecType = true;
  279.     break;
  280. default:
  281.     m_bSubSpecType = false;
  282.     break;
  283. }
  284.     }
  286.     bool operator()( const CRef< COrgMod >& mod ) const {
  287. // mod is the destination modifier
  288. if( m_nType == mod->GetSubtype() ) {
  289.     return true;
  290. }
  291. switch( mod->GetSubtype() ) {
  292. case COrgMod::eSubtype_strain:
  293. case COrgMod::eSubtype_substrain:
  294. case COrgMod::eSubtype_type:
  295. case COrgMod::eSubtype_subtype:
  296. case COrgMod::eSubtype_variety:
  297. case COrgMod::eSubtype_serotype:
  298. case COrgMod::eSubtype_serogroup:
  299. case COrgMod::eSubtype_serovar:
  300. case COrgMod::eSubtype_cultivar:
  301. case COrgMod::eSubtype_pathovar:
  302. case COrgMod::eSubtype_chemovar:
  303. case COrgMod::eSubtype_biovar:
  304. case COrgMod::eSubtype_biotype:
  305. case COrgMod::eSubtype_group:
  306. case COrgMod::eSubtype_subgroup:
  307. case COrgMod::eSubtype_isolate:
  308. // case COrgMod::eSubtype_sub_species:
  309.     return m_bSubSpecType;
  311. //     if( (m_nType >= 2 && m_nType <= 17) ) return 1;
  312.   case COrgMod::eSubtype_other:
  313.       return true;
  314. default:
  315.     break;
  316. }
  317. return false;
  318.     }
  320. private:
  321.     int     m_nType;
  322.     bool    m_bSubSpecType;
  323. };
  325. class PFindModByType {
  326. public:
  327.     PFindModByType( int type ) : m_nType( type ) {}
  329.     bool operator()( const CRef< COrgMod >& mod ) const {
  330. return ( m_nType == mod->GetSubtype() );
  331.     }
  332. private:
  333.     int     m_nType;
  334. };
  336. class PRemoveSynAnamorph {
  337. public:
  338.     PRemoveSynAnamorph( const string& sTaxname ) : m_sName( sTaxname ) {}
  340.     bool operator()( const CRef< COrgMod >& mod ) const {
  341. switch( mod->GetSubtype() ) {
  342. case COrgMod::eSubtype_synonym:
  343. case COrgMod::eSubtype_anamorph:
  344.     return (NStr::CompareNocase( m_sName, mod->GetSubname() ) == 0);
  345. default:
  346.     break;
  347. }
  348. return false;
  349.     }
  351. private:
  352.     const string& m_sName;
  353. };
  355. void
  356. CTaxon1::OrgRefAdjust( COrg_ref& inp_orgRef, const COrg_ref& db_orgRef,
  357.        int tax_id )
  358. {
  359.     inp_orgRef.ResetCommon();
  360.     inp_orgRef.ResetSyn();
  361.     
  362.     // fill-up inp_orgRef based on db_orgRef
  363.     inp_orgRef.SetTaxname( db_orgRef.GetTaxname() );
  364.     if( db_orgRef.IsSetCommon() ) {
  365. inp_orgRef.SetCommon( db_orgRef.GetCommon() );
  366.     }
  367.     // Set tax id
  368.     inp_orgRef.SetTaxId( tax_id );
  369.     // copy the synonym list
  370.     if( m_bWithSynonyms && db_orgRef.IsSetSyn() ) {
  371. inp_orgRef.SetSyn() = db_orgRef.GetSyn();
  372.     }
  373.   
  374.     // copy orgname
  375.     COrgName& on = inp_orgRef.SetOrgname();
  377.     // Copy the orgname
  378.     on.SetName().Assign( db_orgRef.GetOrgname().GetName() );
  380.     bool bHasMod = on.IsSetMod();
  381.     const COrgName::TMod& lSrcMod = db_orgRef.GetOrgname().GetMod();
  382.     COrgName::TMod& lDstMod = on.SetMod();
  384.     if( bHasMod ) { // Merge modifiers
  385. // Find and remove gb_xxx modifiers
  386. // tc2proc.c: CleanOrgName
  387. // Service stuff
  388. CTaxon1_req req;
  389. CTaxon1_resp resp;
  390. CRef<CTaxon1_info> pModInfo( new CTaxon1_info() );
  392. PushDiagPostPrefix( "Taxon1::OrgRefAdjust" );
  394. for( COrgName::TMod::iterator i = lDstMod.begin();
  395.      i != lDstMod.end(); ) {
  396.     switch( (*i)->GetSubtype() ) {
  397.     case COrgMod::eSubtype_gb_acronym:
  398.     case COrgMod::eSubtype_gb_anamorph:
  399.     case COrgMod::eSubtype_gb_synonym:
  400. i = lDstMod.erase( i );
  401. break;
  402.     default: // Check the modifier validity
  403. if( (*i)->CanGetSubname() && (*i)->CanGetSubtype() &&
  404.     !(*i)->GetSubname().empty() && (*i)->GetSubtype() != 0 ) {
  405.     pModInfo->SetIval1( tax_id );
  406.     pModInfo->SetIval2( (*i)->GetSubtype() );
  407.     pModInfo->SetSval( (*i)->GetSubname() );
  409.     req.SetGetorgmod( *pModInfo );
  410.     try {
  411. if( SendRequest( req, resp ) ) {
  412.     if( !resp.IsGetorgmod() ) { // error
  413. ERR_POST( "Response type is not Getorgmod" );
  414.     } else {
  415. if( resp.GetGetorgmod().size() > 0 ) {
  416.     CRef<CTaxon1_info> pInfo
  417. = resp.GetGetorgmod().front();
  418.     if( pInfo->GetIval1() == tax_id ) {
  419. if( pInfo->GetIval2() == 0 ) {
  420. // Modifier is wrong (probably, hidden)
  421.     i = lDstMod.erase( i );
  422.     continue;
  423. } else {
  424.     (*i)->SetSubname( pInfo->GetSval() );
  425.     (*i)->SetSubtype( COrgMod::TSubtype( pInfo->GetIval2() ) );
  426. }
  427.     } else if( pInfo->GetIval1() != 0 ) {
  428. // Another redirection occurred
  429. // leave modifier but issue warning
  430. NCBI_NS_NCBI::CNcbiDiag(eDiag_Warning)
  431.     << "OrgMod type="
  432.     << COrgMod::GetTypeInfo_enum_ESubtype()
  433.     ->FindName( (*i)->GetSubtype(), true )
  434.     << " name='" << (*i)->GetSubname()
  435.     << "' causing illegal redirection"
  436.     << NCBI_NS_NCBI::Endm;
  437.     }
  438. }
  439.     }
  440. } else if( resp.IsError()
  441.    && resp.GetError().GetLevel() 
  442.    != CTaxon1_error::eLevel_none ) {
  443.     string sErr;
  444.     resp.GetError().GetErrorText( sErr );
  445.     ERR_POST( sErr );
  446. }
  447.     } catch( exception& e ) {
  448. ERR_POST( e.what() );
  449.     }
  451. }
  453. ++i;
  454. break;
  455.     }
  456. }
  458. PopDiagPostPrefix();
  460. PFindConflict predConflict;
  462. for( COrgName::TMod::const_iterator i = lSrcMod.begin();
  463.      i != lSrcMod.end();
  464.      ++i ) {
  465.     predConflict.SetTypeToMatch( (*i)->GetSubtype() );
  466.     if( (*i)->GetSubtype() != COrgMod::eSubtype_other ) {
  467. if( find_if( lDstMod.begin(), lDstMod.end(), predConflict )
  468.     == lDstMod.end() ) {
  469.     CRef<COrgMod> pMod( new COrgMod() );
  470.     pMod->Assign( *(*i) );
  471.     lDstMod.push_back( pMod );
  472. }
  473.     }
  474. }
  475.     } else { // Copy modifiers
  477. CRef<COrgMod> pMod;
  478. for( COrgName::TMod::const_iterator i = lSrcMod.begin();
  479.      i != lSrcMod.end();
  480.      ++i ) {
  481.     switch( (*i)->GetSubtype() ) {
  482.     case COrgMod::eSubtype_gb_acronym:
  483.     case COrgMod::eSubtype_gb_anamorph:
  484.     case COrgMod::eSubtype_gb_synonym:
  485.        pMod.Reset( new COrgMod() );
  486.        pMod->Assign( *(*i) );
  487.        lDstMod.push_back( pMod );
  488.     default:
  489.        break;
  490.     }
  491. }
  492. // Remove 'other' modifiers
  493. PFindModByType fmbt( COrgMod::eSubtype_other );
  494. remove_if( lDstMod.begin(), lDstMod.end(), fmbt );
  495.     }
  496.     // Remove 'synonym' or 'anamorph' it if coincides with taxname
  497.     PRemoveSynAnamorph rsa( inp_orgRef.GetTaxname() );
  498.     remove_if( lDstMod.begin(), lDstMod.end(), rsa );
  500.     // Reset destination modifiers if empty
  501.     if( lDstMod.size() == 0 ) {
  502. on.ResetMod();
  503.     }
  504.     // Copy lineage
  505.     if( db_orgRef.GetOrgname().IsSetLineage() ) {
  506. on.SetLineage() = db_orgRef.GetOrgname().GetLineage();
  507.     } else {
  508. on.ResetLineage();
  509.     }
  510.     if( db_orgRef.GetOrgname().IsSetGcode() ) {
  511. on.SetGcode( db_orgRef.GetOrgname().GetGcode() );
  512.     } else {
  513. on.ResetGcode();
  514.     }
  515.     if( db_orgRef.GetOrgname().IsSetMgcode() ) {
  516. on.SetMgcode( db_orgRef.GetOrgname().GetMgcode() );
  517.     } else {
  518. on.ResetMgcode();
  519.     }
  520.     if( db_orgRef.GetOrgname().IsSetDiv() ) {
  521. on.SetDiv( db_orgRef.GetOrgname().GetDiv() );
  522.     } else {
  523. on.ResetDiv();
  524.     }
  525. }
  527. bool
  528. CTaxon1::LookupByOrgRef(const COrg_ref& inp_orgRef, int* pTaxid,
  529. COrgName::TMod& hitMods )
  530. {
  531.     SetLastError(NULL);
  533.     CTaxon1_req  req;
  534.     CTaxon1_resp resp;
  536.     SerialAssign< COrg_ref >( req.SetLookup(), inp_orgRef );
  538.     if( SendRequest( req, resp ) ) {
  539.         if( resp.IsLookup() ) {
  540.             // Correct response, return object
  541.     COrg_ref& result = resp.SetLookup().SetOrg();
  542.     *pTaxid = result.GetTaxId();
  543.     if( result.IsSetOrgname() &&
  544. result.GetOrgname().IsSetMod() ) {
  545. hitMods.swap( result.SetOrgname().SetMod() );
  546.     }
  547. //  for( COrgName::TMod::const_iterator ci =
  548. //   result.GetOrgname().GetMod().begin();
  549. //       ci != result.GetOrgname().GetMod().end();
  550. //       ++ci ) {
  551. //      if( (*ci)->GetSubtype() == COrgMod::eSubtype_old_name ) {
  552. //  hitMod->Assign( *ci );
  553. //  bHitFound = true;
  554. //  break;
  555. //      }
  556. //  }
  557. //      }
  558. //      if( bHitFound ) {
  559. //  hitMod.Reset( NULL );
  560. //      }
  561.     return true;
  562.         } else { // Internal: wrong respond type
  563.             SetLastError( "Response type is not Lookup" );
  564.         }
  565.     }
  566.     return false;
  567. }
  569. void
  570. CTaxon1::PopulateReplaced( COrg_ref& org, COrgName::TMod& lMods  )
  571. {
  572.     if( org.IsSetOrgname() ) {
  573. CRef< COrgMod > pOldNameMod;
  574. COrgName& on = org.SetOrgname();
  575. for( COrgName::TMod::iterator i = lMods.begin();
  576.      i != lMods.end();
  577.      ++i ) {
  578.     if( (*i)->GetSubtype() == COrgMod::eSubtype_old_name ) {
  579. pOldNameMod = *i;
  580. continue;
  581.     }
  582.     if( on.IsSetMod() ) {
  583. PFindModByType fmbt( (*i)->GetSubtype() );
  584. if( find_if( on.GetMod().begin(), on.GetMod().end(), fmbt )
  585.     != on.GetMod().end() ) {
  586.     /* modifier already present in target orgref */
  587.     continue;
  588. }
  589.     }
  590.     /* adding this modifier */
  591.     on.SetMod().push_back( *i );
  592. }
  593. if( pOldNameMod ) {
  594.     if( on.IsSetMod() ) {
  595. PFindModByType fmbt( COrgMod::eSubtype_old_name );
  596. COrgName::TMod::iterator i =
  597.     find_if( on.SetMod().begin(), on.SetMod().end(), fmbt );
  598. if( i != on.SetMod().end() ) {
  599.     // There is old-name in the target already
  600.     if( !(*i)->IsSetAttrib() && pOldNameMod->IsSetAttrib() &&
  601. NStr::CompareNocase(pOldNameMod->GetSubname(), 
  602.     (*i)->GetSubname() ) == 0 ) {
  603. (*i)->SetAttrib( pOldNameMod->GetAttrib() );
  604.     }
  605.     return;
  606. }
  607.     }
  608.     /* we probably don't need to populate search name */
  609.     if( org.IsSetTaxname() &&
  610. NStr::CompareNocase( org.GetTaxname(),
  611.      pOldNameMod->GetSubname() ) == 0 ) {
  612. if( pOldNameMod->IsSetAttrib() ) {
  613.     const string& sAttrib = pOldNameMod->GetAttrib();
  614.     if( !sAttrib.empty() && sAttrib[0] == '(' ) {
  615. try {
  616.     CRef< COrgMod > srchMod( new COrgMod );
  617.     string::size_type pos = sAttrib.find("=");
  618.     if( pos == string::npos ) {
  619. return;
  620.     }
  621.     if( on.IsSetMod() ) {
  622. const COrgName::TMod& mods = on.GetMod();
  623. srchMod->SetSubname()
  624.     .assign( sAttrib.c_str()+pos+1 );
  625. srchMod->SetSubtype
  626.     ( COrgMod::TSubtype
  627.                                       (NStr::StringToInt
  628.       (sAttrib.substr(1, pos-1), 10,
  629.        NStr::eCheck_Skip) ) );
  630. PFindMod mf;
  631. mf.SetModToMatch( srchMod );
  632. if( find_if( mods.begin(), mods.end(),
  633.      mf ) != mods.end() ) {
  634.     return;
  635. }
  636.     }
  637. } catch(...) { return; }
  638.     } else
  639. return;
  640. } else
  641.     return;
  642.     }
  643.     // Add old-name to modifiers
  644.     on.SetMod().push_back( pOldNameMod );
  645. }
  646.     }
  647. }
  649. CRef< CTaxon2_data >
  650. CTaxon1::Lookup(const COrg_ref& inp_orgRef )
  651. {
  652.     SetLastError(NULL);
  653.     // Check if this taxon is in cache
  654.     CTaxon2_data* pData = 0;
  655.     COrgName::TMod hitMod;
  656.     int tax_id = 0; //GetTaxIdByOrgRef( inp_orgRef );
  658.     if( LookupByOrgRef( inp_orgRef, &tax_id, hitMod )
  659. && tax_id > 0
  660.         && m_plCache->LookupAndInsert( tax_id, &pData ) && pData ) {
  662.         CTaxon2_data* pNewData = new CTaxon2_data();
  664. //        SerialAssign<CTaxon2_data>( *pNewData, *pData  );
  665. COrg_ref* pOrf = new COrg_ref;
  666. pOrf->Assign( inp_orgRef );
  667. if( pOrf->IsSetOrgname() && pOrf->GetOrgname().IsSetMod() ) {
  668.     // Clean up modifiers
  669.     pOrf->SetOrgname().ResetMod();
  670. }
  671. pNewData->SetOrg( *pOrf );
  673. const COrg_ref& db_orgRef = pData->GetOrg();
  675. OrgRefAdjust( pNewData->SetOrg(), db_orgRef, tax_id );
  676. // Copy all other fields
  677. if( pData->IsSetBlast_name() ) {
  678.     pNewData->SetBlast_name() = pData->GetBlast_name();
  679. }
  680. if( pData->IsSetIs_uncultured() ) {
  681.     pNewData->SetIs_uncultured( pData->GetIs_uncultured() );
  682. }
  683. if( pData->IsSetIs_species_level() ) {
  684.     pNewData->SetIs_species_level( pData->GetIs_species_level() );
  685. }
  686. // Insert the hitMod if necessary
  687. if( hitMod.size() > 0 ) {
  688.     PopulateReplaced( pNewData->SetOrg(), hitMod );
  689. }
  691.         return CRef<CTaxon2_data>(pNewData);
  692.     }
  693.     return CRef<CTaxon2_data>(NULL);
  694. }
  696. CConstRef< CTaxon2_data >
  697. CTaxon1::LookupMerge(COrg_ref& inp_orgRef )
  698. {
  699.     CTaxon2_data* pData = 0;
  701.     SetLastError(NULL);
  702.     COrgName::TMod hitMod;
  703.     int tax_id = 0; //GetTaxIdByOrgRef( inp_orgRef );
  705.     if( LookupByOrgRef( inp_orgRef, &tax_id, hitMod )
  706. && tax_id > 0
  707.         && m_plCache->LookupAndInsert( tax_id, &pData ) && pData ) {
  709. const COrg_ref& db_orgRef = pData->GetOrg();
  711. OrgRefAdjust( inp_orgRef, db_orgRef, tax_id );
  713. if( hitMod.size() > 0 ) {
  714.     PopulateReplaced( inp_orgRef, hitMod );
  715. }
  716.     }
  717.     return CConstRef<CTaxon2_data>(pData);
  718. }
  720. int
  721. CTaxon1::GetTaxIdByOrgRef(const COrg_ref& inp_orgRef)
  722. {
  723.     SetLastError(NULL);
  725.     CTaxon1_req  req;
  726.     CTaxon1_resp resp;
  728.     SerialAssign< COrg_ref >( req.SetGetidbyorg(), inp_orgRef );
  730.     if( SendRequest( req, resp ) ) {
  731.         if( resp.IsGetidbyorg() ) {
  732.             // Correct response, return object
  733.             return resp.GetGetidbyorg();
  734.         } else { // Internal: wrong respond type
  735.             SetLastError( "Response type is not Getidbyorg" );
  736.         }
  737.     }
  738.     return 0;
  739. }
  741. int
  742. CTaxon1::GetTaxIdByName(const string& orgname)
  743. {
  744.     SetLastError(NULL);
  745.     if( orgname.empty() )
  746.         return 0;
  747.     COrg_ref orgRef;
  748.     
  749.     orgRef.SetTaxname().assign( orgname );
  750.     
  751.     return GetTaxIdByOrgRef(orgRef);
  752. }
  754. int
  755. CTaxon1::FindTaxIdByName(const string& orgname)
  756. {
  757.     SetLastError(NULL);
  758.     if( orgname.empty() )
  759.         return 0;
  761.     int id( GetTaxIdByName(orgname) );
  763.     if(id < 1) {
  765.         int idu = 0;
  767.         CTaxon1_req  req;
  768.         CTaxon1_resp resp;
  770.         req.SetGetunique().assign( orgname );
  772.         if( SendRequest( req, resp ) ) {
  773.             if( resp.IsGetunique() ) {
  774.                 // Correct response, return object
  775.                 idu = resp.GetGetunique();
  776.             } else { // Internal: wrong respond type
  777.                 SetLastError( "Response type is not Getunique" );
  778.             }
  779.         }
  781.         if( idu > 0 )
  782.             id= idu;
  783.     }
  784.     return id;
  785. }
  787. //----------------------------------------------
  788. // Get tax_id by organism name using fancy search modes.
  789. // Returns: tax_id - if the only organism found
  790. //               0 - no organism found
  791. //         -tax_id - if multiple nodes found
  792. //                   (where -tax_id is id of one of the nodes)
  793. ///
  794. int
  795. CTaxon1::SearchTaxIdByName(const string& orgname, ESearch mode,
  796.    list< CRef< CTaxon1_name > >* pNameList)
  797. {
  798.     // Use fancy searches
  799.     SetLastError(NULL);
  800.     if( orgname.empty() ) {
  801. return 0;
  802.     }
  803.     CRef< CTaxon1_info > pQuery( new CTaxon1_info() );
  804.     int nMode = 0;
  805.     switch( mode ) {
  806.     default:
  807.     case eSearch_Exact:    nMode = 0; break;
  808.     case eSearch_TokenSet: nMode = 1; break;
  809.     case eSearch_WildCard: nMode = 2; break; // shell-style wildcards, i.e. *,?,[]
  810.     case eSearch_Phonetic: nMode = 3; break;
  811.     }
  812.     pQuery->SetIval1( nMode );
  813.     pQuery->SetIval2( 0 );
  814.     pQuery->SetSval( orgname );
  815.     
  816.     CTaxon1_req  req;
  817.     CTaxon1_resp resp;
  819.     req.SetSearchname( *pQuery );
  820.     
  821.     if( SendRequest( req, resp ) ) {
  822. if( resp.IsSearchname() ) {
  823.     // Correct response, return object
  824.     int retc = 0;
  825.     const CTaxon1_resp::TSearchname& lNm = resp.GetSearchname();
  826.     if( lNm.size() == 0 ) {
  827. retc = 0;
  828.     } else if( lNm.size() == 1 ) {
  829. retc = lNm.front()->GetTaxid();
  830.     } else {
  831. retc = -1;
  832.     }
  833.     // Fill the names list
  834.     if( pNameList ) {
  835. pNameList->swap( resp.SetSearchname() );
  836.     }
  837.     return retc;
  838. } else { // Internal: wrong respond type
  839.     SetLastError( "Response type is not Searchname" );
  840.     return 0;
  841. }
  842.     }
  843.     return 0;
  844. }
  846. int
  847. CTaxon1::GetAllTaxIdByName(const string& orgname, TTaxIdList& lIds)
  848. {
  849.     int count = 0;
  851.     SetLastError(NULL);
  852.     if( orgname.empty() )
  853.         return 0;
  855.     CTaxon1_req  req;
  856.     CTaxon1_resp resp;
  858.     req.SetFindname().assign(orgname);
  860.     if( SendRequest( req, resp ) ) {
  861.         if( resp.IsFindname() ) {
  862.             // Correct response, return object
  863.             const list< CRef< CTaxon1_name > >& lNm = resp.GetFindname();
  864.             // Fill in the list
  865.             for( list< CRef< CTaxon1_name > >::const_iterator
  866.                      i = lNm.begin();
  867.                  i != lNm.end(); ++i, ++count )
  868.                 lIds.push_back( (*i)->GetTaxid() );
  869.         } else { // Internal: wrong respond type
  870.             SetLastError( "Response type is not Findname" );
  871.             return 0;
  872.         }
  873.     }
  874.     return count;
  875. }
  877. CConstRef< COrg_ref >
  878. CTaxon1::GetOrgRef(int tax_id,
  879.                    bool& is_species,
  880.                    bool& is_uncultured,
  881.                    string& blast_name)
  882. {
  883.     SetLastError(NULL);
  884.     if( tax_id > 1 ) {
  885.         CTaxon2_data* pData = 0;
  886.         if( m_plCache->LookupAndInsert( tax_id, &pData ) && pData ) {
  887.             is_species = pData->GetIs_species_level();
  888.             is_uncultured = pData->GetIs_uncultured();
  889.             if( pData->GetBlast_name().size() > 0 ) {
  890.                 blast_name.assign( pData->GetBlast_name().front() );
  891.             }
  892.             return CConstRef<COrg_ref>(&pData->GetOrg());
  893.         }
  894.     }
  895.     return null;
  896. }
  898. bool
  899. CTaxon1::SetSynonyms(bool on_off)
  900. {
  901.     SetLastError(NULL);
  902.     bool old_val( m_bWithSynonyms );
  903.     m_bWithSynonyms = on_off;
  904.     return old_val;
  905. }
  907. int
  908. CTaxon1::GetParent(int id_tax)
  909. {
  910.     CTaxon1Node* pNode = 0;
  911.     SetLastError(NULL);
  912.     if( m_plCache->LookupAndAdd( id_tax, &pNode )
  913.         && pNode && pNode->GetParent() ) {
  914.         return pNode->GetParent()->GetTaxId();
  915.     }
  916.     return 0;
  917. }
  919. int
  920. CTaxon1::GetGenus(int id_tax)
  921. {
  922.     CTaxon1Node* pNode = 0;
  923.     SetLastError(NULL);
  924.     if( m_plCache->LookupAndAdd( id_tax, &pNode )
  925.         && pNode ) {
  926.         int genus_rank(m_plCache->GetGenusRank());
  927.         while( !pNode->IsRoot() ) {
  928.             int rank( pNode->GetRank() );
  929.             if( rank == genus_rank )
  930.                 return pNode->GetTaxId();
  931.             if( (rank > 0) && (rank < genus_rank))
  932.                 return -1;
  933.             pNode = pNode->GetParent();
  934.         }
  935.     }
  936.     return -1;
  937. }
  939. int
  940. CTaxon1::GetSuperkingdom(int id_tax)
  941. {
  942.     CTaxon1Node* pNode = 0;
  943.     SetLastError(NULL);
  944.     if( m_plCache->LookupAndAdd( id_tax, &pNode )
  945.         && pNode ) {
  946.         int sk_rank(m_plCache->GetSuperkingdomRank());
  947.         while( !pNode->IsRoot() ) {
  948.             int rank( pNode->GetRank() );
  949.             if( rank == sk_rank )
  950.                 return pNode->GetTaxId();
  951.             if( (rank > 0) && (rank < sk_rank))
  952.                 return -1;
  953.             pNode = pNode->GetParent();
  954.         }
  955.     }
  956.     return -1;
  957. }
  959. int
  960. CTaxon1::GetChildren(int id_tax, TTaxIdList& children_ids)
  961. {
  962.     int count(0);
  963.     CTaxon1Node* pNode = 0;
  964.     SetLastError(NULL);
  965.     if( m_plCache->LookupAndAdd( id_tax, &pNode )
  966.         && pNode ) {
  968.         CTaxon1_req  req;
  969.         CTaxon1_resp resp;
  971.         req.SetTaxachildren( id_tax );
  973.         if( SendRequest( req, resp ) ) {
  974.             if( resp.IsTaxachildren() ) {
  975.                 // Correct response, return object
  976.                 list< CRef< CTaxon1_name > >& lNm = resp.SetTaxachildren();
  977.                 // Fill in the list
  978.                 CTreeIterator* pIt = m_plCache->GetTree().GetIterator();
  979.                 pIt->GoNode( pNode );
  980.                 for( list< CRef< CTaxon1_name > >::const_iterator
  981.                          i = lNm.begin();
  982.                      i != lNm.end(); ++i, ++count ) {
  983.                     children_ids.push_back( (*i)->GetTaxid() );
  984.                     // Add node to the partial tree
  985.                     CTaxon1Node* pNewNode = new CTaxon1Node(*i);
  986.                     m_plCache->SetIndexEntry(pNewNode->GetTaxId(), pNewNode);
  987.                     pIt->AddChild( pNewNode );
  988.                 }
  989.             } else { // Internal: wrong respond type
  990.                 SetLastError( "Response type is not Taxachildren" );
  991.                 return 0;
  992.             }
  993.         }
  994.     }
  995.     return count;
  996. }
  998. bool
  999. CTaxon1::GetGCName(short gc_id, string& gc_name_out )
  1000. {
  1001.     SetLastError(NULL);
  1002.     if( m_gcStorage.empty() ) {
  1003.         CTaxon1_req  req;
  1004.         CTaxon1_resp resp;
  1006.         req.SetGetgcs();
  1008.         if( SendRequest( req, resp ) ) {
  1009.             if( resp.IsGetgcs() ) {
  1010.                 // Correct response, return object
  1011.                 const list< CRef< CTaxon1_info > >& lGc = resp.GetGetgcs();
  1012.                 // Fill in storage
  1013.                 for( list< CRef< CTaxon1_info > >::const_iterator
  1014.                          i = lGc.begin();
  1015.                      i != lGc.end(); ++i ) {
  1016.                     m_gcStorage.insert( TGCMap::value_type((*i)->GetIval1(),
  1017.                                                            (*i)->GetSval()) );
  1018. }
  1019.             } else { // Internal: wrong respond type
  1020.                 SetLastError( "Response type is not Getgcs" );
  1021.                 return false;
  1022.             }
  1023.         }
  1024.     }
  1025.     TGCMap::const_iterator gci( m_gcStorage.find( gc_id ) );
  1026.     if( gci != m_gcStorage.end() ) {
  1027.         gc_name_out.assign( gci->second );
  1028.         return true;
  1029.     } else {
  1030.         SetLastError( "ERROR: GetGCName(): Unknown genetic code" );
  1031.         return false;
  1032.     }
  1033. }
  1035. //---------------------------------------------
  1036. // Get taxonomic rank name by rank id
  1037. ///
  1038. bool
  1039. CTaxon1::GetRankName(short rank_id, string& rank_name_out )
  1040. {
  1041.     SetLastError( NULL );
  1042.     const char* pchName = m_plCache->GetRankName( rank_id );
  1043.     if( pchName ) {
  1044. rank_name_out.assign( pchName );
  1045. return true;
  1046.     } else {
  1047. SetLastError( "ERROR: GetRankName(): Rank not found" );
  1048. return false;
  1049.     }
  1050. }
  1052. //---------------------------------------------
  1053. // Get taxonomic division name by division id
  1054. ///
  1055. bool
  1056. CTaxon1::GetDivisionName(short div_id, string& div_name_out )
  1057. {
  1058.     SetLastError( NULL );
  1059.     const char* pchName = m_plCache->GetDivisionName( div_id );
  1060.     if( pchName ) {
  1061. div_name_out.assign( pchName );
  1062. return true;
  1063.     } else {
  1064. SetLastError( "ERROR: GetDivisionName(): Division not found" );
  1065. return false;
  1066.     }
  1067. }
  1069. //---------------------------------------------
  1070. // Get taxonomic name class (scientific name, common name, etc.) by id
  1071. ///
  1072. bool
  1073. CTaxon1::GetNameClass(short nameclass_id, string& name_class_out )
  1074. {
  1075.     SetLastError( NULL );
  1076.     const char* pchName = m_plCache->GetNameClassName( nameclass_id );
  1077.     if( pchName ) {
  1078. name_class_out.assign( pchName );
  1079. return true;
  1080.     } else {
  1081. SetLastError( "ERROR: GetNameClass(): Name class not found" );
  1082. return false;
  1083.     }
  1084. }
  1086. int
  1087. CTaxon1::Join(int taxid1, int taxid2)
  1088. {
  1089.     int tax_id = 0;
  1090.     CTaxon1Node *pNode1, *pNode2;
  1091.     SetLastError(NULL);
  1092.     if( m_plCache->LookupAndAdd( taxid1, &pNode1 ) && pNode1
  1093.         && m_plCache->LookupAndAdd( taxid2, &pNode2 ) && pNode2 ) {
  1094.         CRef< ITreeIterator > pIt( GetTreeIterator() );
  1095.         pIt->GoNode( pNode1 );
  1096.         pIt->GoAncestor( pNode2 );
  1097.         tax_id = pIt->GetNode()->GetTaxId();
  1098.     }
  1099.     return tax_id;
  1100. }
  1102. int
  1103. CTaxon1::GetAllNames(int tax_id, TNameList& lNames, bool unique)
  1104. {
  1105.     int count(0);
  1106.     SetLastError(NULL);
  1107.     CTaxon1_req  req;
  1108.     CTaxon1_resp resp;
  1110.     req.SetGetorgnames( tax_id );
  1112.     if( SendRequest( req, resp ) ) {
  1113.         if( resp.IsGetorgnames() ) {
  1114.             // Correct response, return object
  1115.             const list< CRef< CTaxon1_name > >& lNm = resp.GetGetorgnames();
  1116.             // Fill in the list
  1117.             for( list< CRef< CTaxon1_name > >::const_iterator
  1118.                      i = lNm.begin();
  1119.                  i != lNm.end(); ++i, ++count )
  1120.                 if( !unique ) {
  1121.                     lNames.push_back( (*i)->GetOname() );
  1122.                 } else {
  1123.                     lNames.push_back( ((*i)->IsSetUname() && !(*i)->GetUname().empty()) ?
  1124.                                       (*i)->GetUname() :
  1125.                                       (*i)->GetOname() );
  1126.                 }
  1127.         } else { // Internal: wrong respond type
  1128.             SetLastError( "Response type is not Getorgnames" );
  1129.             return 0;
  1130.         }
  1131.     }
  1133.     return count;
  1134. }
  1136. /*---------------------------------------------
  1137.  * Find organism name in the string (for PDB mostly)
  1138.  * Returns: nimber of tax_ids found
  1139.  * NOTE:
  1140.  * 1. orgname is substring of search_str which matches organism name
  1141.  *    (return parameter).
  1142.  * 2. Ids consists of tax_ids. Caller is responsible to free this memory
  1143.  */
  1144.  // int getTaxId4Str(const char* search_str, char** orgname, intPtr *Ids_out);
  1146. bool
  1147. CTaxon1::IsAlive(void)
  1148. {
  1149.     SetLastError(NULL);
  1150.     if( m_pServer ) {
  1151.         if( !m_pOut || !m_pOut->InGoodState() )
  1152.             SetLastError( "Output stream is not in good state" );
  1153.         else if( !m_pIn || !m_pIn->InGoodState() )
  1154.             SetLastError( "Input stream is not in good state" );
  1155.         else
  1156.             return true;
  1157.     } else {
  1158.         SetLastError( "Not connected to Taxonomy service" );
  1159.     }
  1160.     return false;
  1161. }
  1163. bool
  1164. CTaxon1::GetTaxId4GI(int gi, int& tax_id_out )
  1165. {
  1166.     SetLastError(NULL);
  1167.     CTaxon1_req  req;
  1168.     CTaxon1_resp resp;
  1169.     
  1170.     req.SetId4gi( gi );
  1172.     if( SendRequest( req, resp ) ) {
  1173.         if( resp.IsId4gi() ) {
  1174.             // Correct response, return object
  1175.             tax_id_out = resp.GetId4gi();
  1176.             return true;
  1177.         } else { // Internal: wrong respond type
  1178.             SetLastError( "Response type is not Id4gi" );
  1179.         }
  1180.     }
  1181.     return false;
  1182. }
  1184. bool
  1185. CTaxon1::GetBlastName(int tax_id, string& blast_name_out )
  1186. {
  1187.     CTaxon1Node* pNode = 0;
  1188.     SetLastError(NULL);
  1189.     if( m_plCache->LookupAndAdd( tax_id, &pNode ) && pNode ) {
  1190.         while( !pNode->IsRoot() ) {
  1191.             if( !pNode->GetBlastName().empty() ) {
  1192.                 blast_name_out.assign( pNode->GetBlastName() );
  1193.                 return true;
  1194.             }
  1195.             pNode = pNode->GetParent();
  1196.         }
  1197.         blast_name_out.erase();
  1198.         return true;
  1199.     }
  1200.     return false;
  1201. }
  1203. bool
  1204. CTaxon1::SendRequest( CTaxon1_req& req, CTaxon1_resp& resp )
  1205. {
  1206.     unsigned nIterCount( 0 );
  1207.     unsigned fail_flags( 0 );
  1208.     if( !m_pServer ) {
  1209.         SetLastError( "Service is not initialized" );
  1210.         return false;
  1211.     }
  1212.     SetLastError( NULL );
  1214.     do {
  1215.         bool bNeedReconnect( false );
  1217.         try {
  1218.             *m_pOut << req;
  1219.             m_pOut->Flush();
  1221.             if( m_pOut->InGoodState() ) {
  1222.                 try {
  1223.                     *m_pIn >> resp;
  1225.                     if( m_pIn->InGoodState() ) {
  1226.                         if( resp.IsError() ) { // Process error here
  1227.                             string err;
  1228.                             resp.GetError().GetErrorText( err );
  1229.                             SetLastError( err.c_str() );
  1230.                             return false;
  1231.                         } else
  1232.                             return true;
  1233.                     }
  1234.                 } catch( exception& e ) {
  1235.                     SetLastError( e.what() );
  1236.                 }
  1237.                 fail_flags = m_pIn->GetFailFlags();
  1238.                 bNeedReconnect = (fail_flags & ( CObjectIStream::eEOF
  1239.                                                  |CObjectIStream::eReadError
  1240.                                                  |CObjectIStream::eOverflow
  1241.                                                  |CObjectIStream::eFail
  1242.                                                  |CObjectIStream::eNotOpen )
  1243.                                   ? true : false);
  1244.             } else {
  1245.                 m_pOut->ThrowError((CObjectOStream::EFailFlags)
  1246.                                     m_pOut->GetFailFlags(),
  1247.                                     "Output stream is in bad state");
  1248.             }
  1249.         } catch( exception& e ) {
  1250.             SetLastError( e.what() );
  1251.             fail_flags = m_pOut->GetFailFlags();
  1252.             bNeedReconnect = (fail_flags & ( CObjectOStream::eEOF
  1253.                                              |CObjectOStream::eWriteError
  1254.                                              |CObjectOStream::eOverflow
  1255.                                              |CObjectOStream::eFail
  1256.                                              |CObjectOStream::eNotOpen )
  1257.                               ? true : false);
  1258.         }
  1260.         if( !bNeedReconnect )
  1261.             break;
  1262.         // Reconnect the service
  1263.         if( nIterCount < m_nReconnectAttempts ) {
  1264.             delete m_pOut;
  1265.             delete m_pIn;
  1266.             delete m_pServer;
  1267.             m_pOut = NULL;
  1268.             m_pIn = NULL;
  1269.             m_pServer = NULL;
  1270.             try {
  1271.                 auto_ptr<CObjectOStream> pOut;
  1272.                 auto_ptr<CObjectIStream> pIn;
  1273.                 auto_ptr<CConn_ServiceStream>
  1274.                     pServer( new CConn_ServiceStream(m_pchService, fSERV_Any,
  1275.                                                      0, 0, m_timeout) );
  1277.                 pOut.reset( CObjectOStream::Open(m_eDataFormat, *pServer) );
  1278.                 pIn.reset( CObjectIStream::Open(m_eDataFormat, *pServer) );
  1279.                 m_pServer = pServer.release();
  1280.                 m_pIn = pIn.release();
  1281.                 m_pOut = pOut.release();
  1282.             } catch( exception& e ) {
  1283.                 SetLastError( e.what() );
  1284.             }
  1285.         } else { // No more attempts left
  1286.             break;
  1287.         }
  1288.     } while( nIterCount++ < m_nReconnectAttempts );
  1289.     return false;
  1290. }
  1292. void
  1293. CTaxon1::SetLastError( const char* pchErr )
  1294. {
  1295.     if( pchErr )
  1296.         m_sLastError.assign( pchErr );
  1297.     else
  1298.         m_sLastError.erase();
  1299. }
  1301. static void s_StoreResidueTaxid( CTreeIterator* pIt, CTaxon1::TTaxIdList& lTo )
  1302. {
  1303.     CTaxon1Node* pNode =  static_cast<CTaxon1Node*>( pIt->GetNode() );
  1304.     if( !pNode->IsJoinTerminal() ) {
  1305. lTo.push_back( pNode->GetTaxId() );
  1306.     }
  1307.     if( pIt->GoChild() ) {
  1308. do {
  1309.     s_StoreResidueTaxid( pIt, lTo );
  1310. } while( pIt->GoSibling() );
  1311. pIt->GoParent();
  1312.     }
  1313. }
  1314. //--------------------------------------------------
  1315. // This function constructs minimal common tree from the gived tax id
  1316. // set (ids_in) treated as tree's leaves. It then returns a residue of 
  1317. // this tree node set and the given tax id set in ids_out.
  1318. // Returns: false if some error
  1319. //          true  if Ok
  1320. ///
  1321. typedef vector<CTaxon1Node*> TTaxNodeLineage;
  1322. bool
  1323. CTaxon1::GetPopsetJoin( const TTaxIdList& ids_in, TTaxIdList& ids_out )
  1324. {
  1325.     SetLastError(NULL);
  1326.     if( ids_in.size() > 0 ) {
  1327. map< int, CTaxon1Node* > nodeMap;
  1328. CTaxon1Node *pParent = 0, *pNode = 0, *pNewParent = 0;
  1329. CTreeCont tPartTree; // Partial tree
  1330. CTreeIterator* pIt = tPartTree.GetIterator();
  1331. TTaxNodeLineage vLin;
  1332. // Build the partial tree
  1333.   bool bHasSiblings;
  1334. vLin.reserve( 256 );
  1335. for( TTaxIdList::const_iterator ci = ids_in.begin();
  1336.      ci != ids_in.end();
  1337.      ++ci ) {
  1338.     map< int, CTaxon1Node* >::iterator nmi = nodeMap.find( *ci );
  1339.     if( nmi == nodeMap.end() ) {
  1340. if( m_plCache->LookupAndAdd( *ci, &pNode ) ) {
  1341.     if( !tPartTree.GetRoot() ) {
  1342. pNewParent = new CTaxon1Node
  1343.     ( *static_cast<const CTaxon1Node*>
  1344.       (m_plCache->GetTree().GetRoot()) );
  1345. tPartTree.SetRoot( pNewParent );
  1346. nodeMap.insert( map< int,CTaxon1Node* >::value_type
  1347. (pNewParent->GetTaxId(), pNewParent) );
  1348.     }
  1349.     if( pNode ) {
  1350. vLin.clear();
  1351. pParent = pNode->GetParent();
  1352. pNode = new CTaxon1Node( *pNode );
  1353. pNode->SetJoinTerminal();
  1354. vLin.push_back( pNode );
  1355. while( pParent &&
  1356.        ((nmi=nodeMap.find(pParent->GetTaxId()))
  1357.  == nodeMap.end()) ) {
  1358.     pNode = new CTaxon1Node( *pParent );
  1359.     vLin.push_back( pNode );
  1360.     pParent = pParent->GetParent();
  1361. }
  1362. if( !pParent ) {
  1363.     pIt->GoRoot();
  1364. } else {
  1365.     pIt->GoNode( nmi->second );
  1366. }
  1367. for( TTaxNodeLineage::reverse_iterator i =
  1368.  vLin.rbegin();
  1369.      i != vLin.rend();
  1370.      ++i ) {
  1371.     pNode = *i;
  1372.     nodeMap.insert( map< int,CTaxon1Node* >::value_type
  1373.     ( pNode->GetTaxId(), pNode ) );
  1374.     pIt->AddChild( pNode );
  1375.     pIt->GoNode( pNode );
  1376. }
  1377.     }
  1378. } else { // Error while adding - ignore invalid tax_ids
  1379.     continue;
  1380.     //return false;
  1381. }
  1382.     } else { // Node is already here
  1383. nmi->second->SetJoinTerminal();
  1384.     }
  1385. }
  1386. // Partial tree is build, make a residue
  1387. pIt->GoRoot();
  1388. bHasSiblings = true;
  1389. if( pIt->GoChild() ) {
  1390.     while( !pIt->GoSibling() ) {
  1391. pNode = static_cast<CTaxon1Node*>( pIt->GetNode() );
  1392. if( pNode->IsJoinTerminal() || !pIt->GoChild() ) {
  1393.     bHasSiblings = false;
  1394.     break;
  1395. }
  1396.     }
  1397.     if( bHasSiblings ) {
  1398. pIt->GoParent();
  1399.     }
  1400.     s_StoreResidueTaxid( pIt, ids_out );
  1401. }
  1402.     }
  1403.     return true;
  1404. }
  1406. //-----------------------------------
  1407. //  Tree-related functions
  1408. bool
  1409. CTaxon1::LoadSubtreeEx( int tax_id, int levels, const ITaxon1Node** ppNode )
  1410. {
  1411.     CTaxon1Node* pNode = 0;
  1412.     SetLastError(NULL);
  1413.     if( ppNode ) {
  1414. *ppNode = pNode;
  1415.     }
  1416.     if( m_plCache->LookupAndAdd( tax_id, &pNode )
  1417.         && pNode ) {
  1419. if( ppNode ) {
  1420.     *ppNode = pNode;
  1421. }
  1423. if( pNode->IsSubtreeLoaded() ) {
  1424.     return true;
  1425. }
  1427. if( levels == 0 ) {
  1428.     return true;
  1429. }
  1431.         CTaxon1_req  req;
  1432.         CTaxon1_resp resp;
  1434. if( levels < 0 ) {
  1435.     tax_id = -tax_id;
  1436. }
  1437.         req.SetTaxachildren( tax_id );
  1439.         if( SendRequest( req, resp ) ) {
  1440.             if( resp.IsTaxachildren() ) {
  1441.                 // Correct response, return object
  1442.                 list< CRef< CTaxon1_name > >& lNm = resp.SetTaxachildren();
  1443.                 // Fill in the list
  1444.                 CTreeIterator* pIt = m_plCache->GetTree().GetIterator();
  1445.                 pIt->GoNode( pNode );
  1446.                 for( list< CRef< CTaxon1_name > >::const_iterator
  1447.                          i = lNm.begin();
  1448.                      i != lNm.end(); ++i ) {
  1449.     if( (*i)->GetCde() == 0 ) { // Change parent node
  1450. if( m_plCache->LookupAndAdd( (*i)->GetTaxid(), &pNode )
  1451.     && pNode ) { 
  1452.     pIt->GoNode( pNode );
  1453. } else { // Invalid parent specified
  1454.     SetLastError( ("Invalid parent taxid "
  1455.   + NStr::IntToString((*i)->GetTaxid())
  1456.   ).c_str() );
  1457.     return false;
  1458. }
  1459.     } else { // Add node to the partial tree
  1460. if( !m_plCache->Lookup((*i)->GetTaxid(), &pNode) ) {
  1461.     pNode = new CTaxon1Node(*i);
  1462.     m_plCache->SetIndexEntry(pNode->GetTaxId(), pNode);
  1463.     pIt->AddChild( pNode );
  1464. }
  1465.     }
  1466.     pNode->SetSubtreeLoaded( pNode->IsSubtreeLoaded() ||
  1467.      (levels < 0) );
  1468.                 }
  1469. return true;
  1470.             } else { // Internal: wrong respond type
  1471.                 SetLastError( "Response type is not Taxachildren" );
  1472.                 return false;
  1473.             }
  1474.         } 
  1475.     }
  1476.     return false;
  1477. }
  1479. CRef< ITreeIterator >
  1480. CTaxon1::GetTreeIterator( CTaxon1::EIteratorMode mode )
  1481. {
  1482.     CRef< ITreeIterator > pIt;
  1483.     CTreeConstIterator* pIter = m_plCache->GetTree().GetConstIterator();
  1485.     switch( mode ) {
  1486.     default:
  1487.     case eIteratorMode_FullTree:
  1488. pIt.Reset( new CFullTreeConstIterator( pIter ) );
  1489. break;
  1490.     case eIteratorMode_LeavesBranches:
  1491. pIt.Reset( new CTreeLeavesBranchesIterator( pIter ) );
  1492. break;
  1493.     case eIteratorMode_Best:
  1494. pIt.Reset( new CTreeBestIterator( pIter ) );
  1495. break;
  1496.     case eIteratorMode_Blast:
  1497. pIt.Reset( new CTreeBlastIterator( pIter ) );
  1498. break;
  1499.     }
  1500.     SetLastError(NULL);
  1501.     return pIt;
  1502. }
  1504. CRef< ITreeIterator >
  1505. CTaxon1::GetTreeIterator( int tax_id, CTaxon1::EIteratorMode mode )
  1506. {
  1507.     CRef< ITreeIterator > pIt;
  1508.     CTaxon1Node* pData = 0;
  1509.     SetLastError(NULL);
  1510.     if( m_plCache->LookupAndAdd( tax_id, &pData ) ) {
  1511. pIt = GetTreeIterator( mode );
  1512. if( !pIt->GoNode( pData ) ) {
  1513.     SetLastError( "Iterator in this mode cannot point to the node with"
  1514.   " this tax id" );
  1515.     pIt.Reset( NULL );
  1516. }
  1517.     }
  1518.     return pIt;
  1519. }
  1521. bool
  1522. CTaxon1::GetNodeProperty( int tax_id, const string& prop_name,
  1523.   string& prop_val )
  1524. {
  1525.     SetLastError(NULL);
  1526.     CTaxon1_req req;
  1527.     CTaxon1_resp resp;
  1528.     CRef<CTaxon1_info> pProp( new CTaxon1_info() );
  1530.     CDiagAutoPrefix( "Taxon1::GetNodeProperty" );
  1532.     if( !prop_name.empty() ) {
  1533. pProp->SetIval1( tax_id );
  1534. pProp->SetIval2( -1 ); // Get string property by name
  1535. pProp->SetSval( prop_name );
  1537. req.SetGetorgprop( *pProp );
  1538. try {
  1539.     if( SendRequest( req, resp ) ) {
  1540. if( !resp.IsGetorgprop() ) { // error
  1541.     ERR_POST( "Response type is not Getorgprop" );
  1542. } else {
  1543.     if( resp.GetGetorgprop().size() > 0 ) {
  1544. CRef<CTaxon1_info> pInfo
  1545.     ( resp.GetGetorgprop().front() );
  1546. prop_val.assign( pInfo->GetSval() );
  1547. return true;
  1548.     }
  1549. }
  1550.     } else if( resp.IsError()
  1551.        && resp.GetError().GetLevel() 
  1552.        != CTaxon1_error::eLevel_none ) {
  1553. string sErr;
  1554. resp.GetError().GetErrorText( sErr );
  1555. ERR_POST( sErr );
  1556.     }
  1557. } catch( exception& e ) {
  1558.     ERR_POST( e.what() );
  1559.     SetLastError( e.what() );
  1560. }
  1561.     } else {
  1562. SetLastError( "Empty property name is not accepted" );
  1563. ERR_POST( GetLastError() );
  1564.     }
  1565.     return false;
  1566. }
  1568. bool
  1569. CTaxon1::GetNodeProperty( int tax_id, const string& prop_name,
  1570.   bool& prop_val )
  1571. {
  1572.     SetLastError(NULL);
  1573.     CTaxon1_req req;
  1574.     CTaxon1_resp resp;
  1575.     CRef<CTaxon1_info> pProp( new CTaxon1_info() );
  1577.     CDiagAutoPrefix( "Taxon1::GetNodeProperty" );
  1579.     if( !prop_name.empty() ) {
  1580. pProp->SetIval1( tax_id );
  1581. pProp->SetIval2( -3 ); // Get bool property by name
  1582. pProp->SetSval( prop_name );
  1584. req.SetGetorgprop( *pProp );
  1585. try {
  1586.     if( SendRequest( req, resp ) ) {
  1587. if( !resp.IsGetorgprop() ) { // error
  1588.     ERR_POST( "Response type is not Getorgprop" );
  1589. } else {
  1590.     if( resp.GetGetorgprop().size() > 0 ) {
  1591. CRef<CTaxon1_info> pInfo
  1592.     = resp.GetGetorgprop().front();
  1593. prop_val = pInfo->GetIval2() != 0;
  1594. return true;
  1595.     }
  1596. }
  1597.     } else if( resp.IsError()
  1598.        && resp.GetError().GetLevel() 
  1599.        != CTaxon1_error::eLevel_none ) {
  1600. string sErr;
  1601. resp.GetError().GetErrorText( sErr );
  1602. ERR_POST( sErr );
  1603.     }
  1604. } catch( exception& e ) {
  1605.     ERR_POST( e.what() );
  1606.     SetLastError( e.what() );
  1607. }
  1608.     } else {
  1609. SetLastError( "Empty property name is not accepted" );
  1610. ERR_POST( GetLastError() );
  1611.     }
  1612.     return false;
  1613. }
  1615. bool
  1616. CTaxon1::GetNodeProperty( int tax_id, const string& prop_name,
  1617.   int& prop_val )
  1618. {
  1619.     SetLastError(NULL);
  1620.     CTaxon1_req req;
  1621.     CTaxon1_resp resp;
  1622.     CRef<CTaxon1_info> pProp( new CTaxon1_info() );
  1624.     CDiagAutoPrefix( "Taxon1::GetNodeProperty" );
  1626.     if( !prop_name.empty() ) {
  1627. pProp->SetIval1( tax_id );
  1628. pProp->SetIval2( -2 ); // Get int property by name
  1629. pProp->SetSval( prop_name );
  1631. req.SetGetorgprop( *pProp );
  1632. try {
  1633.     if( SendRequest( req, resp ) ) {
  1634. if( !resp.IsGetorgprop() ) { // error
  1635.     ERR_POST( "Response type is not Getorgprop" );
  1636. } else {
  1637.     if( resp.GetGetorgprop().size() > 0 ) {
  1638. CRef<CTaxon1_info> pInfo
  1639.     = resp.GetGetorgprop().front();
  1640. prop_val = pInfo->GetIval2();
  1641. return true;
  1642.     }
  1643. }
  1644.     } else if( resp.IsError()
  1645.        && resp.GetError().GetLevel() 
  1646.        != CTaxon1_error::eLevel_none ) {
  1647. string sErr;
  1648. resp.GetError().GetErrorText( sErr );
  1649. ERR_POST( sErr );
  1650.     }
  1651. } catch( exception& e ) {
  1652.     ERR_POST( e.what() );
  1653.     SetLastError( e.what() );
  1654. }
  1655.     } else {
  1656. SetLastError( "Empty property name is not accepted" );
  1657. ERR_POST( GetLastError() );
  1658.     }
  1659.     return false;
  1660. }
  1662. //-----------------------------------
  1663. //  Iterator stuff
  1664. //
  1665. // 'Downward' traverse mode (nodes that closer to root processed first)
  1666. ITreeIterator::EAction 
  1667. ITreeIterator::TraverseDownward(I4Each& cb, unsigned levels)
  1668. {
  1669.     if( levels ) {
  1670.         switch( cb.Execute(GetNode()) ) {
  1671.         default:
  1672.         case eOk:
  1673.             if(!IsTerminal()) {
  1674.                 switch( cb.LevelBegin(GetNode()) ) {
  1675.                 case eStop: return eStop;
  1676.                 default:
  1677.                 case eOk:
  1678.                     if(GoChild()) {
  1679.                         do {
  1680.                             if(TraverseDownward(cb, levels-1)==eStop)
  1681.                                 return eStop;
  1682.                         } while(GoSibling());
  1683.                     }
  1684.                 case eSkip: // Means skip this level
  1685.                     break;
  1686.                 }
  1687.                 GoParent();
  1688.                 if( cb.LevelEnd(GetNode()) == eStop )
  1689.                     return eStop;
  1690.             }
  1691.         case eSkip: break;
  1692.         case eStop: return eStop;
  1693.         }
  1694.     }
  1695.     return eOk;
  1696. }
  1698. // 'Upward' traverse mode (nodes that closer to leaves processed first)
  1699. ITreeIterator::EAction
  1700. ITreeIterator::TraverseUpward(I4Each& cb, unsigned levels)
  1701. {
  1702.     if( levels > 0 ) {
  1703.         if(!IsTerminal()) {
  1704.             switch( cb.LevelBegin(GetNode()) ) {
  1705.             case eStop: return eStop;
  1706.             default:
  1707.             case eOk:
  1708.                 if(GoChild()) {
  1709.                     do {
  1710.                         if( TraverseUpward(cb, levels-1) == eStop )
  1711.                             return eStop;
  1712.                     } while(GoSibling());
  1713.                 }
  1714.             case eSkip: // Means skip this level
  1715.                 break;
  1716.             }
  1717.             GoParent();
  1718.             if( cb.LevelEnd(GetNode()) == eStop )
  1719.                 return eStop;
  1720.         }
  1721.         return cb.Execute(GetNode());
  1722.     }
  1723.     return eOk;
  1724. }
  1726. // 'LevelByLevel' traverse (nodes that closer to root processed first)
  1727. ITreeIterator::EAction
  1728. ITreeIterator::TraverseLevelByLevel(I4Each& cb, unsigned levels)
  1729. {
  1730.     switch( cb.Execute( GetNode() ) ) {
  1731.     case eStop:
  1732. return eStop;
  1733.     case eSkip:
  1734. return eSkip;
  1735.     case eOk:
  1736.     default:
  1737. break;
  1738.     }
  1739.     if(!IsTerminal()) {
  1740. vector< const ITaxon1Node* > skippedNodes;
  1741. return TraverseLevelByLevelInternal(cb, levels, skippedNodes);
  1742.     }
  1743.     return eOk;
  1744. }
  1746. ITreeIterator::EAction
  1747. ITreeIterator::TraverseLevelByLevelInternal(I4Each& cb, unsigned levels,
  1748.     vector< const ITaxon1Node* >& skp)
  1749. {
  1750.     size_t skp_start = skp.size();
  1751.     if( levels > 1 ) {
  1752. if(!IsTerminal()) {
  1753.     switch( cb.LevelBegin(GetNode()) ) {
  1754.     case eStop: return eStop;
  1755.     default:
  1756.     case eOk:
  1757. if(GoChild()) {
  1758.     // First pass - call Execute for all children
  1759.     do {
  1760. switch( cb.Execute(GetNode()) ) {
  1761. default:
  1762. case eOk:
  1763.     break;
  1764. case eSkip: // Means skip this node
  1765.     skp.push_back( GetNode() );
  1766.     break;
  1767. case eStop: return eStop;
  1768. }
  1769.     } while( GoSibling() );
  1770.     GoParent();
  1771.     // Start second pass
  1772.     size_t skp_cur = skp_start;
  1773.     GoChild();
  1774.     do {
  1775. if( skp.size() == skp_start ||
  1776.     skp[skp_cur] != GetNode() ) {
  1777.     if(TraverseLevelByLevelInternal(cb, levels-1, skp)
  1778.        == eStop ) {
  1779. return eStop;
  1780.     }
  1781. } else {
  1782.     ++skp_cur;
  1783. }
  1784.     } while(GoSibling());
  1785.     GoParent();
  1786. }
  1787. if( cb.LevelEnd( GetNode() ) == eStop )
  1788.     return eStop;
  1789. break;
  1790.     case eSkip:
  1791. break;
  1792.     }
  1793. }
  1794.     }
  1795.     skp.resize( skp_start );
  1796.     return eOk;
  1797. }
  1799. // Scans all the ancestors starting from immediate parent up to the root
  1800. // (no levelBegin, levelEnd calls performed)
  1801. ITreeIterator::EAction
  1802. ITreeIterator::TraverseAncestors(I4Each& cb)
  1803. {
  1804.     const ITaxon1Node* pNode = GetNode();
  1805.     EAction stat = eOk;
  1806.     while( GoParent() ) {
  1807. stat = cb.Execute(GetNode());
  1808. switch( stat ) {
  1809. case eStop: return eStop; // Stop scan, some error occurred
  1810. default:
  1811. case eOk:
  1812. case eSkip: // Means skip further scan, no error generated
  1813.     break;
  1814. }
  1815. if( stat == eSkip ) {
  1816.     break;
  1817. }
  1818.     }
  1819.     GoNode( pNode );
  1820.     return stat;
  1821. }
  1823. bool
  1824. CTaxon1::CheckOrgRef( const COrg_ref& orgRef, TOrgRefStatus& stat_out )
  1825. {
  1826.     CDiagAutoPrefix( "Taxon1::CheckOrgRef" );
  1827.     SetLastError(NULL);
  1828.     int tax_id;
  1830.     tax_id = GetTaxIdByOrgRef( orgRef );
  1831.     stat_out = eStatus_Ok;
  1833.     if( tax_id == 0 ) {
  1834. SetLastError( "No organism found for specified org_ref" );
  1835. ERR_POST( GetLastError() );
  1836. return false;
  1837.     } else if( tax_id < 0 ) {
  1838. SetLastError( "Multiple organisms found for specified org_ref" );
  1839. ERR_POST( GetLastError() );
  1840. return false;
  1841.     } else {
  1842. CRef< CTaxon2_data > pData( GetById( tax_id ) );
  1843. if( pData ) {
  1844.     // Compare orgrefs
  1845.     const COrg_ref& goodOr = pData->GetOrg();
  1847.     if( !orgRef.IsSetOrgname() ) {
  1848. stat_out |= eStatus_NoOrgname;
  1849.     } else {
  1850. const COrgName& goodOn = goodOr.GetOrgname();
  1851. const COrgName& inpOn = orgRef.GetOrgname();
  1853. if( !inpOn.IsSetGcode() || !goodOn.IsSetGcode() ||
  1854.     inpOn.GetGcode() != goodOn.GetGcode() ) {
  1855.     stat_out |= eStatus_WrongGC;
  1856. }
  1857. if( !inpOn.IsSetMgcode() ) { // mgc not set in input
  1858.     if( goodOn.IsSetMgcode() &&
  1859. goodOn.GetMgcode() != 0 ) {
  1860. stat_out |= eStatus_WrongMGC;
  1861.     }
  1862. } else { // mgc set
  1863.     if( !goodOn.IsSetMgcode() ) {
  1864. if( inpOn.GetMgcode() != 0 ) { // not unassigned
  1865.     stat_out |= eStatus_WrongMGC;
  1866. }
  1867.     } else if( inpOn.GetMgcode() != goodOn.GetMgcode() ) {
  1868. stat_out |= eStatus_WrongMGC;
  1869.     }
  1870. }
  1871. if( !inpOn.IsSetLineage() || !goodOn.IsSetLineage() ||
  1872.     inpOn.GetLineage().compare( goodOn.GetLineage() ) != 0 ) {
  1873.     stat_out |= eStatus_WrongLineage;
  1874. }
  1875. if( !inpOn.IsSetName() || !goodOn.IsSetName() ||
  1876.     inpOn.GetName().Which() != goodOn.GetName().Which() ) {
  1877.     stat_out |= eStatus_WrongOrgname;
  1878. }
  1879. if( !inpOn.IsSetDiv() ) {
  1880.     if( goodOn.IsSetDiv() &&
  1881. goodOn.GetDiv().compare( "UNA" ) != 0 ) {
  1882. stat_out |= eStatus_WrongDivision;
  1883.     }
  1884. } else {
  1885.     if( !goodOn.IsSetDiv() ) {
  1886. if( inpOn.GetDiv().compare( "UNA" ) != 0 ) {
  1887.     stat_out |= eStatus_WrongDivision;
  1888. }
  1889.     } else if( inpOn.GetDiv().compare( goodOn.GetDiv() )
  1890.        != 0 ) {
  1891. stat_out |= eStatus_WrongDivision;
  1892.     }
  1893. }
  1894. if( goodOn.IsSetMod() ) {
  1895.     if( inpOn.IsSetMod() ) {
  1896. const COrgName::TMod& inpMods = inpOn.GetMod();
  1897. const COrgName::TMod& goodMods = goodOn.GetMod();
  1898. for( COrgName::TMod::const_iterator gi =
  1899.  goodMods.begin();
  1900.      gi != goodMods.end();
  1901.      ++gi ) {
  1902.     bool bFound = false;
  1903.     for( COrgName::TMod::const_iterator ii = 
  1904.      inpMods.begin();
  1905.  ii != inpMods.end();
  1906.  ++ii ) {
  1907. if( (*gi)->GetSubtype() == (*ii)->GetSubtype()
  1908.     && ((*gi)->GetSubname() ==
  1909. (*ii)->GetSubname()) ) {
  1910.     bFound = true;
  1911.     break;
  1912. }
  1913.     }
  1914.     if( !bFound ) {
  1915. stat_out |= eStatus_WrongOrgmod;
  1916. break;
  1917.     }
  1918. }
  1919.     } else {
  1920. stat_out |= eStatus_WrongOrgmod;
  1921.     }
  1922. }
  1923.     }
  1924.     // Check taxname
  1925.     if( orgRef.IsSetTaxname() ) {
  1926. if( !goodOr.IsSetTaxname() ||
  1927.     orgRef.GetTaxname().compare( goodOr.GetTaxname() ) != 0 ) {
  1928.     stat_out |= eStatus_WrongTaxname;
  1929. }
  1930.     } else if( goodOr.IsSetTaxname() ) {
  1931. stat_out |= eStatus_WrongTaxname;
  1932.     }
  1933.     // Check common name
  1934.     if( orgRef.IsSetCommon() ) {
  1935. if( !goodOr.IsSetCommon() ||
  1936.     orgRef.GetCommon().compare( goodOr.GetCommon() ) != 0 ) {
  1937.     stat_out |= eStatus_WrongCommonName;
  1938. }
  1939.     } else if( goodOr.IsSetCommon() ) {
  1940. stat_out |= eStatus_WrongCommonName;
  1941.     }
  1942. } else { // Internal error: Cannot find orgref by tax_id
  1943.     SetLastError( "No organisms found for tax id" );
  1944.     ERR_POST( GetLastError() );
  1945.     return false;
  1946. }
  1947.     }
  1948.     return true;
  1949. }
  1951. END_objects_SCOPE
  1952. END_NCBI_SCOPE
  1956. /*
  1957.  * $Log: taxon1.cpp,v $
  1958.  * Revision 1000.3  2004/06/01 19:35:15  gouriano
  1959.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.25
  1960.  *
  1961.  * Revision 6.25  2004/05/19 17:27:10  gorelenk
  1962.  * Added include of PCH - ncbi_pch.hpp
  1963.  *
  1964.  * Revision 6.24  2004/04/01 14:14:02  lavr
  1965.  * Spell "occurred", "occurrence", and "occurring"
  1966.  *
  1967.  * Revision 6.23  2004/03/12 20:07:24  domrach
  1968.  * CheckOrgRef() function added for checking the user orgref against the orgref from Taxonomy db
  1969.  *
  1970.  * Revision 6.22  2004/02/04 16:14:44  domrach
  1971.  * New iterator types (modes of operation) are introduced. They include:
  1972.  * full tree, branches'n'leaves, best, and blast. Position inquiry f-ns
  1973.  * IsTerminal(), IsFirstChild(), and IsLastChild() has been moved from
  1974.  * ITreeNode to ITreeIterator. Node loading f-ns() now return the ITreeNode
  1975.  * for tax id.
  1976.  *
  1977.  * Revision 6.21  2003/11/20 15:42:19  ucko
  1978.  * Update for new (saner) treatment of ASN.1 NULLs.
  1979.  *
  1980.  * Revision 6.20  2003/11/18 17:50:51  dicuccio
  1981.  * Rearranged #include statements to avoid warning on MSVC
  1982.  *
  1983.  * Revision 6.19  2003/10/23 18:52:47  domrach
  1984.  * Unique name bug fixed
  1985.  *
  1986.  * Revision 6.18  2003/07/09 15:41:31  domrach
  1987.  * SearchTaxIdByName(), GetNameClass(), and GetNodeProperty() functions added
  1988.  *
  1989.  * Revision 6.17  2003/06/23 20:42:08  domrach
  1990.  * New treatment of subspecies names introduced
  1991.  *
  1992.  * Revision 6.16  2003/06/05 20:44:02  domrach
  1993.  * Adjusted to the new CanGetXxx verification methods
  1994.  *
  1995.  * Revision 6.15  2003/05/06 19:53:54  domrach
  1996.  * New functions and interfaces for traversing the cached partial taxonomy tree introduced. Convenience functions GetDivisionName() and GetRankName() were added
  1997.  *
  1998.  * Revision 6.14  2003/03/10 20:59:37  ucko
  1999.  * ThrowError1 -> ThrowError, per the recent change to <serial/objostr.hpp>.
  2000.  * Explicitly cast ints to COrgMod::TSubtype when setting OrgMod.subtype.
  2001.  *
  2002.  * Revision 6.13  2003/03/05 21:33:52  domrach
  2003.  * Enhanced orgref processing. Orgref cache capacity control added.
  2004.  *
  2005.  * Revision 6.12  2003/01/31 03:46:46  lavr
  2006.  * Heed int->bool performance warnings
  2007.  *
  2008.  * Revision 6.11  2003/01/21 19:38:59  domrach
  2009.  * GetPopsetJoin() member function optimized to copy partial tree from cached tree
  2010.  *
  2011.  * Revision 6.10  2003/01/10 19:58:46  domrach
  2012.  * Function GetPopsetJoin() added to CTaxon1 class
  2013.  *
  2014.  * Revision 6.9  2002/11/08 20:55:58  ucko
  2015.  * CConstRef<> now requires an explicit constructor.
  2016.  *
  2017.  * Revision 6.8  2002/11/08 14:39:52  domrach
  2018.  * Member function GetSuperkingdom() added
  2019.  *
  2020.  * Revision 6.7  2002/11/04 21:29:18  grichenk
  2021.  * Fixed usage of const CRef<> and CRef<> constructor
  2022.  *
  2023.  * Revision 6.6  2002/08/06 16:12:34  domrach
  2024.  * Merging of modifiers is now performed in LookupMerge
  2025.  *
  2026.  * Revision 6.5  2002/07/25 15:01:56  grichenk
  2027.  * Replaced non-const GetXXX() with SetXXX()
  2028.  *
  2029.  * Revision 6.4  2002/02/14 22:44:50  vakatov
  2030.  * Use STimeout instead of time_t.
  2031.  * Get rid of warnings and extraneous #include's, shuffled code a little.
  2032.  *
  2033.  * Revision 6.3  2002/01/31 00:31:26  vakatov
  2034.  * Follow the renaming of "CTreeCont.hpp" to "ctreecont.hpp".
  2035.  * Get rid of "std::" which is unnecessary and sometimes un-compilable.
  2036.  * Also done some source identation/beautification.
  2037.  *
  2038.  * Revision 6.2  2002/01/30 16:13:38  domrach
  2039.  * Changes made to pass through MSVC compiler. Some src files renamed
  2040.  *
  2041.  * Revision 6.1  2002/01/28 19:56:10  domrach
  2042.  * Initial checkin of the library implementation files
  2043.  *
  2044.  * ===========================================================================
  2045.  */