seq_id_tree.cpp

来自「ncbi源码」· C++ 代码 · 共 1,683 行 · 第 1/3 页

            ver.push_back(info);
        }
        if ( tid.IsSetName() ) {
            TVersions& ver = m_ByName[tid.GetName()];
            ITERATE(TVersions, vit, ver) {
                _ASSERT(!x_Get(*(*vit)->GetSeqId()).Equals(tid));
            }
            ver.push_back(info);
        }
    }
    return CSeq_id_Handle(info);
}


void CSeq_id_Textseq_Tree::x_Unindex(const CSeq_id_Info* info)
{
    _ASSERT(x_Check(*info->GetSeqId()));
    const CTextseq_id& tid = x_Get(*info->GetSeqId());

    if ( tid.IsSetAccession() ) {
        TStringMap::iterator it =
            m_ByAccession.find(tid.GetAccession());
        if (it != m_ByAccession.end()) {
            NON_CONST_ITERATE(TVersions, vit, it->second) {
                if (*vit == info) {
                    it->second.erase(vit);
                    break;
                }
            }
            if (it->second.empty())
                m_ByAccession.erase(it);
        }
    }
    if ( tid.IsSetName() ) {
        TStringMap::iterator it = m_ByName.find(tid.GetName());
        if (it != m_ByName.end()) {
            NON_CONST_ITERATE(TVersions, vit, it->second) {
                if (*vit == info) {
                    it->second.erase(vit);
                    break;
                }
            }
            if (it->second.empty())
                m_ByName.erase(it);
        }
    }
}


void CSeq_id_Textseq_Tree::x_FindVersionMatch(const TVersions& ver_list,
                                              const CTextseq_id& tid,
                                              TSeq_id_MatchList& id_list) const
{
    int ver = 0;
    string rel;
    if ( tid.IsSetVersion() )
        ver = tid.GetVersion();
    if ( tid.IsSetRelease() )
        rel = tid.GetRelease();
    ITERATE(TVersions, vit, ver_list) {
        int ver_it = 0;
        string rel_it;
        const CTextseq_id& vit_ref = x_Get(*(*vit)->GetSeqId());
        if ( vit_ref.IsSetVersion() )
            ver_it = vit_ref.GetVersion();
        if ( vit_ref.IsSetRelease() )
            rel_it = vit_ref.GetRelease();
        if (ver != 0 && ver != ver_it) {
            continue;
        }
        if (!rel.empty() && rel != rel_it) {
            continue;
        }
        id_list.insert(CSeq_id_Handle(*vit));
    }
}


void CSeq_id_Textseq_Tree::FindMatch(const CSeq_id_Handle& id,
                                     TSeq_id_MatchList& id_list) const
{
    //_ASSERT(id && id == FindInfo(id.GetSeqId()));
    const CTextseq_id& tid = x_Get(*id.GetSeqId());
    if ( tid.IsSetAccession() ) {
        TReadLockGuard guard(m_TreeLock);
        TStringMap::const_iterator it = m_ByAccession.find(tid.GetAccession());
        if (it != m_ByAccession.end()) {
            x_FindVersionMatch(it->second, tid, id_list);
        }
    }
    else if ( tid.IsSetName() ) {
        TReadLockGuard guard(m_TreeLock);
        TStringMap::const_iterator it = m_ByName.find(tid.GetName());
        if (it != m_ByName.end()) {
            x_FindVersionMatch(it->second, tid, id_list);
        }
    }
}


void CSeq_id_Textseq_Tree::FindMatchStr(string sid,
                                        TSeq_id_MatchList& id_list) const
{
    TReadLockGuard guard(m_TreeLock);
    // ignore '.' in the search string - cut it out
    sid = sid.substr(0, sid.find('.'));
    // Find by accession
    TStringMap::const_iterator it = m_ByAccession.find(sid);
    if (it == m_ByAccession.end()) {
        it = m_ByName.find(sid);
        if (it == m_ByName.end())
            return;
    }
    ITERATE(TVersions, vit, it->second) {
        id_list.insert(CSeq_id_Handle(*vit));
    }
}


bool CSeq_id_Textseq_Tree::IsBetterVersion(const CSeq_id_Handle& h1,
                                           const CSeq_id_Handle& h2) const
{
    CConstRef<CSeq_id> id1 = h1.GetSeqId();
    _ASSERT(x_Check(*id1));
    CConstRef<CSeq_id> id2 = h2.GetSeqId();
    _ASSERT(x_Check(*id2));
    const CTextseq_id& tid1 = x_Get(*id1);
    const CTextseq_id& tid2 = x_Get(*id2);
    // Compare versions. If only one of the two ids has version,
    // consider it is better.
    if ( tid1.IsSetVersion() ) {
        if ( tid2.IsSetVersion() )
            return tid1.GetVersion() > tid2.GetVersion();
        else
            return true; // Only h1 has version
    }
    return false; // h1 has no version, so it can not be better than h2
}


bool CSeq_id_Textseq_Tree::HaveReverseMatch(const CSeq_id_Handle&) const
{
    return true;
}


