cache.cpp

ncbi源码

    CTaxon1Node* pSubgen = ( NULL );
    CTaxon1Node* pNode = ( &node );
    string::size_type pos(0);
    do {
        int rank( pNode->GetRank() );
        if( rank == GetSubspeciesRank())
            pSubspec = pNode;
        else if( rank == GetSpeciesRank())
            pSpec = pNode;
        else if( rank == GetSubgenusRank())
            pSubgen = pNode;
        else if(rank == GetGenusRank()) {
            pGenus = pNode;
            break;
        }
        pNode = pNode->GetParent();
    } while( pNode && !pNode->IsRoot() );
    pNode = &node;

    if( !pGenus ) {
        if( !pSubgen )
            return false;
        else
            pGenus = pSubgen;
    }
    CBinomialOrgName& bon = ( on.SetName().SetBinomial() );

    bon.SetGenus( pGenus->GetName() );

    if( pSpec ) { // we have a species in lineage
        bon.SetSpecies().assign( pSpec->GetName(),
                                 pos=s_AfterPrefix( pSpec->GetName(),
                                                    pGenus->GetName() ),
                                 pSpec->GetName().size() - pos );

        if( pSubspec ) { // we also have a subspecies in lineage
            bon.SetSubspecies().assign( pSubspec->GetName(),
                                        pos=s_AfterPrefix(pSubspec->GetName(),
                                                          pSpec->GetName()),
                                        pSubspec->GetName().size() - pos );
        }
        if( pNode != pSpec ) {
            BuildOrgModifier( pNode, on );
        }
        return true;
    }
    // no species in lineage
    if( pSubspec ) { // we have no species but we have subspecies
        bon.SetSubspecies().assign( pSubspec->GetName(),
                                    pos=s_AfterPrefix(pSubspec->GetName(),
                                                      pGenus->GetName()),
                                    pSubspec->GetName().size() - pos );
        BuildOrgModifier( pNode, on,
                          pNode==pSubspec ? pGenus : pSubspec );
        return true;
    }
  
    // we have no species, no subspecies
    // but we are under species level (varietas or forma)
    BuildOrgModifier( pNode, on, pGenus );
    return true;
}

bool
COrgRefCache::SetPartialName( CTaxon1Node& node, COrgName& on )
{
    CTaxElement* pTaxElem = ( new CTaxElement );
    int rank_id= node.GetRank();
    
    CPartialOrgName& pon = ( on.SetName().SetPartial() );
    pon.Set().push_back(CRef<CTaxElement>(pTaxElem));

    if( rank_id == GetFamilyRank()) {
        pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_family );
    }
    else if(rank_id == GetOrderRank()) {
        pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_order );
    }
    else if(rank_id == GetClassRank()) {
        pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_class );
    }
    else {
        pTaxElem->SetFixed_level( CTaxElement_Base::eFixed_level_other );
        pTaxElem->SetLevel( GetRankName( rank_id ) );
    }
    pTaxElem->SetName( node.GetName() );
    return true;
}

