seq_id_tree.cpp

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

/*
 * ===========================================================================
 * PRODUCTION $Log: seq_id_tree.cpp,v $
 * PRODUCTION Revision 1000.4  2004/06/01 19:24:07  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.13
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: seq_id_tree.cpp,v 1000.4 2004/06/01 19:24:07 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Aleksey Grichenko, Eugene Vasilchenko
*
* File Description:
*   Seq-id mapper for Object Manager
*
*/

#include <ncbi_pch.hpp>
#include <objmgr/impl/seq_id_tree.hpp>
#include <objmgr/objmgr_exception.hpp>

BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)

/////////////////////////////////////////////////////////////////////////////
// to make map<string, something> case-insensitive

struct seqid_string_less
{
    bool operator()(const string& s1, const string& s2) const
    {
        return (NStr::CompareNocase(s1, s2) < 0);
    }
};


////////////////////////////////////////////////////////////////////
//
//  CSeq_id_***_Tree::
//
//    Seq-id sub-type specific trees
//

CSeq_id_Which_Tree::CSeq_id_Which_Tree(void)
{
}


CSeq_id_Which_Tree::~CSeq_id_Which_Tree(void)
{
}


bool CSeq_id_Which_Tree::HaveMatch(const CSeq_id_Handle& ) const
{
    return true; // Assume have matches by default
}


bool CSeq_id_Which_Tree::IsBetterVersion(const CSeq_id_Handle& /*h1*/,
                                         const CSeq_id_Handle& /*h2*/) const
{
    return false; // No id version by default
}


inline
CSeq_id_Info* CSeq_id_Which_Tree::CreateInfo(void)
{
    return new CSeq_id_Info(this);
}


bool CSeq_id_Which_Tree::HaveReverseMatch(const CSeq_id_Handle& ) const
{
    return false; // Assume no reverse matches by default
}


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


CSeq_id_Info* CSeq_id_Which_Tree::CreateInfo(const CSeq_id& id)
{
    CRef<CSeq_id> id_ref(new CSeq_id);
    id_ref->Assign(id);
    return new CSeq_id_Info(this, id_ref);
}


void CSeq_id_Which_Tree::DropInfo(const CSeq_id_Info* info)
{
    if ( info->GetCounter() > 0 ) {
        return;
    }

    {{
        TWriteLockGuard guard(m_TreeLock);
        if ( info->GetCounter() > 0 ) {
            return;
        }
        x_Unindex(info);
    }}

    delete info;
}


CSeq_id_Handle CSeq_id_Which_Tree::GetGiHandle(int /*gi*/)
{
    NCBI_THROW(CObjMgrException, eIdMapperError, "Invalid seq-id type");
}