void CSeq_id_Textseq_Tree::FindReverseMatch(const CSeq_id_Handle& id,
                                            TSeq_id_MatchList& id_list)
{
    id_list.insert(id);

    CConstRef<CSeq_id> orig_id = id.GetSeqId();
    const CTextseq_id& orig_tid = x_Get(*orig_id);

    CRef<CSeq_id> tmp(new CSeq_id);
    tmp->Assign(*orig_id);
    CTextseq_id& tid = const_cast<CTextseq_id&>(x_Get(*tmp));
    bool A = orig_tid.IsSetAccession();
    bool N = orig_tid.IsSetName();
    bool v = orig_tid.IsSetVersion();
    bool r = orig_tid.IsSetRelease();

    if ( A  &&  (N  ||  v  ||  r) ) {
        // A only
        tid.Reset();
        tid.SetAccession(orig_tid.GetAccession());
        id_list.insert(FindOrCreate(*tmp));
        if ( v  &&  (N  ||  r) ) {
            // A.v
            tid.SetVersion(orig_tid.GetVersion());
            id_list.insert(FindOrCreate(*tmp));
        }
        if ( N ) {
            // N only
            tid.Reset();
            tid.SetName(orig_tid.GetName());
            id_list.insert(FindOrCreate(*tmp));
            if ( v  ||  r ) {
                if ( r ) {
                    // N.r
                    tid.SetRelease(orig_tid.GetRelease());
                    id_list.insert(FindOrCreate(*tmp));
                    tid.ResetRelease();
                }
                // A + N
                tid.SetAccession(orig_tid.GetAccession());
                id_list.insert(FindOrCreate(*tmp));
                if ( v  &&  r ) {
                    // A.v + N
                    tid.SetVersion(orig_tid.GetVersion());
                    id_list.insert(FindOrCreate(*tmp));
                    // A + N.r
                    tid.ResetVersion();
                    tid.SetRelease(orig_tid.GetRelease());
                    id_list.insert(FindOrCreate(*tmp));
                }
            }
        }
    }
    else if ( N  &&  (v  ||  r) ) {
        // N only
        tid.Reset();
        tid.SetName(orig_tid.GetName());
        id_list.insert(FindOrCreate(*tmp));
        if ( v  &&  r ) {
            tid.SetRelease(orig_tid.GetRelease());
            id_list.insert(FindOrCreate(*tmp));
        }
    }
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_GB_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_GB_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsGenbank()  ||  id.IsEmbl()  ||  id.IsDdbj();
}


const CTextseq_id& CSeq_id_GB_Tree::x_Get(const CSeq_id& id) const
{
    switch ( id.Which() ) {
    case CSeq_id::e_Genbank:
        return id.GetGenbank();
    case CSeq_id::e_Embl:
        return id.GetEmbl();
    case CSeq_id::e_Ddbj:
        return id.GetDdbj();
    default:
        NCBI_THROW(CObjMgrException, eIdMapperError, "Invalid seq-id type");
    }
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Pir_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Pir_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsPir();
}


const CTextseq_id& CSeq_id_Pir_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetPir();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Swissprot_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Swissprot_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsSwissprot();
}


const CTextseq_id& CSeq_id_Swissprot_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetSwissprot();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Prf_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Prf_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsPrf();
}


const CTextseq_id& CSeq_id_Prf_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetPrf();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Tpd_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Tpg_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsTpg();
}


const CTextseq_id& CSeq_id_Tpg_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetTpg();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Tpe_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Tpe_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsTpe();
}


const CTextseq_id& CSeq_id_Tpe_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetTpe();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Tpd_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Tpd_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsTpd();
}


const CTextseq_id& CSeq_id_Tpd_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetTpd();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Other_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Other_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsOther();
}


const CTextseq_id& CSeq_id_Other_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetOther();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Local_Tree
/////////////////////////////////////////////////////////////////////////////


CSeq_id_Local_Tree::CSeq_id_Local_Tree(void)
{
}


CSeq_id_Local_Tree::~CSeq_id_Local_Tree(void)
{
}


bool CSeq_id_Local_Tree::Empty(void) const
{
    return m_ByStr.empty() && m_ById.empty();
}


CSeq_id_Info* CSeq_id_Local_Tree::x_FindInfo(const CObject_id& oid) const
{
    if ( oid.IsStr() ) {
        TByStr::const_iterator it = m_ByStr.find(oid.GetStr());
        if (it != m_ByStr.end()) {
            return it->second;
        }
    }
    else if ( oid.IsId() ) {
        TById::const_iterator it = m_ById.find(oid.GetId());
        if (it != m_ById.end()) {
            return it->second;
        }
    }
    // Not found
    return 0;
}


CSeq_id_Handle CSeq_id_Local_Tree::FindInfo(const CSeq_id& id) const
{
    _ASSERT( id.IsLocal() );
    const CObject_id& oid = id.GetLocal();
    TReadLockGuard guard(m_TreeLock);
    return CSeq_id_Handle(x_FindInfo(oid));
}


