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

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

生物技术

开发平台：

C/C++

cache.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: cache.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:35:08  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.21
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: cache.cpp,v 1000.3 2004/06/01 19:35:08 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 caching implementation
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <objects/taxon1/taxon1.hpp>
  44. #include "cache.hpp"
  46. #include <vector>
  47. #include <algorithm>
  49. BEGIN_NCBI_SCOPE
  50. BEGIN_objects_SCOPE
  53. COrgRefCache::COrgRefCache( CTaxon1& host )
  54.     : m_host( host ), m_nCacheCapacity( 10 )
  55. {
  56.     return;
  57. }
  59. bool
  60. COrgRefCache::Init( unsigned nCapacity )
  61. {
  62.     CTaxon1_req  req;
  63.     CTaxon1_resp resp;
  65.     req.SetMaxtaxid();
  67.     if( m_host.SendRequest( req, resp ) ) {
  68.         if( resp.IsMaxtaxid() ) {
  69.             // Correct response, return object
  70.             m_nMaxTaxId = resp.GetMaxtaxid();
  71.             m_nMaxTaxId += m_nMaxTaxId/10;
  72.             m_ppEntries = new CTaxon1Node*[m_nMaxTaxId];
  73.             memset( m_ppEntries, '', m_nMaxTaxId*sizeof(*m_ppEntries) );
  74.         } else { // Internal: wrong respond type
  75.             m_host.SetLastError( "Response type is not Maxtaxid" );
  76.             return false;
  77.         }
  78.     } else {
  79.         return false;
  80.     }
  81.     CTaxon1_name* pNode = ( new CTaxon1_name );
  82.     pNode->SetTaxid( 1 );
  83.     pNode->SetOname().assign("root");
  84.     pNode->SetCde( 0x40000000 ); // Gene bank hidden
  85.     CTaxon1Node* pRoot = new CTaxon1Node( CRef<CTaxon1_name>(pNode) );
  86.     m_tPartTree.SetRoot( pRoot );
  87.     SetIndexEntry( 1, pRoot );
  89.     if( nCapacity != 0 ) {
  90. m_nCacheCapacity = nCapacity;
  91.     }
  92.     InitRanks();
  93.     InitDivisions();
  94.     return true;
  95. }
  97. bool
  98. COrgRefCache::Lookup( int tax_id, CTaxon1Node** ppNode )
  99. {
  100.     if( (unsigned)tax_id < m_nMaxTaxId ) {
  101.         *ppNode = m_ppEntries[tax_id];
  102.     } else {
  103. *ppNode = NULL;
  104.     }
  105.     return *ppNode != NULL;
  106. }
  108. bool
  109. COrgRefCache::LookupAndAdd( int tax_id, CTaxon1Node** ppData )
  110. {
  111.     *ppData = NULL;
  112.     if( (unsigned)tax_id < m_nMaxTaxId ) {
  113.         CTaxon1Node* pNode = ( m_ppEntries[tax_id] );
  114.         if( pNode ) {
  115.             *ppData = pNode;
  116.             return true;
  117.         } else { // Add the entry from server
  118.             CTaxon1_req  req;
  119.             CTaxon1_resp resp;
  121.             req.SetTaxalineage( tax_id );
  123.             if( m_host.SendRequest( req, resp ) ) {
  124.                 if( resp.IsTaxalineage() ) {
  125.                     // Correct response, return object
  126.                     list< CRef<CTaxon1_name> >& lLin = resp.SetTaxalineage();
  127.                     CTaxon1Node* pParent = 0;
  128.                     pNode   = 0;
  129.     // Check if this is a secondary node
  130.     if( lLin.front()->GetTaxid() != tax_id ) {
  131. // Secondary node, try to get primary from index
  132. pNode = m_ppEntries[ lLin.front()->GetTaxid() ];
  133.     }
  134.     if( !pNode ) {
  135. list< CRef< CTaxon1_name > >::reverse_iterator i;
  136. // Fill in storage
  137. for( i = lLin.rbegin(); i != lLin.rend(); ++i ) {
  138.     if( !m_ppEntries[ (*i)->GetTaxid() ] ) {
  139. // Create node
  140. break;
  141.     } else {
  142. pParent = m_ppEntries[ (*i)->GetTaxid() ];
  143.     }
  144. }
  145. // Create tree iterator
  146. CTreeIterator* pIt = ( m_tPartTree.GetIterator() );
  147. if( !pParent ) {
  148.     pParent = static_cast<CTaxon1Node*>(pIt->GetNode());
  149. }
  150. pIt->GoNode( pParent );
  151. for( ; i != lLin.rend(); ++i ) {
  152.     pNode = new CTaxon1Node(*i);
  153.     m_ppEntries[ pNode->GetTaxId() ] = pNode;
  154.     pIt->AddChild( pNode );
  155.     pIt->GoNode( pNode );
  156. }
  157.     } else { // Store secondary in index
  158. m_ppEntries[ tax_id ] = pNode;
  159.     }
  160.     _ASSERT( pNode );
  161.                     *ppData = pNode;
  162.                     return true;
  163.                 } else { // Internal: wrong respond type
  164.                     m_host.SetLastError( "Unable to get node lineage:
  165.  Response type is not Taxalineage" );
  166.                     return false;
  167.                 }
  168.             }
  169.         }
  170.     }
  171.     return false;
  172. }
  174. bool
  175. COrgRefCache::LookupAndInsert( int tax_id, CTaxon1_data** ppData )
  176. {
  177.     CTaxon1Node* pNode = ( NULL );
  178.     *ppData = NULL;
  180.     if( LookupAndAdd( tax_id, &pNode ) && pNode ) {
  181.         SCacheEntry* pEntry = ( pNode->GetEntry() );
  182.         if( !pEntry ) {
  183.             if( !Insert1( *pNode ) )
  184.                 return false;
  185.             pEntry = pNode->GetEntry();
  186.         } else {
  187.             m_lCache.remove( pEntry );
  188.             m_lCache.push_front( pEntry );
  189.         }
  190.         *ppData = pEntry->GetData1();
  191.         return true;
  192.     }
  193.     return false;
  194. }
  196. bool
  197. COrgRefCache::LookupAndInsert( int tax_id, CTaxon2_data** ppData )
  198. {
  199.     CTaxon1Node* pNode = ( NULL );
  200.     *ppData = NULL;
  202.     if( LookupAndAdd( tax_id, &pNode ) && pNode ) {
  203.         SCacheEntry* pEntry = ( pNode->GetEntry() );
  204.         if( !pEntry ) {
  205.             if( !Insert2( *pNode ) )
  206.                 return false;
  207.             pEntry = pNode->GetEntry();
  208.         } else {
  209.             m_lCache.remove( pEntry );
  210.             m_lCache.push_front( pEntry );
  211.         }
  212.         *ppData = pEntry->GetData2();
  213.         return true;
  214.     }
  215.     return false;
  216. }
  218. bool
  219. COrgRefCache::Lookup( int tax_id, CTaxon1_data** ppData )
  220. {
  221.     if( (unsigned)tax_id < m_nMaxTaxId ) {
  222.         CTaxon1Node* pNode = ( m_ppEntries[tax_id] );
  223.         SCacheEntry* pEntry;
  224.         if( pNode && (pEntry=pNode->GetEntry()) ) {
  225.             // Move in the list
  226.             m_lCache.remove( pEntry );
  227.             m_lCache.push_front( pEntry );
  228.             *ppData = pEntry->GetData1();
  229.             return true;
  230.         }
  231.     }
  232.     *ppData = NULL;
  233.     return false;
  234. }
  236. bool
  237. COrgRefCache::Lookup( int tax_id, CTaxon2_data** ppData )
  238. {
  239.     if( (unsigned)tax_id < m_nMaxTaxId ) {
  240.         CTaxon1Node* pNode = ( m_ppEntries[tax_id] );
  241.         SCacheEntry* pEntry;
  242.         if( pNode && (pEntry=pNode->GetEntry()) ) {
  243.             // Move in the list
  244.             m_lCache.remove( pEntry );
  245.             m_lCache.push_front( pEntry );
  246.             *ppData = pEntry->GetData2();
  247.             return true;
  248.         }
  249.     }
  250.     *ppData = NULL;
  251.     return false;
  252. }
  254. bool
  255. s_BuildLineage( string& str, CTaxon1Node* pNode, unsigned sz, int sp_rank )
  256. {
  257.     if( !pNode->IsRoot() ) {
  258.         if( pNode->GetRank() > sp_rank-1 ) {
  259.             s_BuildLineage( str, pNode->GetParent(), 0, sp_rank );
  260.             return false;
  261.         } else {
  262.             if( pNode->IsGenBankHidden() ) {
  263.                 return s_BuildLineage( str, pNode->GetParent(), sz, sp_rank );
  264.             }
  265.             bool bCont;
  266.             bCont=s_BuildLineage( str, pNode->GetParent(),
  267.                                   sz+pNode->GetName().size()+2, sp_rank );
  268.             if( bCont ) {
  269.                 str.append( pNode->GetName() );
  270. if( sz != 0 ) {
  271.     str.append( "; " );
  272. }
  273.             }
  274.             return bCont;
  275.         }
  276.     } else {
  277.         str.reserve( sz );
  278.     }
  279.     return true;
  280. }
  282. string::size_type
  283. s_AfterPrefix( const string& str1, const string& prefix )
  284. {
  285.     string::size_type pos(0);
  286.     if( NStr::StartsWith( str1, prefix ) ) {
  287.         pos += prefix.size();
  288.     }
  289.     return str1.find_first_not_of( " tnr", pos );
  290. }
  292. static const char s_achSubsp[] = "subsp.";
  293. static const char s_achSsp[] = "ssp.";
  294. static const char s_achF_Sp[] = "f. sp.";
  295. static const char s_achFSp[] = "f.sp.";
  296. static const char s_achStr[] = "str.";
  297. static const char s_achSubstr[] = "substr.";
  298. static const char s_achVar[] = "var.";
  299. static const char s_achSv[] = "sv.";
  300. static const char s_achCv[] = "cv.";
  301. static const char s_achPv[] = "pv.";
  302. static const char s_achBv[] = "bv.";
  303. static const char s_achF[] = "f.";
  304. static const char s_achFo[] = "fo.";
  305. static const char s_achGrp[] = "grp.";
  307. struct SSubtypeAbbr {
  308.     const char*       m_pchAbbr;
  309.     size_t            m_nAbbrLen;
  310.     COrgMod::ESubtype m_eSubtype;
  311. };
  314. static SSubtypeAbbr s_aSubtypes[] = {
  315.     { s_achSubsp, sizeof(s_achSubsp)-1, COrgMod::eSubtype_sub_species },
  316.     { s_achSsp,   sizeof(s_achSsp)-1,   COrgMod::eSubtype_sub_species },
  317.     { s_achF_Sp,  sizeof(s_achF_Sp)-1,  COrgMod::eSubtype_forma_specialis },
  318.     { s_achFSp,   sizeof(s_achFSp)-1,   COrgMod::eSubtype_forma_specialis },
  319.     { s_achStr,   sizeof(s_achStr)-1,   COrgMod::eSubtype_strain },
  320.     { s_achSubstr,sizeof(s_achSubstr)-1,COrgMod::eSubtype_substrain },
  321.     { s_achVar,   sizeof(s_achVar)-1,   COrgMod::eSubtype_variety },
  322.     { s_achSv,    sizeof(s_achSv)-1,    COrgMod::eSubtype_serovar },
  323.     { s_achCv,    sizeof(s_achCv)-1,    COrgMod::eSubtype_cultivar },
  324.     { s_achPv,    sizeof(s_achPv)-1,    COrgMod::eSubtype_pathovar },
  325.     { s_achBv,    sizeof(s_achBv)-1,    COrgMod::eSubtype_biovar },
  326.     { s_achF,     sizeof(s_achF)-1,     COrgMod::eSubtype_forma },
  327.     { s_achFo,    sizeof(s_achFo)-1,    COrgMod::eSubtype_forma },
  328.     { s_achGrp,   sizeof(s_achGrp)-1,   COrgMod::eSubtype_group },
  329.     { NULL,       0,                    COrgMod::eSubtype_other }
  330. };
  332. static int
  333. s_NofTokens( const string& s )
  334. {
  335.     int nof = 0;
  336.     char first, last, c;
  337.     int bracket_level, token;
  339.     if( !s.empty() ) {
  340. string::size_type pos = 0;
  341. while( pos < s.size() ) {
  342.     bracket_level= 0;
  343.     token = 0;
  345.     do { // Skip heading white space
  346. first= s[pos++];
  347.     } while( (isspace(first) || iscntrl(first)) &&
  348.      pos < s.size() );
  349.     
  350.     switch( first ) {
  351.     case '"': last= '"'; break;
  352.     case '(': last= ')'; break;
  353.     case '{': last= '}'; break;
  354.     case '[': last= ']'; break;
  355.     default:  last= 0;   break;
  356.     }
  358.     for(; pos < s.size(); ++pos) {
  359. c = s[pos];
  360. if( !isalnum(c) ) {
  361.     if( last == 0 ) {
  362. if( first == c ) {
  363.     ++bracket_level;
  364. }
  365. if( last == c && (!bracket_level--) ) {
  366.     ++pos;
  367.     break;
  368. }
  369.     } else {
  370. if( c == '.' || isspace(c) || iscntrl(c) ) {
  371.     ++pos;
  372.     break;
  373. }
  374.     }
  375. } else {
  376.     token = 1;
  377. }
  378.     }
  379.     nof += token;
  380. }
  381.     }            
  382.     return nof;
  383. }
  385. COrgMod::ESubtype
  386. COrgRefCache::GetSubtypeFromName( string& sName )
  387. {
  388.     static const string s_sSubspCf( "subsp. cf." );
  389.     static const string s_sSubspAff( "subsp. aff." );
  391.     string::size_type pos;
  392.     if( sName.find('.') == string::npos ) {
  393. return COrgMod::eSubtype_other;
  394.     }
  395.     /* ignore subsp. cf. and subsp. aff. */
  396.     if( NStr::FindNoCase( sName, s_sSubspCf ) != string::npos ) {
  397. return COrgMod::eSubtype_other;
  398.     }
  399.     if( NStr::FindNoCase( sName, s_sSubspAff ) != string::npos ) {
  400. return COrgMod::eSubtype_other;
  401.     }
  403.     /* check for subsp */
  404.     SSubtypeAbbr* pSubtypeAbbr = &s_aSubtypes[0];
  405.     while( pSubtypeAbbr->m_eSubtype != COrgMod::eSubtype_other ) {
  406. if( (pos=NStr::FindNoCase( sName,
  407.        string(pSubtypeAbbr->m_pchAbbr,
  408.       pSubtypeAbbr->m_nAbbrLen) )) != NPOS ) {
  409.     sName.erase( pos, pSubtypeAbbr->m_nAbbrLen );
  410.     sName = NStr::TruncateSpaces( sName, NStr::eTrunc_Begin );
  411.     if( pSubtypeAbbr->m_eSubtype == COrgMod::eSubtype_sub_species
  412. && s_NofTokens( sName ) != 1 ) {
  413. break; // Return other
  414.     }
  415.     return pSubtypeAbbr->m_eSubtype;
  416. }
  417. ++pSubtypeAbbr;
  418.     }
  419.     return COrgMod::eSubtype_other;
  420. }
  422. bool
  423. COrgRefCache::BuildOrgModifier( CTaxon1Node* pNode,
  424.                                 COrgName& on,
  425.                                 CTaxon1Node* pParent )
  426. {
  427.     CTaxon1Node* pTmp;
  428.     CRef<COrgMod> pMod( new COrgMod );
  430.     if( !pParent && !pNode->IsRoot() ) {
  431.         pTmp = pNode->GetParent();
  432.         while( !pTmp->IsRoot() ) {
  433.             int prank = pTmp->GetRank();
  434.             if((prank == GetSubspeciesRank()) || 
  435.                (prank == GetSpeciesRank()) ||
  436.                (prank == GetGenusRank())) {
  437.                 pParent = pTmp;
  438.                 break;
  439.             }
  440.             pTmp = pTmp->GetParent();
  441.         }
  442.     }
  443.     string::size_type pos = 0;
  444.     if( pParent ) { // Get rid of parent prefix
  445.         pos = s_AfterPrefix( pNode->GetName(),
  446.                              pParent->GetName() );
  447.     }
  448.     pMod->SetSubname().assign( pNode->GetName(), pos,
  449.                                pNode->GetName().size()-pos );
  451.     pMod->SetSubtype( GetSubtypeFromName( pMod->SetSubname() ) );
  453.     if( pMod->GetSubtype() == COrgMod_Base::eSubtype_sub_species &&
  454. pNode->GetRank() != GetSubspeciesRank() ) {
  455.         pMod->SetSubtype( COrgMod_Base::eSubtype_other );
  456.     }
  458.     if( pMod->GetSubtype() == COrgMod_Base::eSubtype_other ) {
  459. int rank = pNode->GetRank();
  460. if( rank == GetSubspeciesRank() ) {
  461.             if( s_NofTokens( pNode->GetName() ) == 3 ) {
  462. // Assign only "Name1 ssp. Name2" or "Name1 subsp. Name2"  
  463. pMod->SetSubtype( COrgMod_Base::eSubtype_sub_species );
  464.     }
  465. } else if( rank == GetVarietyRank() ) {
  466.     pMod->SetSubtype( COrgMod_Base::eSubtype_variety );
  467. } else if( rank == GetFormaRank() ) {
  468.     pMod->SetSubtype( COrgMod_Base::eSubtype_forma );
  469. } else if( pParent && pParent->GetRank() == GetSubspeciesRank() ) {
  470.     pMod->SetSubtype( COrgMod_Base::eSubtype_strain );
  471. } else { // Do not insert invalid modifier
  472.     return false;
  473. }
  474.     }
  475.     // Store it into list
  476.     on.SetMod().push_back( pMod );
  478.     return true;
  479. }
  481. bool
  482. COrgRefCache::SetBinomialName( CTaxon1Node& node, COrgName& on )
  483. {
  484.     CTaxon1Node* pSpec = ( NULL );
  485.     CTaxon1Node* pSubspec = ( NULL );
  486.     CTaxon1Node* pGenus = ( NULL );
  487.     CTaxon1Node* pSubgen = ( NULL );
  488.     CTaxon1Node* pNode = ( &node );
  489.     string::size_type pos(0);
  490.     do {
  491.         int rank( pNode->GetRank() );
  492.         if( rank == GetSubspeciesRank())
  493.             pSubspec = pNode;
  494.         else if( rank == GetSpeciesRank())
  495.             pSpec = pNode;
  496.         else if( rank == GetSubgenusRank())
  497.             pSubgen = pNode;
  498.         else if(rank == GetGenusRank()) {
  499.             pGenus = pNode;
  500.             break;
  501.         }
  502.         pNode = pNode->GetParent();
  503.     } while( pNode && !pNode->IsRoot() );
  504.     pNode = &node;
  506.     if( !pGenus ) {
  507.         if( !pSubgen )
  508.             return false;
  509.         else
  510.             pGenus = pSubgen;
  511.     }
  512.     CBinomialOrgName& bon = ( on.SetName().SetBinomial() );
  514.     bon.SetGenus( pGenus->GetName() );
  516.     if( pSpec ) { // we have a species in lineage
  517.         bon.SetSpecies().assign( pSpec->GetName(),
  518.                                  pos=s_AfterPrefix( pSpec->GetName(),
  519.                                                     pGenus->GetName() ),
  520.                                  pSpec->GetName().size() - pos );
  522.         if( pSubspec ) { // we also have a subspecies in lineage
  523.             bon.SetSubspecies().assign( pSubspec->GetName(),
  524.                                         pos=s_AfterPrefix(pSubspec->GetName(),
  525.                                                           pSpec->GetName()),
  526.                                         pSubspec->GetName().size() - pos );
  527.         }
  528.         if( pNode != pSpec ) {
  529.             BuildOrgModifier( pNode, on );
  530.         }
  531.         return true;
  532.     }
  533.     // no species in lineage
  534.     if( pSubspec ) { // we have no species but we have subspecies
  535.         bon.SetSubspecies().assign( pSubspec->GetName(),
  536.                                     pos=s_AfterPrefix(pSubspec->GetName(),
  537.                                                       pGenus->GetName()),
  538.                                     pSubspec->GetName().size() - pos );
  539.         BuildOrgModifier( pNode, on,
  540.                           pNode==pSubspec ? pGenus : pSubspec );
  541.         return true;
  542.     }
  543.   
  544.     // we have no species, no subspecies
  545.     // but we are under species level (varietas or forma)
  546.     BuildOrgModifier( pNode, on, pGenus );
  547.     return true;
  548. }
  550. bool
  551. COrgRefCache::SetPartialName( CTaxon1Node& node, COrgName& on )
  552. {
  553.     CTaxElement* pTaxElem = ( new CTaxElement );
  554.     int rank_id= node.GetRank();
  555.     
  556.     CPartialOrgName& pon = ( on.SetName().SetPartial() );
  557.     pon.Set().push_back(CRef<CTaxElement>(pTaxElem));
  559.     if( rank_id == GetFamilyRank()) {
  560.         pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_family );
  561.     }
  562.     else if(rank_id == GetOrderRank()) {
  563.         pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_order );
  564.     }
  565.     else if(rank_id == GetClassRank()) {
  566.         pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_class );
  567.     }
  568.     else {
  569.         pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_other );
  570.         pTaxElem->SetLevel( GetRankName( rank_id ) );
  571.     }
  572.     pTaxElem->SetName( node.GetName() );
  573.     return true;
  574. }
  576. bool
  577. COrgRefCache::BuildOrgRef( CTaxon1Node& node, COrg_ref& org, bool& is_species )
  578. {
  579.     // Init ranks here
  580.     if( !InitRanks() || !InitNameClasses() || !InitDivisions() )
  581.         return false;
  583.     CTaxon1_req  req;
  584.     CTaxon1_resp resp;
  586.     req.SetGetorgnames( node.GetTaxId() );
  588.     if( m_host.SendRequest( req, resp ) ) {
  589.         if( resp.IsGetorgnames() ) {
  590.             // Correct response, return object
  591.             list< CRef< CTaxon1_name > >&
  592.                 lLin = ( resp.SetGetorgnames() );
  593.             // Save taxname
  594.             org.SetTaxname().swap( lLin.front()->SetOname() );
  595.             lLin.pop_front();
  597.             list< CRef< CTaxon1_name > >::iterator i;
  598.             // Find preferred common name
  599.             int pref_cls = GetPreferredCommonNameClass();
  600.             for( i = lLin.begin(); i != lLin.end(); ++i ) {
  601.                 if( (*i)->CanGetCde() && (*i)->GetCde() == pref_cls ) {
  602.                     org.SetCommon().swap( (*i)->SetOname() );
  603.                     lLin.erase( i );
  604.                     break;
  605.                 }
  606.             }
  607.             int syn_cls(GetSynonymNameClass());
  608.             int comm_cls(GetCommonNameClass());
  609.             for( i = lLin.begin(); i != lLin.end(); ++i ) {
  610. if( (*i)->CanGetCde() ) {
  611.     int cls = (*i)->GetCde();
  612.     if( cls == syn_cls || cls == comm_cls ) {
  613. org.SetSyn().push_back( (*i)->GetOname() );
  614.     }
  615. }
  616.             }
  617.             // Set taxid as db tag
  618.             org.SetTaxId( node.GetTaxId() );
  620.             COrgName& on = ( org.SetOrgname() );
  622.             short div_id( node.GetDivision() );
  623.             if( GetDivisionCode( div_id ) ) {
  624.                 on.SetDiv( GetDivisionCode( div_id ) );
  625.             }
  626.             on.SetGcode( node.GetGC() );
  627.     if( node.GetMGC() > 0 ) {
  628. on.SetMgcode( node.GetMGC() );
  629.     }
  630.             // Build lineage
  631.             CTaxon1Node* pNode;
  632.             if( !node.IsRoot() ) {
  633.                 pNode = node.GetParent();
  634. on.SetLineage(kEmptyStr);
  635.                 s_BuildLineage( on.SetLineage(), pNode, 0,
  636. GetSpeciesRank() );
  637.                 if( on.GetLineage().empty() ) {
  638.                     on.ResetLineage();
  639. }
  640.             }
  641.             // Set rank
  642.             int rank_id( node.GetRank() );
  644.             is_species = (rank_id >= GetSpeciesRank());
  645.             // correct level by lineage if node has no rank
  646.             if( rank_id < 0 && !node.IsRoot() ) {
  647.                 pNode = node.GetParent();
  648.                 while( !pNode->IsRoot() ) {
  649.                     int rank( pNode->GetRank() );
  650.                     if(rank >= 0) {
  651.                         is_species= (rank >= GetSpeciesRank()-1);
  652.                         break;
  653.                     }
  654.                     pNode = pNode->GetParent();
  655.                 }
  656.             }
  657.             // Create name
  658.             if(is_species) {
  659.                 /* we are on species level or below */
  660.      
  661.                 /* check for viruses */
  662.                 if( div_id == GetVirusesDivision()
  663.                     || div_id == GetPhagesDivision() ) {
  664.                     /* this is a virus */
  665.                     /* virus */
  666.                     if( rank_id == GetSpeciesRank() ) {
  667.                         /* we are on species level */
  668.                         on.SetName().SetVirus( node.GetName() );
  669.                     } else {
  670.                         /* we are below species */
  671.                         /* first try to find species or min rank which
  672.                            below species but above us */
  673.                         pNode = 0;
  674.                         CTaxon1Node* pTmp = ( node.GetParent() );
  676.                         while( pTmp && !pTmp->IsRoot() ) {
  677.                             int rank(pTmp->GetRank());
  678.                             if( rank >= GetSpeciesRank() ) {
  679.                                 pNode = pTmp;
  680.                                 if( rank == GetSpeciesRank() )
  681.                                     break;
  682.                             } else if( rank >= 0 )
  683.                                 break;
  684.                             pTmp = pTmp->GetParent();
  685.                         }
  686.                         if( !pNode ) {// we have species or something above us
  687.                             pNode = &node;
  688.                         }
  689.                         on.SetName().SetVirus( pNode->GetName() );
  690.                         // Add modifier to orgname
  691.                         BuildOrgModifier( &node, on );
  692.                     } // non species rank
  693.                 } else if( !SetBinomialName( node, on ) ) {
  694.                     // name is not binomial: set partial
  695.                     SetPartialName( node, on );
  696.                 }
  697.             } else { // above species
  698.                 SetPartialName( node, on );
  699.             }
  700.     // Add some genbank names as organism modifiers
  701.     if( org.IsSetOrgname() ) { // OrgName is not empty
  702. for( i = lLin.begin(); i != lLin.end(); ++i ) {
  703.     if( (*i)->CanGetCde() ) {
  704. int cde = (*i)->GetCde();
  705. COrgMod::ESubtype stype = (COrgMod::ESubtype)0;
  706. if( cde == GetGBAcronymNameClass() ) {
  707.     stype = COrgMod::eSubtype_gb_acronym;
  708. } else if( cde == GetGBSynonymNameClass() ) {
  709.     stype = COrgMod::eSubtype_gb_synonym;
  710. } else if( cde == GetGBAnamorphNameClass() ) {
  711.     stype = COrgMod::eSubtype_gb_anamorph;
  712. }
  713. if( stype ) {
  714.     CRef<COrgMod> pMod( new COrgMod );
  715.     pMod->SetSubname().swap( (*i)->SetOname() );
  716.     pMod->SetSubtype( stype );
  717.     on.SetMod().push_back( pMod );
  718. }
  719.     }
  720. }
  721.     }
  723.         } else {
  724.             m_host.SetLastError
  725.                 ("Unable to get orgref: Response is not Getorgnames");
  726.             return false;
  727.         }
  728.     } else
  729.         return false;
  730.     return true;
  731. }
  733. bool
  734. COrgRefCache::Insert1( CTaxon1Node& node )
  735. {
  736.     bool is_species( false );
  737.     struct SCacheEntry* pEntry = ( new SCacheEntry );
  738.     pEntry->m_pTax1 = new CTaxon1_data;
  739.     pEntry->m_pTax2 = NULL;
  740.     pEntry->m_pTreeNode = &node;
  742.     COrg_ref& org = ( pEntry->m_pTax1->SetOrg() );
  744.     if( !BuildOrgRef( node, org, is_species ) ) {
  745.         delete pEntry;
  746.         return false;
  747.     }
  748.     // Set division code
  749.     if( GetDivisionCode(node.GetDivision()) ) {
  750.         pEntry->m_pTax1->SetDiv()
  751.             .assign( GetDivisionCode(node.GetDivision()) );
  752.     }
  753.     // Set species level
  754.     pEntry->m_pTax1->SetIs_species_level( is_species );
  755.     // Remove last element from list
  756.     if( m_lCache.size() >= m_nCacheCapacity ) {
  757.         CTaxon1Node* pNode = ( m_lCache.back()->m_pTreeNode );
  758.         pNode->m_cacheEntry = NULL;
  759.         delete m_lCache.back();
  760.         m_lCache.pop_back();
  761.     }
  762.     
  763.     node.m_cacheEntry = pEntry;
  764.     m_lCache.push_front( pEntry );
  766.     return true;
  767. }
  769. bool
  770. COrgRefCache::Insert2( CTaxon1Node& node )
  771. {
  772.     bool is_species( false );
  773.     struct SCacheEntry* pEntry = ( new SCacheEntry );
  774.     pEntry->m_pTax1 = NULL;
  775.     pEntry->m_pTax2 = new CTaxon2_data;
  776.     pEntry->m_pTreeNode = &node;
  778.     pEntry->m_pTax2->SetIs_uncultured( node.IsUncultured() );
  780.     COrg_ref& org = pEntry->m_pTax2->SetOrg();
  782.     if( !BuildOrgRef( node, org, is_species ) ) {
  783.         delete pEntry;
  784.         return false;
  785.     }
  786.     // Set blast names
  787.     CTaxon1Node* pNode = ( &node );
  788.     while( !pNode->IsRoot() ) {
  789.         if( !pNode->GetBlastName().empty() ) {
  790.             pEntry->m_pTax2->SetBlast_name()
  791.                 .push_back( pNode->GetBlastName() );
  792.         }
  793.         pNode = pNode->GetParent();
  794.     }
  795.     // Set species level
  796.     pEntry->m_pTax2->SetIs_species_level( is_species );
  797.     // Remove last element from list
  798.     if( m_lCache.size() >= m_nCacheCapacity ) {
  799.         pNode = m_lCache.back()->m_pTreeNode;
  800.         pNode->m_cacheEntry = NULL;
  801.         delete m_lCache.back();
  802.         m_lCache.pop_back();
  803.     }
  804.     
  805.     node.m_cacheEntry = pEntry;
  806.     m_lCache.push_front( pEntry );
  808.     return true;
  809. }
  811. CTaxon1_data*
  812. COrgRefCache::SCacheEntry::GetData1()
  813. {
  814.     if( ! m_pTax1 ) {
  815.         m_pTax1 = new CTaxon1_data;
  816.         if( m_pTax2->IsSetOrg() ) {
  817.             m_pTax1->SetOrg( m_pTax2->SetOrg() );
  818. }
  819.         if( m_pTax2->GetOrg().GetOrgname().CanGetDiv() ) {
  820.             m_pTax1->SetDiv( m_pTax2->GetOrg().GetOrgname().GetDiv() );
  821.         } else {
  822.             m_pTax1->SetDiv( kEmptyStr );
  823. }
  824.         m_pTax1->SetIs_species_level(m_pTax2->GetIs_species_level());
  825.     }
  826.     return m_pTax1;
  827. }
  829. CTaxon2_data*
  830. COrgRefCache::SCacheEntry::GetData2()
  831. {
  832.     if( ! m_pTax2 ) {
  833.         m_pTax2 = new CTaxon2_data;
  834.         if( m_pTax1->IsSetOrg() ) {
  835.             m_pTax2->SetOrg( m_pTax1->SetOrg() );
  836. }
  837.         CTaxon1Node* pNode = ( m_pTreeNode );
  838.         while( !pNode->IsRoot() ) {
  839.             if( !pNode->GetBlastName().empty() ) {
  840.                 m_pTax2->SetBlast_name().push_back( pNode->GetBlastName() );
  841.             }
  842.             pNode = pNode->GetParent();
  843.         }
  844.         m_pTax2->SetIs_uncultured( m_pTreeNode->IsUncultured() );
  845.         m_pTax2->SetIs_species_level(m_pTax1->GetIs_species_level());
  846.     }
  847.     return m_pTax2;
  848. }
  850. int
  851. COrgRefCache::FindRankByName( const char* pchName ) const
  852. {
  853.     for( TRankMapCI ci = m_rankStorage.begin();
  854.          ci != m_rankStorage.end();
  855.          ++ci )
  856.         if( ci->second.compare( pchName ) == 0 )
  857.             return ci->first;
  858.     return -1000;
  859. }
  862. const char*
  863. COrgRefCache::GetRankName( int rank ) const
  864. {
  865.     TRankMapCI ci( m_rankStorage.find( rank ) );
  866.     if( ci != m_rankStorage.end() ) {
  867.         return ci->second.c_str();
  868.     }
  869.     return NULL;
  870. }
  872. bool
  873. COrgRefCache::InitRanks()
  874. {
  875.     if( m_rankStorage.size() == 0 ) {
  877.         CTaxon1_req  req;
  878.         CTaxon1_resp resp;
  880.         req.SetGetranks();
  882.         if( m_host.SendRequest( req, resp ) ) {
  883.             if( resp.IsGetranks() ) {
  884.                 // Correct response, return object
  885.                 const list< CRef< CTaxon1_info > >&
  886.                     lRanks = ( resp.GetGetranks() );
  887.                 // Fill in storage
  888.                 for( list< CRef< CTaxon1_info > >::const_iterator
  889.                          i = lRanks.begin();
  890.                      i != lRanks.end(); ++i ) {
  891.                     m_rankStorage
  892.                         .insert( TRankMap::value_type((*i)->GetIval1(),
  893.                                                       (*i)->GetSval()) );
  894. }
  895.             } else { // Internal: wrong respond type
  896.                 m_host.SetLastError( "Response type is not Getranks" );
  897.                 return false;
  898.             }
  899.         }
  901.         m_nSuperkingdomRank = FindRankByName( "superkingdom" );
  902.         if( m_nSuperkingdomRank < -10 ) {
  903.             m_host.SetLastError( "Superkingdom rank was not found" );
  904.             return false;
  905.         }
  906.         m_nFamilyRank = FindRankByName( "family" );
  907.         if( m_nFamilyRank < -10 ) {
  908.             m_host.SetLastError( "Family rank was not found" );
  909.             return false;
  910.         }
  911.         m_nOrderRank = FindRankByName( "order" );
  912.         if( m_nOrderRank < -10 ) {
  913.             m_host.SetLastError( "Order rank was not found" );
  914.             return false;
  915.         }
  916.         m_nClassRank = FindRankByName( "class" );
  917.         if( m_nClassRank < -10 ) {
  918.             m_host.SetLastError( "Class rank was not found" );
  919.             return false;
  920.         }
  921.         m_nGenusRank = FindRankByName( "genus" );
  922.         if( m_nGenusRank < -10 ) {
  923.             m_host.SetLastError( "Genus rank was not found" );
  924.             return false;
  925.         }
  926.         m_nSubgenusRank = FindRankByName( "subgenus" );
  927.         if( m_nSubgenusRank < -10 ) {
  928.             m_host.SetLastError( "Subgenus rank was not found" );
  929.             return false;
  930.         }
  931.         m_nSpeciesRank = FindRankByName( "species" );
  932.         if( m_nSpeciesRank < -10 ) {
  933.             m_host.SetLastError( "Species rank was not found" );
  934.             return false;
  935.         }
  936.         m_nSubspeciesRank = FindRankByName( "subspecies" );
  937.         if( m_nSubspeciesRank < -10 ) {
  938.             m_host.SetLastError( "Subspecies rank was not found" );
  939.             return false;
  940.         }
  941.         m_nFormaRank = FindRankByName( "forma" );
  942.         if( m_nFormaRank < -10 ) {
  943.             m_host.SetLastError( "Forma rank was not found" );
  944.             return false;
  945.         }
  946.         m_nVarietyRank = FindRankByName( "varietas" );
  947.         if( m_nVarietyRank < -10 ) {
  948.             m_host.SetLastError( "Variety rank was not found" );
  949.             return false;
  950.         }
  951.     }
  952.     return true;
  953. }
  955. const char*
  956. COrgRefCache::GetNameClassName( short nc ) const
  957. {
  958.     TNameClassMapCI ci( m_ncStorage.find( nc ) );
  959.     if( ci != m_ncStorage.end() ) {
  960.         return ci->second.c_str();
  961.     }
  962.     return NULL;
  963. }
  965. short
  966. COrgRefCache::FindNameClassByName( const char* pchName ) const
  967. {
  968.     for( TNameClassMapCI ci = m_ncStorage.begin();
  969.          ci != m_ncStorage.end();
  970.          ++ci )
  971.         if( ci->second.compare( pchName ) == 0 )
  972.             return ci->first;
  973.     return -1;
  974. }
  976. bool
  977. COrgRefCache::InitNameClasses()
  978. {
  979.     if( m_ncStorage.size() == 0 ) {
  981.         CTaxon1_req  req;
  982.         CTaxon1_resp resp;
  984.         req.SetGetcde();
  986.         if( m_host.SendRequest( req, resp ) ) {
  987.             if( resp.IsGetcde() ) {
  988.                 // Correct response, return object
  989.                 const list< CRef< CTaxon1_info > >&
  990.                     l = ( resp.GetGetcde() );
  991.                 // Fill in storage
  992.                 for( list< CRef< CTaxon1_info > >::const_iterator
  993.                          i = l.begin();
  994.                      i != l.end(); ++i )
  995.                     m_ncStorage
  996.                         .insert( TNameClassMap::value_type((*i)->GetIval1(),
  997.                                                            (*i)->GetSval()) );
  998.             } else { // Internal: wrong respond type
  999.                 m_host.SetLastError( "Response type is not Getcde" );
  1000.                 return false;
  1001.             }
  1002.         }
  1004.         m_ncPrefCommon = FindNameClassByName( "genbank common name" );
  1005.         if( m_ncPrefCommon < 0 ) {
  1006.             m_host.SetLastError( "Genbank common name class was not found" );
  1007.             return false;
  1008.         }
  1009.         m_ncCommon = FindNameClassByName( "common name" );
  1010.         if( m_ncCommon < 0 ) {
  1011.             m_host.SetLastError( "Common name class was not found" );
  1012.             return false;
  1013.         }
  1014.         m_ncSynonym = FindNameClassByName( "synonym" );
  1015.         if( m_ncSynonym < 0 ) {
  1016.             m_host.SetLastError( "Synonym name class was not found" );
  1017.             return false;
  1018.         }
  1020. m_ncGBAcronym= FindNameClassByName("genbank acronym");
  1021.         if( m_ncGBAcronym < 0 ) {
  1022.             m_host.SetLastError( "Genbank acrony name class was not found" );
  1023.             return false;
  1024.         }
  1025. m_ncGBSynonym= FindNameClassByName("genbank synonym");
  1026.         if( m_ncGBSynonym < 0 ) {
  1027.             m_host.SetLastError( "Genbank synonym name class was not found" );
  1028.             return false;
  1029.         }
  1030. m_ncGBAnamorph= FindNameClassByName("genbank anamorph");
  1031.         if( m_ncGBAnamorph < 0 ) {
  1032.             m_host.SetLastError( "Genbank anamorph name class was not found" );
  1033.             return false;
  1034.         }
  1035.     }
  1036.     return true;
  1037. }
  1039. short
  1040. COrgRefCache::FindDivisionByCode( const char* pchCode ) const
  1041. {
  1042.     for( TDivisionMapCI ci = m_divStorage.begin();
  1043.          ci != m_divStorage.end();
  1044.          ++ci ) {
  1045.         const char* cp = ( ci->second.m_sCode.c_str() );
  1046.         if( strcmp( cp, pchCode ) == 0 )
  1047.             return ci->first;
  1048.     }
  1049.     return -1;
  1050. }
  1053. const char*
  1054. COrgRefCache::GetDivisionCode( short div_id ) const
  1055. {
  1056.     TDivisionMapCI ci( m_divStorage.find( div_id ) );
  1057.     if( ci != m_divStorage.end() ) {
  1058.         return ci->second.m_sCode.c_str();
  1059.     }
  1060.     return NULL;
  1061. }
  1063. const char*
  1064. COrgRefCache::GetDivisionName( short div_id ) const
  1065. {
  1066.     TDivisionMapCI ci( m_divStorage.find( div_id ) );
  1067.     if( ci != m_divStorage.end() ) {
  1068.         return ci->second.m_sName.c_str();
  1069.     }
  1070.     return NULL;
  1071. }
  1074. bool
  1075. COrgRefCache::InitDivisions()
  1076. {
  1077.     if( m_divStorage.size() == 0 ) {
  1079.         CTaxon1_req  req;
  1080.         CTaxon1_resp resp;
  1082.         req.SetGetdivs();
  1084.         if( m_host.SendRequest( req, resp ) ) {
  1085.             if( resp.IsGetdivs() ) {
  1086.                 // Correct response, return object
  1087.                 const list< CRef< CTaxon1_info > >&
  1088.                     l = ( resp.GetGetdivs() );
  1089.                 // Fill in storage
  1090.                 for( list< CRef< CTaxon1_info > >::const_iterator
  1091.                          i = l.begin();
  1092.                      i != l.end(); ++i ) {
  1093.                     SDivision& div = ( m_divStorage[(*i)->GetIval1()] );
  1094.                     div.m_sName.assign( (*i)->GetSval() );
  1095.                     int code = (*i)->GetIval2();
  1096.                     for(int k= 0; k < 3; k++) {
  1097.                         div.m_sCode.append( 1U, (code >> (8*(3-k))) & 0xFF );
  1098.                     }
  1099.                     div.m_sCode.append( 1U, code & 0xFF );
  1100.                 }
  1101.             } else { // Internal: wrong response type
  1102.                 m_host.SetLastError( "Response type is not Getdivs" );
  1103.                 return false;
  1104.             }
  1105.         }
  1107.         if( (m_divViruses = FindDivisionByCode( "VRL" )) < 0 ) {
  1108.             m_host.SetLastError( "Viruses division was not found" );
  1109.             return false;
  1110.         }
  1111.         if( (m_divPhages = FindDivisionByCode( "PHG" )) < 0 ) {
  1112.             m_host.SetLastError( "Phages division was not found" );
  1113.             return false;
  1114.         }
  1115.     }
  1116.     return true;
  1117. }
  1119. void
  1120. COrgRefCache::SetIndexEntry( int id, CTaxon1Node* pNode )
  1121. {
  1122.     m_ppEntries[id] = pNode;
  1123. }
  1125. //=======================================================
  1126. //
  1127. //   Iterators implementation
  1128. //
  1129. bool
  1130. CTaxTreeConstIterator::IsLastChild() const
  1131. {
  1132.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1133.     bool bResult = true;
  1135.     while( m_it->GoParent() ) {
  1136. if( IsVisible( m_it->GetNode() ) ) {
  1137.     const CTreeContNodeBase* pParent = m_it->GetNode();
  1138.     m_it->GoNode( pOldNode );
  1139.     while( m_it->GetNode() != pParent ) {
  1140. if( m_it->GoSibling() ) {
  1141.     bResult = !NextVisible( pParent );
  1142.     break;
  1143. }
  1144. if( !m_it->GoParent() ) {
  1145.     break;
  1146. }
  1147.     }
  1148.     break;
  1149. }
  1150.     }
  1151.     m_it->GoNode( pOldNode );
  1152.     return bResult;
  1153. }
  1155. bool
  1156. CTaxTreeConstIterator::IsFirstChild() const
  1157. {
  1158.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1159.     bool bResult = false;
  1161.     while( m_it->GoParent() ) {
  1162. if( IsVisible( m_it->GetNode() ) ) {
  1163.     const CTreeContNodeBase* pParent = m_it->GetNode();
  1164.     if( m_it->GoChild() ) {
  1165. bResult = NextVisible(pParent) && m_it->GetNode() == pOldNode;
  1166.     }
  1167.     break;
  1168. }
  1169.     }
  1170.     m_it->GoNode( pOldNode );
  1171.     return bResult;
  1172. }
  1174. bool
  1175. CTaxTreeConstIterator::IsTerminal() const
  1176. {
  1177.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1179.     if( m_it->GoChild() ) {
  1180. bool bResult = NextVisible( pOldNode );
  1181. m_it->GoNode( pOldNode );
  1182. return !bResult;
  1183.     }
  1184.     return true;
  1185. }
  1187. bool
  1188. CTaxTreeConstIterator::NextVisible( const CTreeContNodeBase* pParent ) const
  1189. {
  1190.     if( m_it->GetNode() == pParent ) {
  1191. return false;
  1192.     }
  1193.  next:
  1194.     if( IsVisible( m_it->GetNode() ) ) {
  1195. return true;
  1196.     }
  1197.     if( m_it->GoChild() ) {
  1198. goto next;
  1199.     } else if( m_it->GoSibling() ) {
  1200. goto next;
  1201.     } else {
  1202. while( m_it->GoParent() && m_it->GetNode() != pParent ) {
  1203.     if( m_it->GoSibling() ) {
  1204. goto next;
  1205.     }
  1206. }
  1207.     }
  1208.     return false;
  1209. }
  1211. bool
  1212. CTaxTreeConstIterator::GoParent()
  1213. {
  1214.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1215.     bool bResult = false;
  1216.     while( m_it->GoParent() ) {
  1217. if( IsVisible( m_it->GetNode() ) ) {
  1218.     bResult = true;
  1219.     break;
  1220. }
  1221.     }
  1222.     if( !bResult ) {
  1223. m_it->GoNode( pOldNode );
  1224.     }
  1225.     return bResult;
  1226. }
  1228. bool
  1229. CTaxTreeConstIterator::GoChild()
  1230. {
  1231.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1232.     bool bResult = false;
  1233.     
  1234.     if( m_it->GoChild() ) {
  1235. bResult = NextVisible( pOldNode );
  1236.     }
  1237.     if( !bResult ) {
  1238. m_it->GoNode( pOldNode );
  1239.     }
  1240.     return bResult;
  1241. }
  1243. bool
  1244. CTaxTreeConstIterator::GoSibling()
  1245. {
  1246.     const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1247.     bool bResult = false;
  1249.     if( GoParent() ) {
  1250. const CTreeContNodeBase* pParent = m_it->GetNode();
  1251. m_it->GoNode( pOldNode );
  1252. while( m_it->GetNode() != pParent ) {
  1253.     if( m_it->GoSibling() ) {
  1254. bResult = NextVisible( pParent );
  1255. break;
  1256.     }
  1257.     if( !m_it->GoParent() ) {
  1258. break;
  1259.     }
  1260. }
  1261. if( !bResult ) {
  1262.     m_it->GoNode( pOldNode );
  1263. }
  1264.     }
  1265.     return bResult;
  1266. }
  1268. bool
  1269. CTaxTreeConstIterator::GoNode( const ITaxon1Node* pNode )
  1270. {
  1271.     const CTreeContNodeBase* pTaxNode = CastIC( pNode );
  1273.     if( pNode && IsVisible( pTaxNode ) ) {
  1274. return m_it->GoNode( pTaxNode );
  1275.     }
  1276.     return false;
  1277. }
  1279. bool
  1280. CTaxTreeConstIterator::GoAncestor(const ITaxon1Node* pINode)
  1281. {
  1282.     const CTreeContNodeBase* pNode = CastIC( pINode );
  1283.     if( pNode && IsVisible( pNode ) ) {
  1284. const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1285.     
  1286. vector< const CTreeContNodeBase* > v;
  1287. do {
  1288.     v.push_back( m_it->GetNode() );
  1289. } while( GoParent() );
  1291. m_it->GoNode( pNode );
  1292. vector< const CTreeContNodeBase* >::const_iterator vi;
  1293. do {
  1294.     vi = find( v.begin(), v.end(), m_it->GetNode() );
  1295.     if( vi != v.end() ) {
  1296. return true;
  1297.     }
  1298. } while( GoParent() );
  1299. // Restore old position
  1300. m_it->GoNode( pOldNode );
  1301.     }
  1302.     return false;
  1303. }
  1305. bool
  1306. CTaxTreeConstIterator::BelongSubtree(const ITaxon1Node* pIRoot) const
  1307. {
  1308.     const CTreeContNodeBase* pRoot = CastIC( pIRoot );
  1309.     if( pRoot && IsVisible( pRoot ) ) {
  1310. const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1311. do {
  1312.     if( IsVisible( m_it->GetNode() ) ) {
  1313. if( m_it->GetNode() == pRoot ) {
  1314.     m_it->GoNode( pOldNode );
  1315.     return true;
  1316. }
  1317.     }
  1318. } while( m_it->GoParent() );
  1319. m_it->GoNode( pOldNode );
  1320.     }
  1321.     return false;
  1322. }
  1324. // check if given node belongs to subtree pointed by cursor
  1325. bool
  1326. CTaxTreeConstIterator::AboveNode(const ITaxon1Node* pINode) const
  1327. {
  1328.     const CTreeContNodeBase* pNode = CastIC( pINode );
  1329.     if( pNode == m_it->GetNode() ) { // Node is not above itself
  1330. return false;
  1331.     }
  1333.     if( pNode && IsVisible( pNode ) ) {
  1334. const CTreeContNodeBase* pOldNode = m_it->GetNode();
  1335. m_it->GoNode( pNode );
  1336. do {
  1337.     if( IsVisible( m_it->GetNode() ) ) {
  1338. if( m_it->GetNode() == pOldNode ) {
  1339.     m_it->GoNode( pOldNode );
  1340.     return true;
  1341. }
  1342.     }
  1343. } while( m_it->GoParent() );
  1344. m_it->GoNode( pOldNode );
  1345.     }
  1346.     return false;
  1347. }
  1349. bool
  1350. CTreeLeavesBranchesIterator::IsVisible( const CTreeContNodeBase* pNode ) const
  1351. {
  1352.     return pNode &&
  1353. ( pNode->IsRoot() || pNode->IsTerminal() ||
  1354.   !pNode->Child()->IsLastChild() );
  1355. }
  1357. bool
  1358. CTreeBestIterator::IsVisible( const CTreeContNodeBase* pNode ) const
  1359. {
  1360.     return pNode &&
  1361. ( pNode->IsRoot() || pNode->IsTerminal() ||
  1362.   !pNode->Child()->IsLastChild() ||
  1363.   !(pNode->IsLastChild() && pNode->IsFirstChild()) );
  1365. }
  1367. bool
  1368. CTreeBlastIterator::IsVisible( const CTreeContNodeBase* pNode ) const
  1369. {
  1370.     return pNode && ( pNode->IsRoot() ||
  1371.       !CastCI(pNode)->GetBlastName().empty() );
  1372. }
  1375. END_objects_SCOPE
  1376. END_NCBI_SCOPE
  1380. /*
  1381.  * $Log: cache.cpp,v $
  1382.  * Revision 1000.3  2004/06/01 19:35:08  gouriano
  1383.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R6.21
  1384.  *
  1385.  * Revision 6.21  2004/05/19 17:27:10  gorelenk
  1386.  * Added include of PCH - ncbi_pch.hpp
  1387.  *
  1388.  * Revision 6.20  2004/02/04 16:14:44  domrach
  1389.  * New iterator types (modes of operation) are introduced. They include:
  1390.  * full tree, branches'n'leaves, best, and blast. Position inquiry f-ns
  1391.  * IsTerminal(), IsFirstChild(), and IsLastChild() has been moved from
  1392.  * ITreeNode to ITreeIterator. Node loading f-ns() now return the ITreeNode
  1393.  * for tax id.
  1394.  *
  1395.  * Revision 6.19  2003/11/20 15:42:19  ucko
  1396.  * Update for new (saner) treatment of ASN.1 NULLs.
  1397.  *
  1398.  * Revision 6.18  2003/06/23 20:42:08  domrach
  1399.  * New treatment of subspecies names introduced
  1400.  *
  1401.  * Revision 6.17  2003/06/05 20:44:01  domrach
  1402.  * Adjusted to the new CanGetXxx verification methods
  1403.  *
  1404.  * Revision 6.16  2003/05/06 19:53:53  domrach
  1405.  * New functions and interfaces for traversing the cached partial taxonomy tree introduced. Convenience functions GetDivisionName() and GetRankName() were added
  1406.  *
  1407.  * Revision 6.15  2003/03/06 16:13:14  domrach
  1408.  * Typo fix
  1409.  *
  1410.  * Revision 6.14  2003/03/06 16:11:29  domrach
  1411.  * More static initialization work
  1412.  *
  1413.  * Revision 6.13  2003/03/06 16:01:20  domrach
  1414.  * Static initialization corrected for msvc
  1415.  *
  1416.  * Revision 6.12  2003/03/05 21:33:52  domrach
  1417.  * Enhanced orgref processing. Orgref cache capacity control added.
  1418.  *
  1419.  * Revision 6.11  2003/01/21 19:36:22  domrach
  1420.  * Secondary tax id support added. New copy constructor for partial tree support added.
  1421.  *
  1422.  * Revision 6.10  2002/11/08 14:39:52  domrach
  1423.  * Member function GetSuperkingdom() added
  1424.  *
  1425.  * Revision 6.9  2002/11/04 21:29:18  grichenk
  1426.  * Fixed usage of const CRef<> and CRef<> constructor
  1427.  *
  1428.  * Revision 6.8  2002/08/06 15:09:45  domrach
  1429.  * Introducing new genbank name classes
  1430.  *
  1431.  * Revision 6.7  2002/07/25 15:01:56  grichenk
  1432.  * Replaced non-const GetXXX() with SetXXX()
  1433.  *
  1434.  * Revision 6.6  2002/02/14 22:44:50  vakatov
  1435.  * Use STimeout instead of time_t.
  1436.  * Get rid of warnings and extraneous #include's, shuffled code a little.
  1437.  *
  1438.  * Revision 6.5  2002/01/31 00:31:26  vakatov
  1439.  * Follow the renaming of "CTreeCont.hpp" to "ctreecont.hpp".
  1440.  * Get rid of "std::" which is unnecessary and sometimes un-compilable.
  1441.  * Also done some source identation/beautification.
  1442.  *
  1443.  * Revision 6.4  2002/01/30 16:13:37  domrach
  1444.  * Changes made to pass through MSVC compiler. Some src files renamed
  1445.  *
  1446.  * Revision 6.3  2002/01/29 17:17:45  domrach
  1447.  * Confusion with list/set resolved
  1448.  *
  1449.  * Revision 6.2  2002/01/28 21:37:02  domrach
  1450.  * list changed to multiset in BuildOrgRef()
  1451.  *
  1452.  * Revision 6.1  2002/01/28 19:56:10  domrach
  1453.  * Initial checkin of the library implementation files
  1454.  *
  1455.  * ===========================================================================
  1456.  */