bool
COrgRefCache::BuildOrgRef( CTaxon1Node& node, COrg_ref& org, bool& is_species )
{
    // Init ranks here
    if( !InitRanks() || !InitNameClasses() || !InitDivisions() )
        return false;

    CTaxon1_req  req;
    CTaxon1_resp resp;

    req.SetGetorgnames( node.GetTaxId() );

    if( m_host.SendRequest( req, resp ) ) {
        if( resp.IsGetorgnames() ) {
            // Correct response, return object
            list< CRef< CTaxon1_name > >&
                lLin = ( resp.SetGetorgnames() );
            // Save taxname
            org.SetTaxname().swap( lLin.front()->SetOname() );
            lLin.pop_front();

            list< CRef< CTaxon1_name > >::iterator i;
            // Find preferred common name
            int pref_cls = GetPreferredCommonNameClass();
            for( i = lLin.begin(); i != lLin.end(); ++i ) {
                if( (*i)->CanGetCde() && (*i)->GetCde() == pref_cls ) {
                    org.SetCommon().swap( (*i)->SetOname() );
                    lLin.erase( i );
                    break;
                }
            }
            int syn_cls(GetSynonymNameClass());
            int comm_cls(GetCommonNameClass());
            for( i = lLin.begin(); i != lLin.end(); ++i ) {
		if( (*i)->CanGetCde() ) {
		    int cls = (*i)->GetCde();
		    if( cls == syn_cls || cls == comm_cls ) {
			org.SetSyn().push_back( (*i)->GetOname() );
		    }
		}
            }
            // Set taxid as db tag
            org.SetTaxId( node.GetTaxId() );

            COrgName& on = ( org.SetOrgname() );

            short div_id( node.GetDivision() );
            if( GetDivisionCode( div_id ) ) {
                on.SetDiv( GetDivisionCode( div_id ) );
            }
            on.SetGcode( node.GetGC() );
	    if( node.GetMGC() > 0 ) {
		on.SetMgcode( node.GetMGC() );
	    }
            // Build lineage
            CTaxon1Node* pNode;
            if( !node.IsRoot() ) {
                pNode = node.GetParent();
		on.SetLineage(kEmptyStr);
                s_BuildLineage( on.SetLineage(), pNode, 0,
				GetSpeciesRank() );
                if( on.GetLineage().empty() ) {
                    on.ResetLineage();
		}
            }
            // Set rank
            int rank_id( node.GetRank() );

            is_species = (rank_id >= GetSpeciesRank());
            // correct level by lineage if node has no rank
            if( rank_id < 0 && !node.IsRoot() ) {
                pNode = node.GetParent();
                while( !pNode->IsRoot() ) {
                    int rank( pNode->GetRank() );
                    if(rank >= 0) {
                        is_species= (rank >= GetSpeciesRank()-1);
                        break;
                    }
                    pNode = pNode->GetParent();
                }
            }
            // Create name
            if(is_species) {
                /* we are on species level or below */
	     
                /* check for viruses */
                if( div_id == GetVirusesDivision()
                    || div_id == GetPhagesDivision() ) {
                    /* this is a virus */
                    /* virus */
                    if( rank_id == GetSpeciesRank() ) {
                        /* we are on species level */
                        on.SetName().SetVirus( node.GetName() );
                    } else {
                        /* we are below species */
                        /* first try to find species or min rank which
                           below species but above us */
                        pNode = 0;
                        CTaxon1Node* pTmp = ( node.GetParent() );
			
                        while( pTmp && !pTmp->IsRoot() ) {
                            int rank(pTmp->GetRank());
                            if( rank >= GetSpeciesRank() ) {
                                pNode = pTmp;
                                if( rank == GetSpeciesRank() )
                                    break;
                            } else if( rank >= 0 )
                                break;
                            pTmp = pTmp->GetParent();
                        }
                        if( !pNode ) {// we have species or something above us
                            pNode = &node;
                        }
                        on.SetName().SetVirus( pNode->GetName() );
                        // Add modifier to orgname
                        BuildOrgModifier( &node, on );
                    } // non species rank
                } else if( !SetBinomialName( node, on ) ) {
                    // name is not binomial: set partial
                    SetPartialName( node, on );
                }
            } else { // above species
                SetPartialName( node, on );
            }
	    // Add some genbank names as organism modifiers
	    if( org.IsSetOrgname() ) { // OrgName is not empty
		for( i = lLin.begin(); i != lLin.end(); ++i ) {
		    if( (*i)->CanGetCde() ) {
			int cde = (*i)->GetCde();
			COrgMod::ESubtype stype = (COrgMod::ESubtype)0;
			if( cde == GetGBAcronymNameClass() ) {
			    stype = COrgMod::eSubtype_gb_acronym;
			} else if( cde == GetGBSynonymNameClass() ) {
			    stype = COrgMod::eSubtype_gb_synonym;
			} else if( cde == GetGBAnamorphNameClass() ) {
			    stype = COrgMod::eSubtype_gb_anamorph;
			}
			if( stype ) {
			    CRef<COrgMod> pMod( new COrgMod );
			    pMod->SetSubname().swap( (*i)->SetOname() );
			    pMod->SetSubtype( stype );
			    on.SetMod().push_back( pMod );
			}
		    }
		}
	    }

        } else {
            m_host.SetLastError
                ("Unable to get orgref: Response is not Getorgnames");
            return false;
        }
    } else
        return false;
    return true;
}