CSeq_id_Handle CSeq_id_Local_Tree::FindOrCreate(const CSeq_id& id)
{
    _ASSERT(id.IsLocal());
    const CObject_id& oid = id.GetLocal();
    TWriteLockGuard guard(m_TreeLock);
    CSeq_id_Info* info = x_FindInfo(oid);
    if ( !info ) {
        info = CreateInfo(id);
        if ( oid.IsStr() ) {
            _VERIFY(m_ByStr.insert(TByStr::value_type(oid.GetStr(),
                                                      info)).second);
        }
        else if ( oid.IsId() ) {
            _VERIFY(m_ById.insert(TById::value_type(oid.GetId(),
                                                    info)).second);
        }
        else {
            NCBI_THROW(CObjMgrException, eIdMapperError,
                       "Can not create index for an empty local seq-id");
        }
    }
    return CSeq_id_Handle(info);
}


void CSeq_id_Local_Tree::x_Unindex(const CSeq_id_Info* info)
{
    CConstRef<CSeq_id> id = info->GetSeqId();
    _ASSERT(id->IsLocal());
    const CObject_id& oid = id->GetLocal();

    if ( oid.IsStr() ) {
        _VERIFY(m_ByStr.erase(oid.GetStr()));
    }
    else if ( oid.IsId() ) {
        _VERIFY(m_ById.erase(oid.GetId()));
    }
}


bool CSeq_id_Local_Tree::HaveMatch(const CSeq_id_Handle& ) const
{
    // Only one entry can match each id
    return false;
}


void CSeq_id_Local_Tree::FindMatch(const CSeq_id_Handle& id,
                                   TSeq_id_MatchList& id_list) const
{
    // Only one entry can match each id
    //_ASSERT(id && id == FindInfo(id.GetSeqId()));
    id_list.insert(id);
}


void CSeq_id_Local_Tree::FindMatchStr(string sid,
                                      TSeq_id_MatchList& id_list) const
{
    TReadLockGuard guard(m_TreeLock);
    // In any case search in strings
    TByStr::const_iterator str_it = m_ByStr.find(sid);
    if (str_it != m_ByStr.end()) {
        id_list.insert(CSeq_id_Handle(str_it->second));
    }
    else {
        try {
            int value = NStr::StringToInt(sid);
            TById::const_iterator int_it = m_ById.find(value);
            if (int_it != m_ById.end()) {
                id_list.insert(CSeq_id_Handle(int_it->second));
            }
        }
        catch (const CStringException& /*ignored*/) {
            // Not an integer value
            return;
        }
    }
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_General_Tree
/////////////////////////////////////////////////////////////////////////////


CSeq_id_General_Tree::CSeq_id_General_Tree(void)
{
}


CSeq_id_General_Tree::~CSeq_id_General_Tree(void)
{
}


bool CSeq_id_General_Tree::Empty(void) const
{
    return m_DbMap.empty();
}


CSeq_id_Info* CSeq_id_General_Tree::x_FindInfo(const CDbtag& dbid) const
{
    TDbMap::const_iterator db = m_DbMap.find(dbid.GetDb());
    if (db == m_DbMap.end())
        return 0;
    const STagMap& tm = db->second;
    const CObject_id& oid = dbid.GetTag();
    if ( oid.IsStr() ) {
        STagMap::TByStr::const_iterator it = tm.m_ByStr.find(oid.GetStr());
        if (it != tm.m_ByStr.end()) {
            return it->second;
        }
    }
    else if ( oid.IsId() ) {
        STagMap::TById::const_iterator it = tm.m_ById.find(oid.GetId());
        if (it != tm.m_ById.end()) {
            return it->second;
        }
    }
    // Not found
    return 0;
}


CSeq_id_Handle CSeq_id_General_Tree::FindInfo(const CSeq_id& id) const
{
    _ASSERT( id.IsGeneral() );
    const CDbtag& dbid = id.GetGeneral();
    TReadLockGuard guard(m_TreeLock);
    return CSeq_id_Handle(x_FindInfo(dbid));
}


CSeq_id_Handle CSeq_id_General_Tree::FindOrCreate(const CSeq_id& id)
{
    _ASSERT( id.IsGeneral() );
    const CDbtag& dbid = id.GetGeneral();
    TWriteLockGuard guard(m_TreeLock);
    CSeq_id_Info* info = x_FindInfo(dbid);
    if ( !info ) {
        info = CreateInfo(id);
        STagMap& tm = m_DbMap[dbid.GetDb()];
        const CObject_id& oid = dbid.GetTag();
        if ( oid.IsStr() ) {
            _VERIFY(tm.m_ByStr.insert
                    (STagMap::TByStr::value_type(oid.GetStr(), info)).second);
        }
        else if ( oid.IsId() ) {
            _VERIFY(tm.m_ById.insert(STagMap::TById::value_type(oid.GetId(),
                                                                info)).second);
        }
        else {
            NCBI_THROW(CObjMgrException, eIdMapperError,
                       "Can not create index for an empty db-tag");
        }
    }
    return CSeq_id_Handle(info);
}


void CSeq_id_General_Tree::x_Unindex(const CSeq_id_Info* info)