C++ (Cpp) NCBI_INTERFACE_VERSION Exemples

Exemple #1

 /// Create instance of TDriver
 virtual TInterface*
 CreateInstance(const string& driver  = kEmptyStr,
                CVersionInfo version = NCBI_INTERFACE_VERSION(IFace),
                const TPluginManagerParamTree* params = 0) const
 {
     if (params && (driver.empty() || driver == m_DriverName) &&
             version.Match(NCBI_INTERFACE_VERSION(IFace)) !=
                 CVersionInfo::eNonCompatible) {
         CConfig config(params);
         return new SNetCacheAPIImpl(&config, m_DriverName,
             kEmptyStr, kEmptyStr);
     }
     return NULL;
 }

Exemple #2

Fichier : id2snp.cpp Projet : svn2github/ncbi_tk

 objects::CID2Processor* 
 CreateInstance(const string& driver  = kEmptyStr,
                CVersionInfo version =
                NCBI_INTERFACE_VERSION(objects::CID2Processor),
                const TPluginManagerParamTree* params = 0) const
 {
     objects::CID2Processor* drv = 0;
     if ( !driver.empty()  &&  driver != m_DriverName ) {
         return 0;
     }
     if (version.Match(NCBI_INTERFACE_VERSION(objects::CID2Processor)) 
                         != CVersionInfo::eNonCompatible) {
         drv = new objects::CID2SNPProcessor(params, driver);
     }
     return drv;
 }

Exemple #3

Fichier : blob_storage_netcache.cpp Projet : DmitrySigaev/ncbi

IBlobStorage* CBlobStorageNetCacheCF::CreateInstance(
    const string& driver,
    CVersionInfo version,
    const TPluginManagerParamTree* params) const
{
    if (driver.empty() || driver == m_DriverName) {
        if (version.Match(NCBI_INTERFACE_VERSION(IBlobStorage))
            != CVersionInfo::eNonCompatible && params) {

            CConfig config(params);

            CNetCacheAPI nc_client(&config, kNetCacheAPIDriverName);

            return new CBlobStorage_NetCache(nc_client);
        }
    }
    return 0;
}

Exemple #4

Fichier : cgiapp_cached.cpp Projet : swuecho/igblast

ICache* CCgiApplicationCached::GetCacheStorage() const
{ 
    if (!m_CacheTreeParams || m_CacheDriverName.empty() )
        return NULL;
    
    typedef CPluginManager<ICache> TCacheManager; 
    typedef CPluginManagerGetter<ICache> TCacheManagerStore;
 
     CRef<TCacheManager> cache_manager( TCacheManagerStore::Get() );
    
     _ASSERT( cache_manager );
      
     return cache_manager->CreateInstance(
         m_CacheDriverName,
         NCBI_INTERFACE_VERSION(ICache),
         m_CacheTreeParams
         );
}

Exemple #5

// xcache_dbapi factory ...
ICache*
MakeICache(void)
{
    typedef CPluginManager<ICache> TCacheManager; 
    typedef CPluginManagerGetter<ICache> TCacheManagerStore;

    CRef<TCacheManager> cache_manager( TCacheManagerStore::Get() );
    auto_ptr<TPluginManagerParamTree> params( MakeParamTree() );
    ICache* drv = NULL;

    _ASSERT( cache_manager );
    
    drv = cache_manager->CreateInstance(
        "dbapi",
        NCBI_INTERFACE_VERSION(ICache),
        params.get()
        );
        
    return drv;
}

Exemple #6

ICache* CDBAPI_BlobCacheCF::CreateInstance(
           const string&                  driver,
           CVersionInfo                   version,
           const TPluginManagerParamTree* params) const
{
    auto_ptr<CDBAPI_Cache> drv;
    if (driver.empty() || driver == m_DriverName) {
        if (version.Match(NCBI_INTERFACE_VERSION(ICache))
                            != CVersionInfo::eNonCompatible) {
            drv.reset(new CDBAPI_Cache());
        }
    } else {
        return 0;
    }

    if (!params)
        return drv.release();

    const string& tree_id = params->GetKey();
    if (NStr::CompareNocase(tree_id, kDBAPI_BlobCacheDriverName) != 0) {
        LOG_POST_X(2, Warning
          << "ICache class factory: Top level Id does not match driver name."
          << " Id = " << tree_id << " driver=" << kDBAPI_BlobCacheDriverName
          << " parameters ignored." );

        return drv.release();
    }

    // cache configuration

    const string& conn_str =
        GetParam(params, kCFParam_connection, false);

    const string& temp_dir =
        GetParam(params, kCFParam_temp_dir, false);
    const string& temp_prefix =
        GetParam(params, kCFParam_temp_prefix, false);

    if (!conn_str.empty()) {
        const void* ptr = NStr::StringToPtr(conn_str);
        IConnection* conn = (IConnection*)ptr;
        drv->Open(conn, temp_dir, temp_prefix);
    } else {
        const string& drv_str =
            GetParam(params, kCFParam_driver, true);
        const string& server =
            GetParam(params, kCFParam_server, true);
        const string& database =
            GetParam(params, kCFParam_database, true);

        string login =
            GetParam(params, kCFParam_login, false, kCFParam_login_default);
        string password =
            GetParam(params,
                     kCFParam_password, false, kCFParam_password_default);

        drv->Open(drv_str, server, database,
                  login, password,
                  temp_dir, temp_prefix);

    }

    const string& mem_size_str =
        GetParam(params, kCFParam_mem_size, false, "0");
    unsigned mem_size = 0;
    
    try {
        mem_size = NStr::StringToUInt(mem_size_str);
    } catch(const CStringException&) {
        // ignore
    }
    if (mem_size) {
        drv->SetMemBufferSize(mem_size);
    }

    return drv.release();
}