bool
COrgRefCache::Insert1( CTaxon1Node& node )
{
    bool is_species( false );
    struct SCacheEntry* pEntry = ( new SCacheEntry );
    pEntry->m_pTax1 = new CTaxon1_data;
    pEntry->m_pTax2 = NULL;
    pEntry->m_pTreeNode = &node;

    COrg_ref& org = ( pEntry->m_pTax1->SetOrg() );

    if( !BuildOrgRef( node, org, is_species ) ) {
        delete pEntry;
        return false;
    }
    // Set division code
    if( GetDivisionCode(node.GetDivision()) ) {
        pEntry->m_pTax1->SetDiv()
            .assign( GetDivisionCode(node.GetDivision()) );
    }
    // Set species level
    pEntry->m_pTax1->SetIs_species_level( is_species );
    // Remove last element from list
    if( m_lCache.size() >= m_nCacheCapacity ) {
        CTaxon1Node* pNode = ( m_lCache.back()->m_pTreeNode );
        pNode->m_cacheEntry = NULL;
        delete m_lCache.back();
        m_lCache.pop_back();
    }
    
    node.m_cacheEntry = pEntry;
    m_lCache.push_front( pEntry );

    return true;
}

bool
COrgRefCache::Insert2( CTaxon1Node& node )
{
    bool is_species( false );
    struct SCacheEntry* pEntry = ( new SCacheEntry );
    pEntry->m_pTax1 = NULL;
    pEntry->m_pTax2 = new CTaxon2_data;
    pEntry->m_pTreeNode = &node;

    pEntry->m_pTax2->SetIs_uncultured( node.IsUncultured() );

    COrg_ref& org = pEntry->m_pTax2->SetOrg();

    if( !BuildOrgRef( node, org, is_species ) ) {
        delete pEntry;
        return false;
    }
    // Set blast names
    CTaxon1Node* pNode = ( &node );
    while( !pNode->IsRoot() ) {
        if( !pNode->GetBlastName().empty() ) {
            pEntry->m_pTax2->SetBlast_name()
                .push_back( pNode->GetBlastName() );
        }
        pNode = pNode->GetParent();
    }
    // Set species level
    pEntry->m_pTax2->SetIs_species_level( is_species );
    // Remove last element from list
    if( m_lCache.size() >= m_nCacheCapacity ) {
        pNode = m_lCache.back()->m_pTreeNode;
        pNode->m_cacheEntry = NULL;
        delete m_lCache.back();
        m_lCache.pop_back();
    }
    
    node.m_cacheEntry = pEntry;
    m_lCache.push_front( pEntry );

    return true;
}

CTaxon1_data*
COrgRefCache::SCacheEntry::GetData1()
{
    if( ! m_pTax1 ) {
        m_pTax1 = new CTaxon1_data;
        if( m_pTax2->IsSetOrg() ) {
            m_pTax1->SetOrg( m_pTax2->SetOrg() );
	}
        if( m_pTax2->GetOrg().GetOrgname().CanGetDiv() ) {
            m_pTax1->SetDiv( m_pTax2->GetOrg().GetOrgname().GetDiv() );
        } else {
            m_pTax1->SetDiv( kEmptyStr );
	}
        m_pTax1->SetIs_species_level(m_pTax2->GetIs_species_level());
    }
    return m_pTax1;
}

CTaxon2_data*
COrgRefCache::SCacheEntry::GetData2()
{
    if( ! m_pTax2 ) {
        m_pTax2 = new CTaxon2_data;
        if( m_pTax1->IsSetOrg() ) {
            m_pTax2->SetOrg( m_pTax1->SetOrg() );
	}
        CTaxon1Node* pNode = ( m_pTreeNode );
        while( !pNode->IsRoot() ) {
            if( !pNode->GetBlastName().empty() ) {
                m_pTax2->SetBlast_name().push_back( pNode->GetBlastName() );
            }
            pNode = pNode->GetParent();
        }
        m_pTax2->SetIs_uncultured( m_pTreeNode->IsUncultured() );
        m_pTax2->SetIs_species_level(m_pTax1->GetIs_species_level());
    }
    return m_pTax2;
}

