void ASI::RemoveFromLayout(CRef& cref, CRef& layout) { Component* pLayoutComponent = layout.GetInstance(); if (pLayoutComponent != NULL) { int funcSet = pLayoutComponent->GetFuncSet("{f742f223-bb7b-48f0-92a8-81702e14de16}"); int emitter = pLayoutComponent->GetEmitter("{b11a0db4-cb96-4bf6-9631-fd96f20ea6ab}"); int receiver = pLayoutComponent->GetReceiver("{6a7ab00f-1ab4-4324-9eb4-e614bfca4a16}"); if ((funcSet != -1) && (emitter != -1) && (receiver != -1)) { Component* pComponent = cref.GetInstance(); if (pComponent != NULL) { if (pComponent->m_pData->inLayout && IsParent(pLayoutComponent, pComponent)) { /* * Tell the layout component to remove * the item with the given CRef id. */ DRef dref = NewData(BOI_STD_D(Int)); *dref.GetWriteInstance<int>() = cref.Id(); pLayoutComponent->CallFunc(funcSet, 2, dref, true); DisconnectFromReceiver(pLayoutComponent, emitter, cref); DisconnectFromReceiver(pComponent, BOI_STD_E(ParentBoundingBox), layout); pComponent->m_pData->inLayout = false; CRef invalidCRef; pComponent->SetParent(invalidCRef); } cref.ReleaseInstance(); } } layout.ReleaseInstance(); } }
void CBlastScopeSource::AddDataLoaders(CRef<objects::CScope> scope) { const int blastdb_loader_priority = kBlastDbLoaderPriority + (s_CountBlastDbDataLoaders() - 1); // Note that these priorities are needed so that the CScope::AddXXX methods // don't need a specific priority (the default will be fine). if (!m_BlastDbLoaderName.empty()) { _TRACE("Adding " << m_BlastDbLoaderName << " at priority " << blastdb_loader_priority); scope->AddDataLoader(m_BlastDbLoaderName, blastdb_loader_priority); } if (!m_GbLoaderName.empty()) { _TRACE("Adding " << m_GbLoaderName << " at priority " << (int)CBlastScopeSource::kGenbankLoaderPriority); scope->AddDataLoader(m_GbLoaderName, kGenbankLoaderPriority); } }
bool CPrefetchManager::IsActive(void) { CThreadPool_Thread* thread = dynamic_cast<CThreadPool_Thread*>( CThread::GetCurrentThread()); if ( !thread ) { return false; } CRef<CThreadPool_Task> req = thread->GetCurrentTask(); if ( !req ) { return false; } if ( req->IsCancelRequested() && dynamic_cast<CPrefetchRequest*>(&*req) ) { throw prefetch::CCancelRequestException(); } return true; }
void ASI::GetMenus(CRef& cref, MenuSet& menuSet) { int type = cref.Type(); if (!m_pMenuManager->GetMenus(type, menuSet)) { menuSet.Clear(); Component* pComponent = cref.GetInstance(); if (pComponent != NULL) { const QStringList profile = pComponent->GetProfile(); m_pMenuManager->GetMenus(profile, menuSet, type); cref.ReleaseInstance(); } } }
void CExportStrategy::x_Process_SearchDb(CRef<CSearchDatabase> & db) { if (db.Empty()) { NCBI_THROW(CBlastException, eInvalidArgument, "Empty reference for CSearchDatabase."); } if (db->GetDatabaseName().empty()) { NCBI_THROW(CBlastException, eInvalidArgument, "Error: No database specified"); } // Set database Name CRef<CBlast4_subject> subject_p(new CBlast4_subject); subject_p->SetDatabase(db->GetDatabaseName()); m_QueueSearchRequest->SetSubject(*subject_p); // Set Entrez Query Limitation string entrez_query_limit = db->GetEntrezQueryLimitation(); if(!entrez_query_limit.empty()) { CRef<CBlast4_parameter> p(new CBlast4_parameter); p->SetName(CBlast4Field::GetName(eBlastOpt_EntrezQuery)); CRef<CBlast4_value> v(new CBlast4_value); v->SetString().assign(entrez_query_limit); p->SetValue(*v); _ASSERT(CBlast4Field::Get(eBlastOpt_EntrezQuery).Match(*p)); m_QueueSearchRequest->SetProgram_options().Set().push_back(p); } // Set the GI List Limitation const CSearchDatabase::TGiList& gi_list_limit = db->GetGiListLimitation(); if (!gi_list_limit.empty()) { #ifdef NCBI_STRICT_GI vector<int> int_gi_list; ITERATE ( vector<TGi>, it, gi_list_limit ) { int_gi_list.push_back(GI_TO( int, *it)); }
// ---------------------------------------------------------------------------- bool CVcfReader::xProcessFilter( CVcfData& data, CRef<CSeq_feat> pFeature ) // ---------------------------------------------------------------------------- { CSeq_feat::TExt& ext = pFeature->SetExt(); ext.AddField( "filter", data.m_strFilter ); return true; }
CBlastPrelimSearch::CBlastPrelimSearch(CRef<IQueryFactory> query_factory, CRef<CBlastOptions> options, CRef<CLocalDbAdapter> db) : m_QueryFactory(query_factory), m_InternalData(new SInternalData), m_Options(options), m_DbAdapter(db), m_DbInfo(NULL) { BlastSeqSrc* seqsrc = db->MakeSeqSrc(); x_Init(query_factory, options, CRef<CPssmWithParameters>(), seqsrc); m_InternalData->m_SeqSrc.Reset(new TBlastSeqSrc(seqsrc, 0)); }
static CRef<CScope> s_InitScope(bool reset_loader = true) { CRef<CObjectManager> om = CObjectManager::GetInstance(); if ( reset_loader ) { CDataLoader* loader = om->FindDataLoader(CGBDataLoader::GetLoaderNameFromArgs()); if ( loader ) { BOOST_CHECK(om->RevokeDataLoader(*loader)); } } #ifdef HAVE_PUBSEQ_OS DBAPI_RegisterDriver_FTDS(); GenBankReaders_Register_Pubseq(); #endif CGBDataLoader::RegisterInObjectManager(*om); CRef<CScope> scope(new CScope(*om)); scope->AddDefaults(); return scope; }
int ReadFastaQueries(const string& filename, vector< CRef<objects::CSeq_loc> >& seqs, CRef<objects::CScope>& scope, bool parse_deflines /* = false*/, objects::CSeqIdGenerator* id_generator /* = NULL*/) { seqs.clear(); CNcbiIfstream instream(filename.c_str()); if (!instream) { return -1; } CStreamLineReader line_reader(instream); CFastaReader::TFlags flags = CFastaReader::fAssumeProt | CFastaReader::fForceType; if (!parse_deflines) { flags |= CFastaReader::fNoParseID; } CFastaReader fasta_reader(line_reader, flags); if (id_generator) { fasta_reader.SetIDGenerator(*id_generator); } scope->AddDefaults(); while (!line_reader.AtEOF()) { CRef<CSeq_entry> entry = fasta_reader.ReadOneSeq(); if (entry == 0) { return -1; } scope->AddTopLevelSeqEntry(*entry); CTypeConstIterator<CBioseq> itr(ConstBegin(*entry)); CRef<CSeq_loc> seqloc(new CSeq_loc()); seqloc->SetWhole().Assign(*itr->GetId().front()); seqs.push_back(seqloc); } return 0; }
void ASI::AddToLayout(CRef& cref, CRef& layout) { Component* pLayoutComponent = layout.GetInstance(); if (pLayoutComponent != NULL) { int funcSet = pLayoutComponent->GetFuncSet("{f742f223-bb7b-48f0-92a8-81702e14de16}"); int emitter = pLayoutComponent->GetEmitter("{b11a0db4-cb96-4bf6-9631-fd96f20ea6ab}"); int receiver = pLayoutComponent->GetReceiver("{6a7ab00f-1ab4-4324-9eb4-e614bfca4a16}"); if ((funcSet != -1) && (emitter != -1) && (receiver != -1)) { Component* pComponent = cref.GetInstance(); if (pComponent != NULL) { if ((!pComponent->m_pData->inLayout) && (pComponent != pLayoutComponent)) { pComponent->SetParent(layout); /* * Tell the layout component to add * a new item with the given CRef id. */ DRef dref = NewData(BOI_STD_D(Int)); *dref.GetWriteInstance<int>() = cref.Id(); pLayoutComponent->CallFunc(funcSet, 1, dref, true); ConnectToReceiver(pLayoutComponent, emitter, cref, BOI_STD_R(SetPosition)); ConnectToReceiver(pComponent, BOI_STD_E(ParentBoundingBox), layout, receiver); pComponent->m_pData->inLayout = true; } cref.ReleaseInstance(); } } layout.ReleaseInstance(); } }
int ReadMsa(const string& filename, CRef<CSeq_align>& align, CRef<CScope> scope, bool parse_deflines /* = false*/, objects::CSeqIdGenerator* id_generator /* = NULL*/) { if (scope.Empty()) { return -1; } CNcbiIfstream instream(filename.c_str()); if (!instream) { return -1; } CStreamLineReader line_reader(instream); CFastaReader::TFlags flags = CFastaReader::fAssumeProt | CFastaReader::fForceType | CFastaReader::fValidate; if (!parse_deflines) { flags |= CFastaReader::fNoParseID; } CFastaReader fasta_reader(line_reader, flags); if (id_generator) { fasta_reader.SetIDGenerator(*id_generator); } CRef<CSeq_entry> entry = fasta_reader.ReadAlignedSet(-1); if (entry.Empty()) { return -1; } scope->AddTopLevelSeqEntry(*entry); // notify of a problem if the whole file was not read if (!line_reader.AtEOF()) { return -1; } align = entry->GetAnnot().front()->GetData().GetAlign().front(); return 0; }
bool CShortReadFastaInputSource::x_ReadFromTwoFiles(CBioseq_set& bioseq_set, TSeqPos batch_size, CShortReadFastaInputSource::EInputFormat format) { if (format == eFastc) { NCBI_THROW(CInputException, eInvalidInput, "FASTC format cannot be " "used with two files"); } // tags to indicate paired sequences CRef<CSeqdesc> seqdesc_first(new CSeqdesc); seqdesc_first->SetUser().SetType().SetStr("Mapping"); seqdesc_first->SetUser().AddField("has_pair", eFirstSegment); CRef<CSeqdesc> seqdesc_last(new CSeqdesc); seqdesc_last->SetUser().SetType().SetStr("Mapping"); seqdesc_last->SetUser().AddField("has_pair", eLastSegment); m_BasesAdded = 0; while (m_BasesAdded < batch_size && !m_LineReader->AtEOF() && !m_SecondLineReader->AtEOF()) { CRef<CSeq_entry> first; CRef<CSeq_entry> second; if (format == eFasta) { first = x_ReadFastaOneSeq(m_LineReader); second = x_ReadFastaOneSeq(m_SecondLineReader); } else { first = x_ReadFastqOneSeq(m_LineReader); second = x_ReadFastqOneSeq(m_SecondLineReader); } if (first.NotEmpty()) { if (second.NotEmpty()) { first->SetSeq().SetDescr().Set().push_back(seqdesc_first); } bioseq_set.SetSeq_set().push_back(first); } if (second.NotEmpty()) { if (first.NotEmpty()) { second->SetSeq().SetDescr().Set().push_back(seqdesc_last); } bioseq_set.SetSeq_set().push_back(second); } } return true; }
// ---------------------------------------------------------------------------- bool CGtfReader::x_MergeFeatureLocationMultiInterval( const CGff2Record& record, CRef< CSeq_feat > pFeature ) // ---------------------------------------------------------------------------- { CRef<CSeq_id> pId = CReadUtil::AsSeqId( record.Id(), m_iFlags & fAllIdsAsLocal); CRef< CSeq_loc > pLocation( new CSeq_loc ); pLocation->SetInt().SetId( *pId ); pLocation->SetInt().SetFrom( record.SeqStart() ); pLocation->SetInt().SetTo( record.SeqStop() ); if ( record.IsSetStrand() ) { pLocation->SetInt().SetStrand( record.Strand() ); } pLocation = pLocation->Add( pFeature->SetLocation(), CSeq_loc::fSortAndMerge_All, 0 ); pFeature->SetLocation( *pLocation ); return true; }
void ASI::SetPosition(CRef cref, const QPointF& pos) { Component* pComponent = cref.GetInstance(); if (pComponent != NULL) { if (!pComponent->m_pData->inLayout) { GuiRequest request; request.cref = cref; request.data.point.x = pos.x(); request.data.point.y = pos.y(); request.type = GuiRequest::RequestType_SetPosition; m_pGuiRequestHandler->PostRequest(&request); } cref.ReleaseInstance(); } }
static void s_LoadECNumberTable(const string& dir, const string& name, const char* const *fallback, size_t fallback_count, CProt_ref::EECNumberStatus status) { CRef<ILineReader> lr; if ( !dir.empty() ) { lr.Reset(ILineReader::New (CDirEntry::MakePath(dir, "ecnum_" + name, "txt"))); } if (lr.Empty()) { while (fallback_count--) { s_ProcessECNumberLine(*fallback++, status); } } else { do { s_ProcessECNumberLine(*++*lr, status); } while ( !lr->AtEOF() ); } }
CScope& CAlnMrgApp::GetScope(void) const { if (!m_Scope) { m_ObjMgr = CObjectManager::GetInstance(); CGBDataLoader::RegisterInObjectManager(*m_ObjMgr); m_Scope = new CScope(*m_ObjMgr); m_Scope->AddDefaults(); } return *m_Scope; }
CRef<CBlastOptionsHandle> CIgBlastnAppArgs::x_CreateOptionsHandle(CBlastOptions::EAPILocality locality, const CArgs& args) { CRef<CBlastOptionsHandle> retval; SetTask("blastn"); retval.Reset(CBlastOptionsFactory::CreateTask(GetTask(), locality)); _ASSERT(retval.NotEmpty()); retval->SetFilterString("F"); //retval->SetEvalueThreshold(1e-15); <- this will be overwritten anyway CBlastOptions &opts = retval->SetOptions(); opts.SetMatchReward(1); opts.SetMismatchPenalty(-1); opts.SetWordSize(11); opts.SetGapOpeningCost(4); opts.SetGapExtensionCost(1); return retval; }
// Must be called under a lock // When a client inactivity timeout is detected there is no need to touch the // running or reading jobs. The only things to be done are: // - cancel waiting // - reset pref affinities // - set reset affinity flag // - log the event void CNSClientsRegistry::ClearOnTimeout(CNSClient & client, const string & client_node, bool is_log, ECommandGroup cmd_group) { // Deregister preferred affinities bool had_pref_affs = client.HasPreferredAffinities(cmd_group); if (had_pref_affs) { m_AffRegistry->RemoveClientFromAffinities( client.GetID(), client.GetPreferredAffinities(cmd_group), cmd_group); client.ClearPreferredAffinities(cmd_group); if (is_log) { string aff_part = "get"; if (cmd_group == eRead) aff_part = "read"; CRef<CRequestContext> ctx; ctx.Reset(new CRequestContext()); ctx->SetRequestID(); GetDiagContext().SetRequestContext(ctx); GetDiagContext().PrintRequestStart() .Print("_type", "client_watch") .Print("client_node", client_node) .Print("client_session", client.GetSession()) .Print(aff_part + "_preferred_affinities_reset", "yes"); ctx->SetRequestStatus(CNetScheduleHandler::eStatus_OK); GetDiagContext().PrintRequestStop(); } client.SetAffinityReset(true, cmd_group); } CancelWaiting(client, cmd_group); if (had_pref_affs) x_BuildAffinities(cmd_group); }
CRef<CBioSource> MakeCommonBioSource(const objects::CBioSource& src1, const objects::CBioSource& src2) { CRef<CBioSource> common(NULL); if (!src1.IsSetOrg() || !src2.IsSetOrg()) { return common; } int taxid1 = src1.GetOrg().GetTaxId(); int taxid2 = src2.GetOrg().GetTaxId(); if (taxid1 == 0 || taxid2 == 0) { return common; } else if (taxid1 == taxid2) { common = src1.MakeCommon(src2); } else { CRef<CT3Request> rq(new CT3Request()); rq->SetJoin().Set().push_back(taxid1); rq->SetJoin().Set().push_back(taxid2); CTaxon3_request request; request.SetRequest().push_back(rq); CTaxon3 taxon3; taxon3.Init(); CRef<CTaxon3_reply> reply = taxon3.SendRequest(request); if (reply) { CTaxon3_reply::TReply::const_iterator reply_it = reply->GetReply().begin(); while (reply_it != reply->GetReply().end()) { if ((*reply_it)->IsData() && (*reply_it)->GetData().GetOrg().IsSetTaxname()) { bool is_species_level = false, force_consult = false, has_nucleomorphs = false; (*reply_it)->GetData().GetTaxFlags (is_species_level, force_consult, has_nucleomorphs); if (is_species_level) { common.Reset(new CBioSource()); common->SetOrg().Assign((*reply_it)->GetData().GetOrg()); } break; } ++reply_it; } } } return common; }
BEGIN_NCBI_SCOPE CRef<ILineReader> ILineReader::New(const string& filename) { CRef<ILineReader> lr; if (filename != "-") { try { lr.Reset(new CMemoryLineReader(new CMemoryFile(filename), eTakeOwnership)); } catch (exception& e) { // CFileException is the main concern ERR_POST_X(1, Info << "ILineReader::New: falling back from" " CMemoryLineReader to CBufferedLineReader for " << filename << " due to exception: " << e.what()); } } if (lr.Empty()) { lr.Reset(new CBufferedLineReader(filename)); } return lr; }
int CSeqDBPerfApp::x_ScanDatabase() { CStopWatch sw; sw.Start(); Uint8 num_letters = m_BlastDb->GetTotalLength(); const bool kScanUncompressed = GetArgs()["scan_uncompressed"]; vector<int> oids2iterate; for (int oid = 0; m_DbHandles.front()->CheckOrFindOID(oid); oid++) { oids2iterate.push_back(oid); } LOG_POST(Info << "Will go over " << oids2iterate.size() << " sequences"); #pragma omp parallel default(none) num_threads(m_DbHandles.size()) \ shared(oids2iterate) if(m_DbHandles.size() > 1) { int thread_id = 0; #ifdef _OPENMP thread_id = omp_get_thread_num(); #endif #pragma omp for schedule(static, (oids2iterate.size()/m_DbHandles.size())) nowait for (size_t i = 0; i < oids2iterate.size(); i++) { int oid = oids2iterate[i]; const char* buffer = NULL; int seqlen = 0; if (m_DbIsProtein || kScanUncompressed) { int encoding = m_DbIsProtein ? 0 : kSeqDBNuclBlastNA8; m_DbHandles[thread_id]->GetAmbigSeq(oid, &buffer, encoding); seqlen = m_DbHandles[thread_id]->GetSeqLength(oid); } else { m_DbHandles[thread_id]->GetSequence(oid, &buffer); seqlen = m_DbHandles[thread_id]->GetSeqLength(oid) / 4; } for (int i = 0; i < seqlen; i++) { char base = buffer[i]; base = base; // dummy statement } if (m_DbIsProtein || kScanUncompressed) { m_DbHandles[thread_id]->RetAmbigSeq(&buffer); } else { m_DbHandles[thread_id]->RetSequence(&buffer); } } x_UpdateMemoryUsage(thread_id); } // end of omp parallel sw.Stop(); Uint8 bases = static_cast<Uint8>(num_letters / sw.Elapsed()); cout << "Scanning rate: " << NStr::NumericToString(bases, NStr::fWithCommas) << " bases/second" << endl; return 0; }
static CRef<CScope> s_MakeScope(const string& file_name = kEmptyStr) { CRef<CObjectManager> om = CObjectManager::GetInstance(); if ( !s_LoaderName.empty() ) { om->RevokeDataLoader(s_LoaderName); s_LoaderName.erase(); } if ( file_name.empty() ) { s_LoaderName = CVDBGraphDataLoader::RegisterInObjectManager(*om) .GetLoader()->GetName(); } else { s_LoaderName = CVDBGraphDataLoader::RegisterInObjectManager(*om, file_name) .GetLoader()->GetName(); } CRef<CScope> scope(new CScope(*om)); scope->AddDataLoader(s_LoaderName); return scope; }
bool SequenceTable::findSequence(CRef< CSeq_id > seqId, CRef< CSeq_entry >& seqEntry)const { CRef< CBioseq > bioseq; if (findSequence(seqId, bioseq)) { seqEntry = new CSeq_entry; seqEntry->SetSeq(*bioseq); return true; } else return false; }
// ---------------------------------------------------------------------------- bool CVcfReader::xProcessScore( CVcfData& data, CRef<CSeq_feat> pFeature ) // ---------------------------------------------------------------------------- { CSeq_feat::TExt& ext = pFeature->SetExt(); if ( data.m_pdQual ) { ext.AddField( "score", *data.m_pdQual ); } return true; }
/// Auxiliary function to assign the split query's Seq-interval so that it's /// constrained within the chunk boundaries /// @param chunk Range for the chunk [in] /// @param query_range Range of sequence data corresponding to the full query /// [in] /// @param split_query_loc Seq-loc for this query constrained by the chunk's /// boundaries [out] static void s_SetSplitQuerySeqInterval(const TChunkRange& chunk, const TChunkRange& query_range, CRef<CSeq_loc> split_query_loc) { _ASSERT(split_query_loc.NotEmpty()); _ASSERT(chunk.IntersectingWith(query_range)); CSeq_interval& interval = split_query_loc->SetInt(); const int qstart = chunk.GetFrom() - query_range.GetFrom(); const int qend = chunk.GetToOpen() - query_range.GetToOpen(); interval.SetFrom(max(0, qstart)); if (qend >= 0) { interval.SetTo(query_range.GetToOpen() - query_range.GetFrom()); } else { interval.SetTo(chunk.GetToOpen() - query_range.GetFrom()); } // Note subtraction, as Seq-intervals are assumed to be // open/inclusive interval.SetTo() -= 1; }
void CBlastHitMatrixCGIApplication::x_GetSeqAnnot(CCgiContext& ctx) { const CNcbiRegistry & reg = ctx.GetConfig(); string blastURL = reg.Get("NetParams", "BlastURL"); string url = (string)blastURL + "?CMD=Get&RID=" + m_RID + "&FORMAT_TYPE=ASN.1&FORMAT_OBJECT=Alignment"; SConnNetInfo* net_info = ConnNetInfo_Create(NULL); // create HTTP connection CConn_HttpStream inHttp(url,net_info); try { m_Annot.Reset(new CSeq_annot); auto_ptr<CObjectIStream> is (CObjectIStream::Open(eSerial_AsnText, inHttp)); *is >> *m_Annot; } catch (CException& e) { m_Annot.Reset(); NCBI_THROW(CBlastHitMatrixCGIException, eInvalidSeqAnnot, "Exception reading SeqAnnot via url " + url + ", exception message: " + e.GetMsg()); } }
int CNgAlignTest::Run() { //const CArgs& args = GetArgs(); CRef<CObjectManager> obj_mgr = CObjectManager::GetInstance(); CGBDataLoader::RegisterInObjectManager(*obj_mgr); m_Scope.Reset(new CScope(*obj_mgr)); m_Scope->AddDefaults(); //string TestCaseIni = "/home/boukn/code/toolkit/c++/src/algo/align/uberalign/test/testcases.ini"; string TestCaseIni = "/panfs/pan1.be-md.ncbi.nlm.nih.gov/genome_maint/work/uberalign/test/testcases.ini"; CNcbiIfstream TestCaseFile(TestCaseIni.c_str()); CNcbiRegistry TestCases(TestCaseFile); string CasesStr = TestCases.Get("caselist", "cases"); list<string> Cases; NStr::Split(CasesStr, " \t\r\n,", Cases); ITERATE(list<string>, CaseIter, Cases) { string Type = TestCases.Get(*CaseIter, "type"); if(Type == "one_to_one") { x_OneToOneCase(&TestCases, *CaseIter); } else if(Type == "one_to_blastdb") { x_OneToBlastDbCase(&TestCases, *CaseIter); } else if(Type == "list_to_blastdb") { x_ListToBlastDbCase(&TestCases, *CaseIter); } else if(Type == "split_one_to_blastdb") { x_SplitOneToBlastDbCase(&TestCases, *CaseIter); } else if(Type == "split_list_to_blastdb") { x_SplitListToBlastDbCase(&TestCases, *CaseIter); } else if(Type == "overlap_one_to_blastdb") { x_OverlapOneToBlastDbCase(&TestCases, *CaseIter); } else if(Type == "overlap_list_to_blastdb") { x_OverlapListToBlastDbCase(&TestCases, *CaseIter); } }
SSeqLoc blast_sseq_loc_from_str::make(const std::string& seq_data, bool is_prot, int seq_gi, const std::string& title, ENa_strand strand, int from, int to) { if (seq_gi < 0) { throw std::runtime_error("seq_id cannot be negative."); } if (seq_data.empty()) { throw std::runtime_error("seq_data cannot be empty."); } if (title.empty()) { throw std::runtime_error("title cannot be empty."); } CRef<CScope> scope(new CScope(*_objmngr)); scope->AddDefaults(); from = std::max(from - 1, 0); to = std::max(to - 1, 0); if (to <= 0 || to > seq_data.size()){ to = seq_data.size() -1; // this is because is [from:to] and NOT [from:to[ } if (from > to) { from = to; } CRef<CSeq_entry> entry(new CSeq_entry); CRef<CBioseq> bioseq = build_bioseq(seq_data, is_prot, seq_gi, title); entry->SetSeq(*bioseq); scope->AddTopLevelSeqEntry(*entry); CRef<CSeq_loc> seqloc(new CSeq_loc()); seqloc->SetInt().SetTo(to); seqloc->SetInt().SetFrom(from); seqloc->SetStrand(strand); seqloc->SetInt().SetId().Assign(*bioseq->GetId().front()); SSeqLoc sl(seqloc, scope); return sl; }
const bool CMSPeak::ContainsFast(const int value, const EMSPeakListTypes Which) const { int x(0), l, r; CRef <CMSPeakList> PeakList = GetPeakLists()[Which]; l = 0; r = PeakList->GetNum() - 1; while(l <= r) { x = (l + r)/2; if (PeakList->GetMZI()[x].GetMZ() < value - tol) l = x + 1; else if (PeakList->GetMZI()[x].GetMZ() > value + tol) r = x - 1; else return true; } if (x < PeakList->GetNum() - 1 && PeakList->GetMZI()[x+1].GetMZ() < value + tol && PeakList->GetMZI()[x+1].GetMZ() > value - tol) return true; return false; }
void CExportStrategy::x_Process_SearchDb(CRef<CSearchDatabase> & db) { if (db.Empty()) { NCBI_THROW(CBlastException, eInvalidArgument, "Empty reference for CSearchDatabase."); } if (db->GetDatabaseName().empty()) { NCBI_THROW(CBlastException, eInvalidArgument, "Error: No database specified"); } // Set database Name CRef<CBlast4_subject> subject_p(new CBlast4_subject); subject_p->SetDatabase(db->GetDatabaseName()); m_QueueSearchRequest->SetSubject(*subject_p); // Set Entrez Query Limitation string entrez_query_limit = db->GetEntrezQueryLimitation(); if(!entrez_query_limit.empty()) { CRef<CBlast4_parameter> p(new CBlast4_parameter); p->SetName(CBlast4Field::GetName(eBlastOpt_EntrezQuery)); CRef<CBlast4_value> v(new CBlast4_value); v->SetString().assign(entrez_query_limit); p->SetValue(*v); _ASSERT(CBlast4Field::Get(eBlastOpt_EntrezQuery).Match(*p)); m_QueueSearchRequest->SetProgram_options().Set().push_back(p); } // Set the GI List Limitation const CSearchDatabase::TGiList& gi_list_limit = db->GetGiListLimitation(); if (!gi_list_limit.empty()) { x_AddParameterToProgramOptions(CBlast4Field::Get(eBlastOpt_GiList), gi_list_limit); } // Set the negative GI list const CSearchDatabase::TGiList& neg_gi_list = db->GetNegativeGiListLimitation(); if (!neg_gi_list.empty()) { x_AddParameterToProgramOptions(CBlast4Field::Get(eBlastOpt_NegativeGiList), neg_gi_list); } // Set the filtering algorithms int algo_id = db->GetFilteringAlgorithm(); if (algo_id != -1) { x_AddParameterToProgramOptions(CBlast4Field::Get(eBlastOpt_DbFilteringAlgorithmId), algo_id); } }