tse_info.hpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: tse_info.hpp,v $
 * PRODUCTION Revision 1000.2  2004/04/12 17:28:46  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.49
 * PRODUCTION
 * ===========================================================================
 */

#ifndef OBJECTS_OBJMGR_IMPL___TSE_INFO__HPP
#define OBJECTS_OBJMGR_IMPL___TSE_INFO__HPP

/*  $Id: tse_info.hpp,v 1000.2 2004/04/12 17:28:46 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:
*   TSE info -- entry for data source seq-id to TSE map
*
*/


#include <objmgr/impl/seq_entry_info.hpp>
#include <objmgr/annot_selector.hpp>
#include <objmgr/seq_id_handle.hpp>

#include <util/rangemap.hpp>
#include <corelib/ncbiobj.hpp>
#include <corelib/ncbimtx.hpp>
#include <objmgr/impl/annot_object_index.hpp>

#include <map>
#include <set>
#include <vector>

BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)

class CScope_Impl;
class CBioseq_Info;
class CSeq_entry_Info;
class CSeq_annot_Info;
class CSeq_annot_SNP_Info;
class CTSE_Chunk_Info;
class CTSE_Info_Object;

class CDataSource;
class CHandleRange;
class CAnnotObject_Info;
class CAnnotTypes_CI;
class CSeq_entry;

////////////////////////////////////////////////////////////////////
//
//  CTSE_Info::
//
//    General information and indexes for top level seq-entries
//


struct NCBI_XOBJMGR_EXPORT SIdAnnotObjs
{
    SIdAnnotObjs(void);
    ~SIdAnnotObjs(void);
    SIdAnnotObjs(const SIdAnnotObjs& objs);
    
    typedef CRange<TSeqPos>                                  TRange;
    typedef CRangeMultimap<SAnnotObject_Index, TSeqPos>      TRangeMap;
    typedef vector<TRangeMap>                                TAnnotSet;
    typedef vector<CConstRef<CSeq_annot_SNP_Info> >          TSNPSet;

    TAnnotSet m_AnnotSet;
    TSNPSet   m_SNPSet;

private:
    const SIdAnnotObjs& operator=(const SIdAnnotObjs& objs);
};


class NCBI_XOBJMGR_EXPORT CTSE_Info : public CSeq_entry_Info
{
    typedef CSeq_entry_Info TParent;
public:
    // 'ctors
    // Argument tse will be parentized.
    explicit CTSE_Info(CSeq_entry& tse,
                       bool dead = false,
                       const CObject* blob_id = 0);
    explicit CTSE_Info(const CTSE_Info& info);
    virtual ~CTSE_Info(void);

    bool HasDataSource(void) const;
    CDataSource& GetDataSource(void) const;

    CConstRef<CSeq_entry> GetCompleteTSE(void) const;
    CConstRef<CSeq_entry> GetTSECore(void) const;

    const CTSE_Info& GetTSE_Info(void) const;
    CTSE_Info& GetTSE_Info(void);

    bool IsDead(void) const;
    void SetDead(bool dead);
    bool Locked(void) const;

    const CAnnotName& GetName(void) const;
    void SetName(const CAnnotName& name);

    bool HasAnnot(const CAnnotName& name) const;
    bool HasUnnamedAnnot(void) const;
    bool HasNamedAnnot(const string& name) const;

    const CConstRef<CObject>& GetBlobId(void) const;
    void SetBlobId(const CObject* blob_id);

    // indexes types
    typedef map<int, CBioseq_set_Info*>                      TBioseq_sets;
    typedef map<CSeq_id_Handle, CBioseq_Info*>               TBioseqs;

    typedef SIdAnnotObjs::TRange                             TRange;
    typedef SIdAnnotObjs::TRangeMap                          TRangeMap;
    typedef SIdAnnotObjs::TAnnotSet                          TAnnotSet;
    typedef SIdAnnotObjs::TSNPSet                            TSNPSet;

    typedef map<CSeq_id_Handle, SIdAnnotObjs>                TAnnotObjs;
    typedef map<CAnnotName, TAnnotObjs>                      TNamedAnnotObjs;
    typedef set<CAnnotName>                                  TNames;
    typedef map<CSeq_id_Handle, TNames>                      TSeqIdToNames;

    typedef int                                              TChunkId;
    typedef map<TChunkId, CRef<CTSE_Chunk_Info> >            TChunks;

    bool ContainsSeqid(const CSeq_id_Handle& id) const;
    CConstRef<CBioseq_Info> FindBioseq(const CSeq_id_Handle& key) const;

    void UpdateAnnotIndex(void) const;
    void UpdateAnnotIndex(const CTSE_Info_Object& object) const;
    void UpdateAnnotIndex(void);
    void UpdateAnnotIndex(CTSE_Info_Object& object);

    virtual void DebugDump(CDebugDumpContext ddc, unsigned int depth) const;

    void x_DSAttachContents(CDataSource& ds);
    void x_DSDetachContents(CDataSource& ds);
    
    virtual void x_SetDirtyAnnotIndexNoParent(void);
    virtual void x_ResetDirtyAnnotIndexNoParent(void);