int
COrgRefCache::FindRankByName( const char* pchName ) const
{
    for( TRankMapCI ci = m_rankStorage.begin();
         ci != m_rankStorage.end();
         ++ci )
        if( ci->second.compare( pchName ) == 0 )
            return ci->first;
    return -1000;
}


const char*
COrgRefCache::GetRankName( int rank ) const
{
    TRankMapCI ci( m_rankStorage.find( rank ) );
    if( ci != m_rankStorage.end() ) {
        return ci->second.c_str();
    }
    return NULL;
}

bool
COrgRefCache::InitRanks()
{
    if( m_rankStorage.size() == 0 ) {

        CTaxon1_req  req;
        CTaxon1_resp resp;

        req.SetGetranks();

        if( m_host.SendRequest( req, resp ) ) {
            if( resp.IsGetranks() ) {
                // Correct response, return object
                const list< CRef< CTaxon1_info > >&
                    lRanks = ( resp.GetGetranks() );
                // Fill in storage
                for( list< CRef< CTaxon1_info > >::const_iterator
                         i = lRanks.begin();
                     i != lRanks.end(); ++i ) {
                    m_rankStorage
                        .insert( TRankMap::value_type((*i)->GetIval1(),
                                                      (*i)->GetSval()) );
		}
            } else { // Internal: wrong respond type
                m_host.SetLastError( "Response type is not Getranks" );
                return false;
            }
        }

        m_nSuperkingdomRank = FindRankByName( "superkingdom" );
        if( m_nSuperkingdomRank < -10 ) {
            m_host.SetLastError( "Superkingdom rank was not found" );
            return false;
        }
        m_nFamilyRank = FindRankByName( "family" );
        if( m_nFamilyRank < -10 ) {
            m_host.SetLastError( "Family rank was not found" );
            return false;
        }
        m_nOrderRank = FindRankByName( "order" );
        if( m_nOrderRank < -10 ) {
            m_host.SetLastError( "Order rank was not found" );
            return false;
        }
        m_nClassRank = FindRankByName( "class" );
        if( m_nClassRank < -10 ) {
            m_host.SetLastError( "Class rank was not found" );
            return false;
        }
        m_nGenusRank = FindRankByName( "genus" );
        if( m_nGenusRank < -10 ) {
            m_host.SetLastError( "Genus rank was not found" );
            return false;
        }
        m_nSubgenusRank = FindRankByName( "subgenus" );
        if( m_nSubgenusRank < -10 ) {
            m_host.SetLastError( "Subgenus rank was not found" );
            return false;
        }
        m_nSpeciesRank = FindRankByName( "species" );
        if( m_nSpeciesRank < -10 ) {
            m_host.SetLastError( "Species rank was not found" );
            return false;
        }
        m_nSubspeciesRank = FindRankByName( "subspecies" );
        if( m_nSubspeciesRank < -10 ) {
            m_host.SetLastError( "Subspecies rank was not found" );
            return false;
        }
        m_nFormaRank = FindRankByName( "forma" );
        if( m_nFormaRank < -10 ) {
            m_host.SetLastError( "Forma rank was not found" );
            return false;
        }
        m_nVarietyRank = FindRankByName( "varietas" );
        if( m_nVarietyRank < -10 ) {
            m_host.SetLastError( "Variety rank was not found" );
            return false;
        }
    }
    return true;
}

const char*
COrgRefCache::GetNameClassName( short nc ) const
{
    TNameClassMapCI ci( m_ncStorage.find( nc ) );
    if( ci != m_ncStorage.end() ) {
        return ci->second.c_str();
    }
    return NULL;
}

short
COrgRefCache::FindNameClassByName( const char* pchName ) const
{
    for( TNameClassMapCI ci = m_ncStorage.begin();
         ci != m_ncStorage.end();
         ++ci )
        if( ci->second.compare( pchName ) == 0 )
            return ci->first;