object_manager.cpp

来自「ncbi源码」· C++ 代码 · 共 573 行 · 第 1/2 页

/*
 * ===========================================================================
 * PRODUCTION $Log: object_manager.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 19:23:28  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.33
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: object_manager.cpp,v 1000.2 2004/06/01 19:23:28 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.
*
* ===========================================================================
*
* Authors:
*           Andrei Gourianov
*           Aleksey Grichenko
*           Michael Kimelman
*           Denis Vakatov
*
* File Description:
*           Object manager manages data objects,
*           provides them to Scopes when needed
*
*/

#include <ncbi_pch.hpp>
#include <objmgr/object_manager.hpp>
#include <objmgr/data_loader.hpp>
#include <objmgr/impl/scope_impl.hpp>
#include <objmgr/impl/data_source.hpp>
#include <objmgr/objmgr_exception.hpp>

#include <objects/seqset/Seq_entry.hpp>

BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)

CObjectManager::CObjectManager(void)
{
  //LOG_POST("CObjectManager - new :" << this );
}


CObjectManager::~CObjectManager(void)
{
    //LOG_POST("~CObjectManager - delete " << this );
    // delete scopes
    TWriteLockGuard guard(m_OM_Lock);

    if(!m_setScope.empty()) {
        ERR_POST("Attempt to delete Object Manager with open scopes");
        while ( !m_setScope.empty() ) {
            // this will cause calling RegisterScope and changing m_setScope
            // be careful with data access synchronization
            (*m_setScope.begin())->x_DetachFromOM();
        }
    }
    // release data sources

    m_setDefaultSource.clear();
    
    while (!m_mapToSource.empty()) {
        CDataSource* pSource = m_mapToSource.begin()->second.GetPointer();
        _ASSERT(pSource);
        if ( !pSource->ReferencedOnlyOnce() ) {
            ERR_POST("Attempt to delete Object Manager with used data sources");
        }
        m_mapToSource.erase(m_mapToSource.begin());
    }
    // LOG_POST("~CObjectManager - delete " << this << "  done");
}

/////////////////////////////////////////////////////////////////////////////
// configuration functions


void CObjectManager::RegisterDataLoader(CDataLoader& loader,
                                        EIsDefault   is_default,
                                        CPriorityNode::TPriority priority)
{
    TWriteLockGuard guard(m_OM_Lock);
    x_RegisterLoader(loader, priority, is_default);
}


void CObjectManager::RegisterDataLoader(CDataLoaderFactory& factory,
                                        EIsDefault is_default,
                                        CPriorityNode::TPriority priority)
{
    string loader_name = factory.GetName();
    _ASSERT(!loader_name.empty());
    // if already registered
    TWriteLockGuard guard(m_OM_Lock);
    if ( x_GetLoaderByName(loader_name) ) {
        ERR_POST(Warning <<
            "CObjectManager::RegisterDataLoader: " <<
            "data loader " << loader_name << " already registered");
        return;
    }
    // in case factory was not put in a CRef container by the caller
    // it will be deleted here
    CRef<CDataLoaderFactory> p(&factory);
    // create loader
    CDataLoader* loader = factory.Create();
    // register
    x_RegisterLoader(*loader, priority, is_default);
}


void CObjectManager::RegisterDataLoader(TFACTORY_AUTOCREATE factory,
                                        const string& loader_name,
                                        EIsDefault is_default,
                                        CPriorityNode::TPriority priority)
{
    _ASSERT(!loader_name.empty());
    // if already registered
    TWriteLockGuard guard(m_OM_Lock);
    if ( x_GetLoaderByName(loader_name) ) {
        ERR_POST(Warning <<
            "CObjectManager::RegisterDataLoader: " <<
            "data loader " << loader_name << " already registered");
        return;
    }
    // create one
    CDataLoader* loader = CREATE_AUTOCREATE(CDataLoader,factory);
    loader->SetName(loader_name);
    // register
    x_RegisterLoader(*loader, priority, is_default);
}