    CRef<CTSE_Chunk_Info> GetNotLoadedChunk(void);
    void LoadAllChunks(void);

private:
    friend class CTSE_Guard;
    friend class CDataSource;
    friend class CScope_Impl;
    friend class CDataLoader;
    friend class CAnnot_Collector;
    friend class CSeq_entry_Info;
    friend class CSeq_annot_Info;
    friend class CBioseq_Info;
    friend class CBioseq_set_Info;
    friend class CTSE_Chunk_Info;
    friend class CSeq_annot_SNP_Info;
    friend struct SAnnotSelector;

    CBioseq_set_Info& GetBioseq_set(int id);
    CBioseq_Info& GetBioseq(int gi);
    
    void x_DSMapObject(CConstRef<TObject> obj, CDataSource& ds);
    void x_DSUnmapObject(CConstRef<TObject> obj, CDataSource& ds);

    void x_SetBioseqId(const CSeq_id_Handle& key, CBioseq_Info* info);
    void x_ResetBioseqId(const CSeq_id_Handle& key, CBioseq_Info* info);
    void x_SetBioseq_setId(int key, CBioseq_set_Info* info);
    void x_ResetBioseq_setId(int key, CBioseq_set_Info* info);

    // index access methods
    TAnnotObjs& x_SetAnnotObjs(const CAnnotName& name);
    const TAnnotObjs* x_GetAnnotObjs(const CAnnotName& name) const;
    const TAnnotObjs* x_GetUnnamedAnnotObjs(void) const;
    void x_RemoveAnnotObjs(const CAnnotName& name);
    const SIdAnnotObjs* x_GetIdObjects(const TAnnotObjs& objs,
                                       const CSeq_id_Handle& idh) const;
    const SIdAnnotObjs* x_GetIdObjects(const CAnnotName& name,
                                       const CSeq_id_Handle& id) const;
    const SIdAnnotObjs* x_GetUnnamedIdObjects(const CSeq_id_Handle& id) const;
    SIdAnnotObjs& x_SetIdObjects(TAnnotObjs& objs,
                                 const CAnnotName& name,
                                 const CSeq_id_Handle& id);
    SIdAnnotObjs& x_SetIdObjects(const CAnnotName& name,
                                 const CSeq_id_Handle& idh);

    void x_MapSNP_Table(const CAnnotName& name,
                        const CSeq_id_Handle& key,
                        const CSeq_annot_SNP_Info& snp_info);
    void x_UnmapSNP_Table(const CAnnotName& name,
                          const CSeq_id_Handle& key,
                          const CSeq_annot_SNP_Info& snp_info);

    void x_MapAnnotObject(TRangeMap& rangeMap,
                          const SAnnotObject_Key& key,
                          const SAnnotObject_Index& annotRef);
    bool x_UnmapAnnotObject(TRangeMap& rangeMap,
                            const SAnnotObject_Key& key);
    void x_MapAnnotObject(SIdAnnotObjs& objs,
                          const SAnnotObject_Key& key,
                          const SAnnotObject_Index& annotRef);
    bool x_UnmapAnnotObject(SIdAnnotObjs& objs,
                            const SAnnotObject_Key& key);
    void x_MapAnnotObject(TAnnotObjs& objs,
                          const CAnnotName& name,
                          const SAnnotObject_Key& key,
                          const SAnnotObject_Index& annotRef);
    void x_MapAnnotObject(TAnnotObjs& index,
                          const SAnnotObject_Key& key,
                          const SAnnotObject_Index& annotRef,
                          SAnnotObjects_Info& infos);
    void x_MapAnnotObject(const SAnnotObject_Key& key,
                          const SAnnotObject_Index& annotRef,
                          SAnnotObjects_Info& infos);

    bool x_UnmapAnnotObject(TAnnotObjs& objs,
                            const CAnnotName& name,
                            const SAnnotObject_Key& key);
    void x_UnmapAnnotObjects(SAnnotObjects_Info& infos);

    void x_IndexSeqTSE(const CSeq_id_Handle& id);
    void x_UnindexSeqTSE(const CSeq_id_Handle& id);
    void x_IndexAnnotTSE(const CAnnotName& name, const CSeq_id_Handle& id);
    void x_UnindexAnnotTSE(const CAnnotName& name, const CSeq_id_Handle& id);

    // Parent data-source
    CDataSource*           m_DataSource;

    // Dead seq-entry flag
    bool                   m_Dead;

    // TSE has name
    CAnnotName             m_Name;

    // May be used by data loaders to store blob-id
    typedef CConstRef<CObject> TBlob_ID;
    TBlob_ID               m_Blob_ID;

    typedef CRWLock        TAnnotObjsLock;
    typedef TAnnotObjsLock::TReadLockGuard  TAnnotReadLockGuard;
    typedef TAnnotObjsLock::TWriteLockGuard TAnnotWriteLockGuard;

    // ID to bioseq-info
    TBioseq_sets           m_Bioseq_sets;
    TBioseqs               m_Bioseqs;

    // ID to annot-selector-map
    TNamedAnnotObjs        m_NamedAnnotObjs;
    TSeqIdToNames          m_SeqIdToNames;
    mutable TAnnotObjsLock m_AnnotObjsLock;

    TChunks                m_Chunks;

    // Hide copy methods
    CTSE_Info& operator= (const CTSE_Info&);

};


typedef CConstRef<CTSE_Info> TTSE_Lock;

/////////////////////////////////////////////////////////////////////
//
//  Inline methods
//
/////////////////////////////////////////////////////////////////////