void CSeq_id_Which_Tree::Initialize(vector<CRef<CSeq_id_Which_Tree> >& v)
{
    v.resize(CSeq_id::e_Tpd+1);
    v[CSeq_id::e_not_set].Reset(new CSeq_id_not_set_Tree);
    v[CSeq_id::e_Local].Reset(new CSeq_id_Local_Tree);
    v[CSeq_id::e_Gibbsq].Reset(new CSeq_id_Gibbsq_Tree);
    v[CSeq_id::e_Gibbmt].Reset(new CSeq_id_Gibbmt_Tree);
    v[CSeq_id::e_Giim].Reset(new CSeq_id_Giim_Tree);
    // These three types share the same accessions space
    CRef<CSeq_id_Which_Tree> gb(new CSeq_id_GB_Tree);
    v[CSeq_id::e_Genbank] = gb;
    v[CSeq_id::e_Embl] = gb;
    v[CSeq_id::e_Ddbj] = gb;
    v[CSeq_id::e_Pir].Reset(new CSeq_id_Pir_Tree);
    v[CSeq_id::e_Swissprot].Reset(new CSeq_id_Swissprot_Tree);
    v[CSeq_id::e_Patent].Reset(new CSeq_id_Patent_Tree);
    v[CSeq_id::e_Other].Reset(new CSeq_id_Other_Tree);
    v[CSeq_id::e_General].Reset(new CSeq_id_General_Tree);
    v[CSeq_id::e_Gi].Reset(new CSeq_id_Gi_Tree);
    // see above    v[CSeq_id::e_Ddbj] = gb;
    v[CSeq_id::e_Prf].Reset(new CSeq_id_Prf_Tree);
    v[CSeq_id::e_Pdb].Reset(new CSeq_id_PDB_Tree);
    v[CSeq_id::e_Tpg].Reset(new CSeq_id_Tpg_Tree);
    v[CSeq_id::e_Tpe].Reset(new CSeq_id_Tpe_Tree);
    v[CSeq_id::e_Tpd].Reset(new CSeq_id_Tpd_Tree);
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_not_set_Tree
/////////////////////////////////////////////////////////////////////////////

CSeq_id_not_set_Tree::CSeq_id_not_set_Tree(void)
{
}


CSeq_id_not_set_Tree::~CSeq_id_not_set_Tree(void)
{
}


bool CSeq_id_not_set_Tree::Empty(void) const
{
    return true;
}


inline
bool CSeq_id_not_set_Tree::x_Check(const CSeq_id& id) const
{
    return id.Which() == CSeq_id::e_not_set;
}


void CSeq_id_not_set_Tree::DropInfo(const CSeq_id_Info* /*info*/)
{
}


void CSeq_id_not_set_Tree::x_Unindex(const CSeq_id_Info* /*info*/)
{
}


CSeq_id_Handle CSeq_id_not_set_Tree::FindInfo(const CSeq_id& /*id*/) const
{
    LOG_POST(Warning << "CSeq_id_Mapper::GetHandle() -- uninitialized seq-id");
    return CSeq_id_Handle();
}


CSeq_id_Handle CSeq_id_not_set_Tree::FindOrCreate(const CSeq_id& /*id*/)
{
    LOG_POST(Warning << "CSeq_id_Mapper::GetHandle() -- uninitialized seq-id");
    return CSeq_id_Handle();
}


bool CSeq_id_not_set_Tree::HaveMatch(const CSeq_id_Handle& ) const
{
    return false;
}


void CSeq_id_not_set_Tree::FindMatch(const CSeq_id_Handle& /*id*/,
                                     TSeq_id_MatchList& /*id_list*/) const
{
    LOG_POST(Warning << "CSeq_id_Mapper::GetMatchingHandles() -- "
             "uninitialized seq-id");
}


void CSeq_id_not_set_Tree::FindMatchStr(string /*sid*/,
                                        TSeq_id_MatchList& /*id_list*/) const
{
}


bool CSeq_id_not_set_Tree::HaveReverseMatch(const CSeq_id_Handle& /*id*/) const
{
    return false;
}


void CSeq_id_not_set_Tree::FindReverseMatch(const CSeq_id_Handle& /*id*/,
                                            TSeq_id_MatchList& /*id_list*/)
{
    LOG_POST(Warning << "CSeq_id_Mapper::GetReverseMatchingHandles() -- "
             "uninitialized seq-id");
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_int_Tree
/////////////////////////////////////////////////////////////////////////////


CSeq_id_int_Tree::CSeq_id_int_Tree(void)
{
}


CSeq_id_int_Tree::~CSeq_id_int_Tree(void)
{
}


bool CSeq_id_int_Tree::Empty(void) const
{
    return m_IntMap.empty();
}


CSeq_id_Handle CSeq_id_int_Tree::FindInfo(const CSeq_id& id) const
{
    _ASSERT(x_Check(id));
    int value = x_Get(id);

    TReadLockGuard guard(m_TreeLock);
    TIntMap::const_iterator it = m_IntMap.find(value);
    if (it != m_IntMap.end()) {
        return CSeq_id_Handle(it->second);
    }
    return CSeq_id_Handle();
}


CSeq_id_Handle CSeq_id_int_Tree::FindOrCreate(const CSeq_id& id)
{
    _ASSERT(x_Check(id));
    int value = x_Get(id);

    TWriteLockGuard guard(m_TreeLock);
    pair<TIntMap::iterator, bool> ins =
        m_IntMap.insert(TIntMap::value_type(value, 0));
    if ( ins.second ) {
        ins.first->second = CreateInfo(id);
    }
    return CSeq_id_Handle(ins.first->second);
}


void CSeq_id_int_Tree::x_Unindex(const CSeq_id_Info* info)
{
    _ASSERT(x_Check(*info->GetSeqId()));
    int value = x_Get(*info->GetSeqId());

    _VERIFY(m_IntMap.erase(value));
}


bool CSeq_id_int_Tree::HaveMatch(const CSeq_id_Handle& ) const
{
    // Only one instance of each int id
    return false;
}


void CSeq_id_int_Tree::FindMatch(const CSeq_id_Handle& id,
                                 TSeq_id_MatchList& id_list) const
{
    // Only one instance of each int id
    //_ASSERT(id && id == FindInfo(id.GetSeqId()));
    id_list.insert(id);
}


void CSeq_id_int_Tree::FindMatchStr(string sid,
                                    TSeq_id_MatchList& id_list) const
{
    int value;
    try {
        value = NStr::StringToInt(sid);
    }
    catch (const CStringException& /*ignored*/) {
        // Not an integer value
        return;
    }
    TReadLockGuard guard(m_TreeLock);
    TIntMap::const_iterator it = m_IntMap.find(value);
    if (it != m_IntMap.end()) {
        id_list.insert(CSeq_id_Handle(it->second));
    }
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Gibbsq_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Gibbsq_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsGibbsq();
}


int CSeq_id_Gibbsq_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetGibbsq();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Gibbmt_Tree
/////////////////////////////////////////////////////////////////////////////

bool CSeq_id_Gibbmt_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsGibbmt();
}


int CSeq_id_Gibbmt_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetGibbmt();
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Gi_Tree
/////////////////////////////////////////////////////////////////////////////

CSeq_id_Gi_Tree::CSeq_id_Gi_Tree(void)
    : m_Info(CreateInfo())
{
}


CSeq_id_Gi_Tree::~CSeq_id_Gi_Tree(void)
{
    _ASSERT(m_Info);
    m_Info.Reset();
}


bool CSeq_id_Gi_Tree::Empty(void) const
{
    return true;
}


inline
bool CSeq_id_Gi_Tree::x_Check(const CSeq_id& id) const
{
    return id.IsGi();
}


inline
int CSeq_id_Gi_Tree::x_Get(const CSeq_id& id) const
{
    return id.GetGi();
}


void CSeq_id_Gi_Tree::DropInfo(const CSeq_id_Info* info)
{
    _ASSERT(!m_Info);
    delete info;
}


void CSeq_id_Gi_Tree::x_Unindex(const CSeq_id_Info* /*info*/)
{
}


CSeq_id_Handle CSeq_id_Gi_Tree::GetGiHandle(int gi)
{
    return CSeq_id_Handle(m_Info, gi);
}


CSeq_id_Handle CSeq_id_Gi_Tree::FindInfo(const CSeq_id& id) const
{
    _ASSERT(x_Check(id));
    return CSeq_id_Handle(m_Info, x_Get(id));
}


CSeq_id_Handle CSeq_id_Gi_Tree::FindOrCreate(const CSeq_id& id)
{
    _ASSERT(x_Check(id));
    return CSeq_id_Handle(m_Info, x_Get(id));
}


bool CSeq_id_Gi_Tree::HaveMatch(const CSeq_id_Handle& ) const
{
    // Only one instance of each int id
    return false;
}


void CSeq_id_Gi_Tree::FindMatch(const CSeq_id_Handle& id, TSeq_id_MatchList& id_list) const
{
    // Only one instance of each int id
    id_list.insert(id);
}


void CSeq_id_Gi_Tree::FindMatchStr(string sid,
                                    TSeq_id_MatchList& id_list) const
{
    int value;
    try {
        value = NStr::StringToInt(sid);
    }
    catch (const CStringException& /*ignored*/) {
        // Not an integer value
        return;
    }
    id_list.insert(CSeq_id_Handle(m_Info, value));
}


/////////////////////////////////////////////////////////////////////////////
// CSeq_id_Textseq_Tree
/////////////////////////////////////////////////////////////////////////////


CSeq_id_Textseq_Tree::CSeq_id_Textseq_Tree(void)
{
}


CSeq_id_Textseq_Tree::~CSeq_id_Textseq_Tree(void)
{
}


bool CSeq_id_Textseq_Tree::Empty(void) const
{
    return m_ByName.empty() && m_ByAccession.empty();
}


CSeq_id_Info*
CSeq_id_Textseq_Tree::x_FindVersionEqual(const TVersions& ver_list,
                                         const CTextseq_id& tid) const
{
    ITERATE(TVersions, vit, ver_list) {
        if (x_Get(*(*vit)->GetSeqId()).Equals(tid)) {
            return *vit;
        }
    }
    return 0;
}


CSeq_id_Info* CSeq_id_Textseq_Tree::x_FindInfo(const CTextseq_id& tid) const
{
    TStringMap::const_iterator it;
    if ( tid.IsSetAccession() ) {
        it = m_ByAccession.find(tid.GetAccession());
        if (it == m_ByAccession.end()) {
            return 0;
        }
    }
    else if ( tid.IsSetName() ) {
        it = m_ByName.find(tid.GetName());
        if (it == m_ByName.end()) {
            return 0;
        }
    }
    else {
        return 0;
    }
    return x_FindVersionEqual(it->second, tid);
}


CSeq_id_Handle CSeq_id_Textseq_Tree::FindInfo(const CSeq_id& id) const
{
    // Note: if a record is found by accession, no name is checked
    // even if it is also set.
    _ASSERT(x_Check(id));
    const CTextseq_id& tid = x_Get(id);
    // Can not compare if no accession given
    TReadLockGuard guard(m_TreeLock);
    return CSeq_id_Handle(x_FindInfo(tid));
}

CSeq_id_Handle CSeq_id_Textseq_Tree::FindOrCreate(const CSeq_id& id)
{
    _ASSERT(x_Check(id));
    const CTextseq_id& tid = x_Get(id);
    TWriteLockGuard guard(m_TreeLock);
    CSeq_id_Info* info = x_FindInfo(tid);
    if ( !info ) {
        info = CreateInfo(id);

        if ( tid.IsSetAccession() ) {
            TVersions& ver = m_ByAccession[tid.GetAccession()];
            ITERATE(TVersions, vit, ver) {
                _ASSERT(!x_Get(*(*vit)->GetSeqId()).Equals(tid));
            }