bool CObjectManager::RevokeDataLoader(CDataLoader& loader)
{
    string loader_name = loader.GetName();

    TWriteLockGuard guard(m_OM_Lock);
    // make sure it is registered
    CDataLoader* my_loader = x_GetLoaderByName(loader_name);
    if ( my_loader != &loader ) {
        NCBI_THROW(CObjMgrException, eRegisterError,
            "Data loader " + loader_name + " not registered");
    }
    TDataSourceLock lock = x_RevokeDataLoader(&loader);
    guard.Release();
    return lock;
}


bool CObjectManager::RevokeDataLoader(const string& loader_name)
{
    TWriteLockGuard guard(m_OM_Lock);
    CDataLoader* loader = x_GetLoaderByName(loader_name);
    // if not registered
    if ( !loader ) {
        NCBI_THROW(CObjMgrException, eRegisterError,
            "Data loader " + loader_name + " not registered");
    }
    TDataSourceLock lock = x_RevokeDataLoader(loader);
    guard.Release();
    return lock;
}


CObjectManager::TDataSourceLock
CObjectManager::x_RevokeDataLoader(CDataLoader* loader)
{
    TMapToSource::iterator iter = m_mapToSource.find(loader);
    _ASSERT(iter != m_mapToSource.end());
    _ASSERT(iter->second->GetDataLoader() == loader);
    bool is_default = m_setDefaultSource.erase(iter->second) != 0;
    if ( !iter->second->ReferencedOnlyOnce() ) {
        // this means it is in use
        if ( is_default )
            _VERIFY(m_setDefaultSource.insert(iter->second).second);
        ERR_POST("CObjectManager::RevokeDataLoader: "
                 "data loader is in use");
        return TDataSourceLock();
    }
    // remove from the maps
    TDataSourceLock lock(iter->second);
    m_mapNameToLoader.erase(loader->GetName());
    m_mapToSource.erase(loader);
    return lock;
}


/*
void CObjectManager::RegisterTopLevelSeqEntry(CSeq_entry& top_entry)
{
    TWriteLockGuard guard(m_OM_Mutex);
    x_RegisterTSE(top_entry);
}
*/

/////////////////////////////////////////////////////////////////////////////
// functions for scopes

void CObjectManager::RegisterScope(CScope_Impl& scope)
{
    TWriteLockGuard guard(m_OM_ScopeLock);
    _VERIFY(m_setScope.insert(&scope).second);
}


void CObjectManager::RevokeScope(CScope_Impl& scope)
{
    TWriteLockGuard guard(m_OM_ScopeLock);
    _VERIFY(m_setScope.erase(&scope));
}


void CObjectManager::AcquireDefaultDataSources(TDataSourcesLock& sources)
{
    TReadLockGuard guard(m_OM_Lock);
    sources = m_setDefaultSource;
}


CObjectManager::TDataSourceLock
CObjectManager::AcquireDataLoader(CDataLoader& loader)
{
    TReadLockGuard guard(m_OM_Lock);
    TDataSourceLock lock = x_FindDataSource(&loader);
    if ( !lock ) {
        guard.Release();
        TWriteLockGuard wguard(m_OM_Lock);
        lock = x_RegisterLoader(loader, kPriority_NotSet, eNonDefault, true);
    }
    return lock;
}


CObjectManager::TDataSourceLock
CObjectManager::AcquireDataLoader(const string& loader_name)
{
    TReadLockGuard guard(m_OM_Lock);
    CDataLoader* loader = x_GetLoaderByName(loader_name);
    if ( !loader ) {
        NCBI_THROW(CObjMgrException, eRegisterError,
            "Data loader " + loader_name + " not found");
    }
    TDataSourceLock lock = x_FindDataSource(loader);
    _ASSERT(lock);
    return lock;
}


CObjectManager::TDataSourceLock
CObjectManager::AcquireTopLevelSeqEntry(CSeq_entry& top_entry)
{
    TReadLockGuard guard(m_OM_Lock);
    TDataSourceLock lock = x_FindDataSource(&top_entry);
    if ( !lock ) {
        guard.Release();
        
        TDataSourceLock source(new CDataSource(top_entry, *this));
        source->DoDeleteThisObject();
        
        TWriteLockGuard wguard(m_OM_Lock);
        lock = m_mapToSource.insert(
            TMapToSource::value_type(&top_entry, source)).first->second;
        _ASSERT(lock);
    }
    return lock;
}