A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/data__source_8cpp_source.html below:

NCBI C++ ToolKit: src/objmgr/data_source.cpp Source File

76 #if 0 && defined(_DEBUG) 77 # define TSE_LOCK_NO_SWAP 78 # define TSE_LOCK_TRACE(x) _TRACE(x) 80 # define TSE_LOCK_TRACE(x) 83 #define NCBI_USE_ERRCODE_X ObjMgr_DataSource 100  return

sx_Value->

Get

();

117

m_Blob_Cache_Size(0),

118

m_Blob_Cache_Size_Limit(GetDefaultBlobCacheSizeLimit()),

119

m_StaticBlobCounter(0),

120

m_TrackSplitSeq(

false

)

127

m_DefaultPriority(loader.GetDefaultPriority()),

128

m_Blob_Cache_Size(0),

129

m_Blob_Cache_Size_Limit(

min

(GetDefaultBlobCacheSizeLimit(),

130

loader.GetDefaultBlobCacheSizeLimit())),

131

m_StaticBlobCounter(0),

132

m_TrackSplitSeq(loader.GetTrackSplitSeq())

139

: m_SharedObject(&shared_object),

141

m_Blob_Cache_Size(0),

142

m_Blob_Cache_Size_Limit(GetDefaultBlobCacheSizeLimit()),

143

m_StaticBlobCounter(0),

144

m_TrackSplitSeq(

false

)

200  if

( lock_counter != used_counter ) {

201  ERR_POST_X

(1,

"CDataSource::DropAllTSEs: tse is locked"

);

235  return AddTSE

(tse, dead ?

243  if

(

info

->m_BlobVersion == -1 ) {

264

CDSDetachGuard(

void

)

269

~CDSDetachGuard(

void

)

272

m_TSE_Info->x_DSDetach(*m_DataSource);

288

CDSDetachGuard(

const

CDSDetachGuard&);

312  "Duplicated Blob-id"

);

315

CDSDetachGuard detach_guard;

316

detach_guard.Attach(

this

,

info

);

337  if

(

info

.IsLocked() ) {

338  _TRACE

(

"DropTSE: DS="

<<

this

<<

" TSE_Info="

<<&

info

<<

" locked"

);

341  if

( !

info

.HasDataSource() ) {

342  _TRACE

(

"DropTSE: DS="

<<

this

<<

" TSE_Info="

<<&

info

<<

" already dropped"

);

360  info

->m_DataSource = 0;

371  info

->x_DSDetach(*

this

);

391

pair<TInfoMap::iterator, bool> ins =

395  str

<<

"CDataSource::x_Map(): object already mapped:"

<<

396  " "

<<

typeid

(*obj).name() <<

398  " "

<<

typeid

(*info).name() <<

400  " was: "

<< ins.first->second;

439  return out

<< seq_id;

449 static

ostream&

s_Format

(ostream&

out

,

const

pair<const string, int>& na_with_zoom)

451  out

<< na_with_zoom.first;

452  if

( na_with_zoom.second > 0 ) {

459 template

<

class

Value>

460 static

ostream&

s_Format

(ostream&

out

,

const

pair<const CSeq_id_Handle, Value>& request_pair)

462  return out

<< request_pair.first;

466 template

<

class

Container>

467 static

ostream&

s_Format

(ostream&

out

,

const

Container& container)

469  char

separator =

'('

;

470  for

(

auto

& element : container ) {

471  out

<< separator; separator =

','

;

482  out

<< method_name <<

'('

<< seq_id <<

')'

;

491  out

<< method_name <<

'('

;

502  out

<< method_name <<

'('

;

513  out

<< method_name <<

'('

;

525  out

<< method_name <<

'('

<< seq_id <<

')'

;

536  out

<< method_name <<

'('

;

541  if

( processed_nas && !processed_nas->

empty

() ) {

557  out

<< method_name <<

'('

;

562  if

( processed_nas && !processed_nas->

empty

() ) {

576  out

<< method_name <<

'('

<< blob_id <<

')'

;

588

ret.first = ret.second;

671  for

(

int i

= 0;

i

< 2; ++

i

) {

674  if

( it != index.

end

() ) {

676

ret = (*it2)->x_FindSeq_feat(loc_id, loc_pos, feat);

677  if

( ret.first.first ) {

679  ConstRef

(&ret.first.first->GetTSE_Info()));

694  if

( tse_set != index.

end

() ) {

695  for

(

auto

& tse : tse_set->second ) {

696

blob_ids.

insert

(tse->GetBlobId());

706  auto

iter = index.

find

(idh);

707  if

( iter != index.

end

() ) {

708  for

(

auto

&

split

: iter->second ) {

757

blob_ids.push_back(*it);

768

ret =

dynamic_cast<const CTSE_Info

*

>

(&*found->second);

816

ret =

dynamic_cast<const CBioseq_Info

*

>

(&*found->second);

830  "Can not remove a loaded entry"

);

833  return

parent.

AddEntry

(entry, index);

841  "Can not remove a loaded entry"

);

846  "Can not remove top level seq-entry from a data source"

);

860  "Can not modify a loaded entry"

);

864  return

entry_info.

AddAnnot

(annot);

873  "Can not modify a loaded entry"

);

885  "Can not modify a loaded entry"

);

899  "Can not modify a loaded entry"

);

905  return

parent.

AddAnnot

(new_annot);

931

: m_MainGuard(ds.m_DSMainLock),

932

m_AnnotGuard(ds.m_DSAnnotLock)

948

: m_MainGuard(ds.m_DSMainLock),

949

m_AnnotGuard(ds.m_DSAnnotLock)

1013

ret.back().second !=

id

||

1014

ret.back().first != tse_lock ) {

1015

ret.push_back(pair<CTSE_Lock, CSeq_id_Handle>(tse_lock,

id

));

1029  id

.GetReverseMatchingHandles(ids);

1125  sort

(ret.begin(), ret.end());

1126

ret.erase(unique(ret.begin(), ret.end()), ret.end());

1137  if

( !external_only ) {

1163  if

( blob_count <= 1 ) {

1169  if

( it->HaveReverseMatch() ) {

1171

it->GetReverseMatchingHandles(ids);

1177  if

( blob_count <= 10 ) {

1179  if

( it->second == tse ) {

1195  if

( *tse_it == tse ) {

1206  sort

(ret.begin(), ret.end());

1207

ret.erase(unique(ret.begin(), ret.end()), ret.end());

1216  if

( it == tse_map.

end

() || it->first !=

id

) {

1219  _ASSERT

(it != tse_map.

end

() && it->first ==

id

);

1220  return

it->second.insert(

Ref

(tse_info)).second;

1229  if

( it == tse_map.

end

() ) {

1232

it->second.erase(

Ref

(tse_info));

1233  if

( it->second.empty() ) {

1234

tse_map.

erase

(it);

1243

split_map[id].

insert

(

Ref

(split_info));

1251  auto

it = split_map.

find

(

id

);

1252  if

( it != split_map.

end

() ) {

1253

it->second.erase(

Ref

(split_info));

1254  if

( it->second.empty() ) {

1255

split_map.

erase

(it);

1295  for

(

auto

&

id

: ids ) {

1317  for

(

auto

&

id

: ids ) {

1328  for

(

auto

&

id

: ids ) {

1365

it->first, tse_info);

1378

it->first, tse_info);

1397

debug::CReadGuard<TSeq_id2TSE_Set> g1(

m_TSE_seq

);

1404

debug::CReadGuard<TTSE_Set> g2(tse_set->second);

1414  if

( best_set.

empty

() ) {

1420  if

( ++it == best_set.

end

() ) {

1422  return

*best_set.

begin

();

1435  "Multiple seq-id matches found for "

<<handle);

1459

it->second->x_GetRecords(*hit,

true

);

1500  if

( !history.

empty

() ) {

1511

ret.push_back(

match

);

1524

ids =

match

.m_Bioseq->GetId();

1614

ret =

match

.m_Bioseq->GetTaxId();

1634

ret =

match

.m_Bioseq->GetBioseqLength();

1655

ret.

type

=

match

.m_Bioseq->GetInst_Mol();

1676

ret =

match

.m_Bioseq->GetTSE_Info().GetBlobState();

1693  size_t count

= ids.size(), remaining = 0;

1694  _ASSERT

(ids.size() == loaded.size());

1695  _ASSERT

(ids.size() == ret.size());

1696  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1697  if

( loaded[

i

] ) {

1702

ret[

i

] =

match

.m_Bioseq->GetId();

1703

loaded[

i

] =

true

;

1723  size_t count

= ids.size(), remaining = 0;

1724  _ASSERT

(ids.size() == loaded.size());

1725  _ASSERT

(ids.size() == ret.size());

1726  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1727  if

( loaded[

i

] ) {

1733

loaded[

i

] =

true

;

1753  size_t count

= ids.size(), remaining = 0;

1754  _ASSERT

(ids.size() == loaded.size());

1755  _ASSERT

(ids.size() == ret.size());

1756  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1757  if

( loaded[

i

] ) {

1763

loaded[

i

] =

true

;

1783  size_t count

= ids.size(), remaining = 0;

1784  _ASSERT

(ids.size() == loaded.size());

1785  _ASSERT

(ids.size() == ret.size());

1786  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1787  if

( loaded[

i

] ) {

1793

loaded[

i

] =

true

;

1813  size_t count

= ids.size(), remaining = 0;

1814  _ASSERT

(ids.size() == loaded.size());

1815  _ASSERT

(ids.size() == ret.size());

1816  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1817  if

( loaded[

i

] ) {

1822

ret[

i

] =

match

.m_Bioseq->GetTaxId();

1823

loaded[

i

] =

true

;

1844  size_t count

= ids.size(), remaining = 0;

1845  _ASSERT

(ids.size() == loaded.size());

1846  _ASSERT

(ids.size() == ret.size());

1847  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1848  if

( loaded[

i

] ) {

1853

ret[

i

] =

match

.m_Bioseq->GetBioseqLength();

1854

loaded[

i

] =

true

;

1875  size_t count

= ids.size(), remaining = 0;

1876  _ASSERT

(ids.size() == loaded.size());

1877  _ASSERT

(ids.size() == ret.size());

1878  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1879  if

( loaded[

i

] ) {

1884

ret[

i

] =

match

.m_Bioseq->GetInst_Mol();

1885

loaded[

i

] =

true

;

1906  size_t count

= ids.size(), remaining = 0;

1907  _ASSERT

(ids.size() == loaded.size());

1908  _ASSERT

(ids.size() == ret.size());

1909  for

(

size_t i

= 0;

i

<

count

; ++

i

) {

1910  if

( loaded[

i

] ) {

1915

ret[

i

] =

match

.m_Bioseq->GetTSE_Info().GetBlobState();

1916

loaded[

i

] =

true

;

1969 #ifdef NCBI_USE_TSAN 1970  const size_t

limit_cdds_request = 15;

1972  const size_t

limit_cdds_request = 200;

1974  _ASSERT

(id_sets.size() == loaded.size());

1975  _ASSERT

(id_sets.size() == ret.size());

1976  size_t

current_size =

min

(limit_cdds_request, id_sets.size());

1977  for

(

size_t

current_start = 0; current_start < id_sets.size(); current_start += current_size) {

1978  if

(current_size > id_sets.size() - current_start) current_size = id_sets.size() - current_start;

1980  size_t

current_end = current_start + current_size;

1981  TLoaded

current_loaded(current_id_sets.size());

1982  TCDD_Locks

current_ret(current_id_sets.size());

1983  copy

(id_sets.begin() + current_start, id_sets.begin() + current_end, current_id_sets.begin());

1984  copy

(loaded.begin() + current_start, loaded.begin() + current_end, current_loaded.begin());

1985  copy

(ret.begin() + current_start, ret.begin() + current_end, current_ret.begin());

1988  copy

(current_loaded.begin(), current_loaded.end(), loaded.begin() + current_start);

1989  copy

(current_ret.begin(), current_ret.end(), ret.begin() + current_start);

2004

loader->

GetBlobs

(current_tse_sets);

2010  if

( all_tse_sets.

empty

() ) {

2011  swap

(all_tse_sets, current_tse_sets);

2014

all_tse_sets.

insert

(current_tse_sets.

begin

(), current_tse_sets.

end

());

2015

current_tse_sets.

clear

();

2022  if

( match_map.

empty

() ) {

2028  size_t

current_tse_sets_size = 0;

2029 #ifdef NCBI_USE_TSAN 2030  const size_t

limit_blobs_request = 15;

2032  const size_t

limit_blobs_request = 200;

2036

current_tse_sets.

insert

(

2039  if

( ++current_tse_sets_size >= limit_blobs_request ) {

2041

current_tse_sets_size = 0;

2044  if

( !current_tse_sets.

empty

() ) {

2049

vector<CConstRef<CTSE_Chunk_Info>> chunks;

2050  for

(

auto

& tse_set : tse_sets ) {

2051  auto

& idh = tse_set.first;

2053  if

( idh.HaveMatchingHandles() ) {

2056  for

(

auto

& tse_lock : tse_set.second ) {

2057  if

( tse_lock->HasSplitInfo() ) {

2058  auto

& split_info = tse_lock->GetSplitInfo();

2059

split_info.x_AddChunksForGetRecords(chunks, idh);

2060  for

(

auto

& hit : hset ) {

2063

split_info.x_AddChunksForGetRecords(chunks, hit);

2068  if

( !chunks.empty() ) {

2076

(*it)->x_GetRecords(tse_set->first,

true

);

2085  if

( !it->second ) {

2118  if

(

info

.IsSeq() ) {

2123

bioseqs.push_back(

ConstRef

(&seq));

2131  if

( sub_info.

IsSet

() &&

2151 #if !defined(NCBI_NO_THREADS) 2192  "CDataSource::x_LockTSE: cannot find in locks"

);

2287  TSE_LOCK_TRACE

(

"TSE_LoadLock("

<<&*lock<<

") "

<<&lock<<

" lock"

);

2334

CDSDetachGuard detach_guard;

2335

detach_guard.Attach(

this

, &*lock);

2353

vector<TTSE_Ref> to_delete;

2387

to_delete.push_back(del_tse);

2400  if

( tse->m_LockCounter.Add(1) != 1 ) {

2406  _ASSERT

(tse->m_CachePosition ==

2425  TSE_LOCK_TRACE

(

"TSE_LoadLock("

<<&*load<<

") "

<<&load<<

" lock"

);

2445  TSE_LOCK_TRACE

(

"TSE_LoadLock("

<<&tse<<

") "

<<&load<<

" lock"

);

2486  if

(

this

!= &lock ) {

2493  TSE_LOCK_TRACE

(

"TSE_LoadLock("

<<&*lock<<

") "

<<

this

<<

" lock"

);

2520  TSE_LOCK_TRACE

(

"TSE_LoadLock("

<<&**

this

<<

") "

<<

this

<<

" unlock"

);

2565 #ifdef TSE_LOCK_NO_SWAP 2581  if

(

info

->m_LockCounter.Add(-1) == 0 ) {

2597  return info

->m_LockCounter.Add(1) == 1;

2607  info

->m_LockCounter.Add(1);

2666  if

( !ret.

empty

() ) {

2674

ret.

insert

(it->second);

#define NCBI_ANNOT_TRACK_ZOOM_LEVEL_SUFFIX

Named annotations zoom level can be encoded in the accession string with @ suffix,...

User-defined methods of the data storage class.

void RemoveAnnot(CRef< CSeq_annot_Info > annot)

CRef< CSeq_annot_Info > AddAnnot(CSeq_annot &annot, int chunk_id=0)

TInst_Mol GetInst_Mol(void) const

vector< CSeq_id_Handle > TId

const TId & GetId(void) const

void RemoveEntry(CRef< CSeq_entry_Info > entry)

CRef< CSeq_entry_Info > AddEntry(CSeq_entry &entry, int index, bool set_uniqid=false)

TClass GetClass(void) const

vector< CRef< CSeq_entry_Info > > TSeq_set

CDataSource::TMainLock::TReadLockGuard m_MainGuard

void Guard(CDataSource &ds)

CDSAnnotLockReadGuard(EEmptyGuard)

CDataSource::TAnnotLock::TReadLockGuard m_AnnotGuard

CDataSource::TAnnotLock::TWriteLockGuard m_AnnotGuard

CDataSource::TMainLock::TReadLockGuard m_MainGuard

void Guard(CDataSource &ds)

CDSAnnotLockWriteGuard(EEmptyGuard)

pair< CConstRef< CSeq_annot_Info >, TTSE_Lock > TSeq_annot_Lock

CTSE_LoadLock GetTSE_LoadLock(const TBlobId &blob_id)

TSeqMatches GetMatches(const CSeq_id_Handle &idh, const TTSE_LockSet &locks)

static void x_CollectBlob_ids(const CSeq_id_Handle &idh, const TSeq_id2TSE_Set &index, TLoadedBlob_ids_Set &blob_ids)

TTSE_Lock x_LockTSE(const CTSE_Info &tse_info, const TTSE_LockSet &locks, TLockFlags=0)

TTSE_Lock GetSharedTSE(void) const

vector< TSeqPos > TSequenceLengths

void x_ResetDirtyAnnotIndex(CTSE_Info &tse)

TSeq_id2TSE_Set m_TSE_seq_annot

TSeq_entry_Lock GetSeq_entry_Lock(const CBlobIdKey &blob_id)

void GetSequenceTypes(const TIds &ids, TLoaded &loaded, TSequenceTypes &ret)

SSeqMatch_DS BestResolve(const CSeq_id_Handle &idh)

void x_IndexAnnotTSEs(CTSE_Info *tse_info)

void x_CollectBioseqs(const CSeq_entry_Info &info, TBioseq_InfoSet &bioseqs, CSeq_inst::EMol filter, TBioseqLevelFlag level)

TTSE_Lock AddStaticTSE(CSeq_entry &se)

vector< int > TSequenceStates

CConstRef< CSeq_annot_Info > x_FindSeq_annot_Info(const CSeq_annot &annot) const

void x_UnindexTSE(TSeq_id2TSE_Set &tse_map, const CSeq_id_Handle &id, CTSE_Info *tse_info)

void SetLoaded(CTSE_LoadLock &lock)

void GetSequenceStates(const TIds &ids, TLoaded &loaded, TSequenceStates &ret)

bool x_IsTrackingSplitSeq() const

SSeqMatch_DS x_GetSeqMatch(const CSeq_id_Handle &idh, const TTSE_LockSet &locks)

TSeqPos GetSequenceLength(const CSeq_id_Handle &idh)

void GetLabels(const TIds &ids, TLoaded &loaded, TLabels &ret)

void GetIds(const CSeq_id_Handle &idh, TIds &ids)

CConstRef< CTSE_Info > x_FindTSE_Info(const CSeq_entry &tse) const

bool DropTSE(CTSE_Info &info)

void UpdateAnnotIndex(void)

TTSE_LockSet m_StaticBlobs

void x_ForgetTSE(CRef< CTSE_Info > info)

SGiFound GetGi(const CSeq_id_Handle &idh)

TTSE_LockSet x_GetRecords(const CSeq_id_Handle &idh, CDataLoader::EChoice choice)

CRef< CDataLoader > m_Loader

CRef< CPrefetchThreadOld > m_PrefetchThread

static unsigned GetDefaultBlobCacheSizeLimit()

bool DropStaticTSE(CTSE_Info &info)

void GetBulkIds(const TIds &ids, TLoaded &loaded, TBulkIds &ret)

vector< pair< TTSE_Lock, CSeq_id_Handle > > TTSE_LockMatchSet

unsigned m_StaticBlobCounter

CConstRef< CObject > m_SharedObject

STypeFound GetSequenceType(const CSeq_id_Handle &idh)

virtual void Prefetch(CPrefetchTokenOld_Impl &token)

void x_ReleaseLastLock(CTSE_Lock &lock)

void RemoveAnnot(CSeq_annot_Info &annot)

TTSE_Lock x_FindBestTSE(const CSeq_id_Handle &handle, const TTSE_LockSet &locks)

void GetBioseqs(const CSeq_entry_Info &entry, TBioseq_InfoSet &bioseqs, CSeq_inst::EMol filter, TBioseqLevelFlag level)

TBioseq_Lock FindBioseq_Lock(const CBioseq &bioseq, const TTSE_LockSet &history) const

CTSE_LoadLock GetTSE_LoadLockIfLoaded(const TBlobId &blob_id)

void GetSequenceHashes(const TIds &ids, TLoaded &loaded, TSequenceHashes &ret, THashKnown &known)

void x_UnindexAnnotTSEs(CTSE_Info *tse_info)

void GetBlobs(TSeqMatchMap &match_map)

CDataLoader * GetDataLoader(void) const

void x_UnindexSplitInfo(TSeq_id2SplitInfoSet &split_map, const CSeq_id_Handle &id, CTSE_Split_Info *split_info)

void x_SetDirtyAnnotIndex(CTSE_Info &tse)

void GetCDDAnnots(const TSeqIdSets &id_sets, TLoaded &loaded, TCDD_Locks &ret)

void GetGis(const TIds &ids, TLoaded &loaded, TGis &ret)

int GetSequenceState(const CSeq_id_Handle &idh)

void x_SetLoadLock(CTSE_LoadLock &loadlock, CTSE_Lock &lock)

CConstRef< CBioseq_set_Info > x_FindBioseq_set_Info(const CBioseq_set &seqset) const

pair< CConstRef< CSeq_entry_Info >, TTSE_Lock > TSeq_entry_Lock

void DropAllTSEs(void)

Get TSE info by seq-id handle.

void GetAccVers(const TIds &ids, TLoaded &loaded, TIds &ret)

friend class CTSE_LoadLock

vector< CSeq_inst::TMol > TSequenceTypes

CFastMutex m_PrefetchLock

unsigned m_Blob_Cache_Size

TSeq_id2TSE_Set m_TSE_orphan_annot

void x_UnindexSeqTSE(const CSeq_id_Handle &ids, CTSE_Info *tse_info)

void x_AddTSEOrphanAnnots(TTSE_LockMatchSet &ret, const TSeq_idSet &ids, const CTSE_Lock &tse_lock)

vector< CSeq_id_Handle > TIds

virtual ~CDataSource(void)

CTSE_LoadLock GetLoadedTSE_Lock(const TBlobId &blob_id, const CDeadline &deadline)

TTSE_Lock FindTSE_Lock(const CSeq_entry &entry, const TTSE_LockSet &history) const

CRef< CSeq_entry_Info > AttachEntry(CBioseq_set_Info &parent, CSeq_entry &entry, int index=-1)

Add new sub-entry to "parent".

SHashFound GetSequenceHash(const CSeq_id_Handle &idh)

CRef< CSeq_annot_Info > AttachAnnot(CSeq_entry_Info &parent, CSeq_annot &annot)

Add annotations to a Seq-entry.

void x_SetLock(CTSE_Lock &lock, CConstRef< CTSE_Info > tse) const

const CConstRef< CObject > & GetSharedObject(void) const

bool IsLoaded(const CTSE_Info &tse) const

void x_AddTSEAnnots(TTSE_LockMatchSet &ret, const CSeq_id_Handle &id, const CTSE_Lock &tse_lock)

void x_UnindexAnnotTSE(const CSeq_id_Handle &idh, CTSE_Info *tse_info, bool orphan)

TSeq_annot_Lock FindSeq_annot_Lock(const CSeq_annot &annot, const TTSE_LockSet &history) const

vector< bool > THashKnown

TSeq_entry_Lock FindSeq_entry_Lock(const CSeq_entry &entry, const TTSE_LockSet &history) const

vector< CConstRef< CBioseq_Info > > TBioseq_InfoSet

void x_IndexSeqTSELocked(const CSeq_id_Handle &id, CTSE_Info *tse_info)

CConstRef< CSeq_entry_Info > x_FindSeq_entry_Info(const CSeq_entry &entry) const

void x_AddTSEBioseqAnnots(TTSE_LockMatchSet &ret, const CBioseq_Info &bioseq, const CTSE_Lock &tse_lock)

void x_GetLoadedBlob_ids(const CSeq_id_Handle &idh, TLoadedTypes types, TLoadedBlob_ids_Set &ids) const

vector< CTSE_Lock > TCDD_Locks

unsigned m_Blob_Cache_Size_Limit

TTSE_Set m_DirtyAnnot_TSEs

vector< int > TSequenceHashes

vector< SSeqMatch_DS > TSeqMatches

void x_ReleaseLastTSELock(CRef< CTSE_Info > info)

void GetTSESetWithOrphanAnnots(const TSeq_idSet &ids, TTSE_LockMatchSet &tse_set, const SAnnotSelector *sel, CDataLoader::TProcessedNAs *processed_nas=0)

vector< TBlobId > TLoadedBlob_ids

pair< CConstRef< CBioseq_set_Info >, TTSE_Lock > TBioseq_set_Lock

TTaxId GetTaxId(const CSeq_id_Handle &idh)

void GetSequenceLengths(const TIds &ids, TLoaded &loaded, TSequenceLengths &ret)

TSeq_id2SplitInfoSet m_TSE_split_seq

void GetTSESetWithBioseqAnnots(const CBioseq_Info &bioseq, const TTSE_Lock &tse, TTSE_LockMatchSet &tse_set, const SAnnotSelector *sel, CDataLoader::TProcessedNAs *processed_nas=0, bool external_only=false)

void GetLoadedBlob_ids(const CSeq_id_Handle &idh, TLoadedTypes types, TLoadedBlob_ids &blob_ids) const

void x_DropTSE(CRef< CTSE_Info > info)

CConstRef< CBioseq_Info > x_FindBioseq_Info(const CBioseq &seq) const

CRef< CSeq_annot_Info > ReplaceAnnot(CSeq_annot_Info &old_annot, CSeq_annot &new_annot)

TBioseq_set_Lock FindBioseq_set_Lock(const CBioseq_set &seqset, const TTSE_LockSet &history) const

void x_Unmap(const CObject *obj, const CTSE_Info_Object *info)

void x_Map(const CObject *obj, const CTSE_Info_Object *info)

void x_CleanupUnusedEntries(void)

void x_IndexSplitInfo(TSeq_id2SplitInfoSet &split_map, const CSeq_id_Handle &id, CTSE_Split_Info *split_info)

void RemoveEntry(CSeq_entry_Info &entry)

string GetName(void) const

void GetTaxIds(const TIds &ids, TLoaded &loaded, TTaxIds &ret)

pair< TSeq_annot_Lock, int > TSeq_feat_Lock

void RevokeDataLoader(void)

vector< vector< CSeq_id_Handle > > TSeqIdSets

SAccVerFound GetAccVer(const CSeq_id_Handle &idh)

string GetLabel(const CSeq_id_Handle &idh)

pair< CConstRef< CBioseq_Info >, TTSE_Lock > TBioseq_Lock

TSeq_feat_Lock FindSeq_feat_Lock(const CSeq_id_Handle &loc_id, TSeqPos loc_pos, const CSeq_feat &feat) const

void x_IndexAnnotTSE(const CSeq_id_Handle &idh, CTSE_Info *tse_info, bool orphan)

TTSE_Lock AddTSE(CSeq_entry &se, CTSE_Info::TBlobState=CBioseq_Handle::fState_none)

Register new TSE (Top Level Seq-entry)

void x_ReleaseLastLoadLock(CTSE_LoadLock &lock)

void x_IndexSeqTSE(const CSeq_id_Handle &idh, CTSE_Info *tse_info)

TSeq_id2TSE_Set m_TSE_seq

bool x_IndexTSE(TSeq_id2TSE_Set &tse_map, const CSeq_id_Handle &id, CTSE_Info *tse_info)

void Guard(resource_type &resource)

Manually force the guard to protect some other resource.

void Release()

Manually force the resource to be released.

Data loader exceptions, used by GenBank loader.

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

Base class for all object manager exceptions.

void AddRequest(CPrefetchTokenOld_Impl &token)

T & Get(void)

Create the variable if not created yet, return the reference.

void UpdateAnnotIndex(void) const

const CBioseq_Base_Info & GetParentBioseq_Base_Info(void) const

CRef< CSeq_annot_Info > AddAnnot(CSeq_annot &annot)

void UpdateAnnotIndex(void) const

const TSet & GetSet(void) const

const CBioseq_set_Info & GetParentBioseq_set_Info(void) const

CSeq_entry & operator=(const CSeq_entry &value)

namespace ncbi::objects::

CConditionVariable m_LoadWait

void x_DSAttach(CDataSource &ds)

bool x_DirtyAnnotIndex(void) const

bool HasParent_Info(void) const

TTSE_Cache::iterator m_CachePosition

void UpdateAnnotIndex(const CSeq_id_Handle &id) const

TBlobOrder GetBlobOrder(void) const

CAtomicCounter_WithAutoInit m_LockCounter

CConstRef< CBioseq_Info > FindBioseq(const CSeq_id_Handle &id) const

CDataSource & GetDataSource(void) const

bool OnlyGiAnnotIds(void) const

CSeq_id_Handle ContainsMatchingBioseq(const CSeq_id_Handle &id) const

bool IsLocked(void) const

void x_GetRecords(const CSeq_id_Handle &id, bool bioseq) const

CBioseq_Handle::TBioseqStateFlags TBlobState

bool HasMatchingAnnotIds(void) const

TAnnotLock & GetAnnotLock(void) const

bool x_HasIdObjects(const CSeq_id_Handle &id) const

atomic< ELoadState > m_LoadState

bool HasDataSource(void) const

CRef< CLoadMutex > m_LoadMutex

TIdAnnotInfoMap m_IdAnnotInfoMap

CTSE_Split_Info & GetSplitInfo(void)

bool HasSplitInfo(void) const

CTSE_LoadLockGuard(CDataSource *ds, CTSE_Info::CLoadMutex *mutex)

bool WaitForSignal(const CDeadline &deadline)

CRef< CTSE_Info::CLoadMutex > m_Mutex

CRef< CDataSource > m_DataSource

CTSE_LoadLockGuard operator=(const CTSE_LoadLockGuard &)

~CTSE_LoadLockGuard(void)

CTSE_LoadLockGuard(const CTSE_LoadLockGuard &)

CRef< CDataSource > GetDataSource(void) const

TThreadSystemID m_LoadLockOwner

CTSE_LoadLockGuard & x_GetGuard()

CRef< CDataSource > m_DataSource

bool IsLoaded(void) const

CTSE_LoadLock & operator=(const CTSE_LoadLock &lock)

void ReleaseLoadLock(void)

CRef< CObject > m_LoadLock

TTSE_LockSet m_TSE_LockSet

bool RemoveLock(const CTSE_Lock &lock)

bool PutLock(CTSE_Lock &lock)

bool AddLock(const CTSE_Lock &lock)

const_iterator begin(void) const

static bool IsBetter(const CTSE_Info &tse1, const CTSE_Info &tse2)

CTSE_Lock FindLock(const CTSE_Info *info) const

set< CTSE_Lock > GetBestTSEs(void) const

CConstRef< CObject > m_Info

void Swap(CTSE_Lock &lock)

bool x_Lock(const CTSE_Info *info)

void x_Assign(const CTSE_Lock &lock)

const CTSE_Info * GetNonNullPointer(void) const

void x_Relock(const CTSE_Info *info)

void x_LoadChunks(const TChunkIds &chunk_ids) const

CTimeout – Timeout interval.

container_type::const_iterator const_iterator

container_type::iterator iterator

const_iterator begin() const

const_iterator end() const

const_iterator lower_bound(const key_type &key) const

iterator_bool insert(const value_type &val)

container_type::value_type value_type

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator begin() const

const_iterator end() const

parent_type::const_iterator const_iterator

NCBI_PARAM_DEF_EX(unsigned, OBJMGR, BLOB_CACHE, 10, eParam_NoThread, OBJMGR_BLOB_CACHE)

NCBI_PARAM_DECL(unsigned, OBJMGR, BLOB_CACHE)

static void s_GetBlobs(CDataLoader *loader, CDataLoader::TTSE_LockSets &all_tse_sets, CDataLoader::TTSE_LockSets &current_tse_sets)

#define TSE_LOCK_TRACE(x)

NCBI_DEFINE_ERR_SUBCODE_X(3)

static void sx_AddAnnotMatch(CDataSource::TTSE_LockMatchSet &ret, const CTSE_Lock &tse_lock, const CSeq_id_Handle &id)

static string s_FormatCall(const char *method_name, const CSeq_id_Handle &seq_id)

static ostream & s_Format(ostream &out, const CSeq_id_Handle &seq_id)

static bool s_GetBulkChunks(void)

std::ofstream out("events_result.xml")

main entry point for tests

static const char * str(char *buf, int n)

static const struct type types[]

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

SStrictId_Tax::TId TTaxId

Taxon id type.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

TNCBIAtomicValue TValue

Alias TValue for TNCBIAtomicValue.

TValue Add(int delta) THROWS_NONE

Atomically add value (=delta), and return new counter value.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

TErrCode GetErrCode(void) const

Get error code.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

#define NCBI_THROW_FMT(exception_class, err_code, message)

The same as NCBI_THROW but with message processed as output to ostream.

void GetMatchingHandles(TMatches &matches) const

bool IsBetter(const CSeq_id_Handle &h) const

True if "this" is a better bioseq than "h".

string GetLabel(const CSeq_id &id)

bool HaveMatchingHandles(void) const

virtual int GetSequenceState(const CSeq_id_Handle &idh)

Request for a state of a sequence.

virtual void GetSequenceHashes(const TIds &ids, TLoaded &loaded, TSequenceHashes &ret, THashKnown &known)

Bulk request for hashes of a set of sequences.

void SetTargetDataSource(CDataSource &data_source)

Specify datasource to send loaded data to.

virtual TTSE_LockSet GetOrphanAnnotRecordsNA(const CSeq_id_Handle &idh, const SAnnotSelector *sel, TProcessedNAs *processed_nas)

new Get*AnnotRecords() methods

string GetName(void) const

virtual TTSE_Lock ResolveConflict(const CSeq_id_Handle &id, const TTSE_LockSet &tse_set)

Resolve TSE conflict *select the best TSE from the set of dead TSEs.

virtual void GetTaxIds(const TIds &ids, TLoaded &loaded, TTaxIds &ret)

Bulk request for taxonomy ids of a set of sequences.

virtual void GetBulkIds(const TIds &ids, TLoaded &loaded, TBulkIds &ret)

Bulk request for all Seq-ids of a set of sequences.

virtual TTSE_Lock GetBlobById(const TBlobId &blob_id)

virtual void GetIds(const CSeq_id_Handle &idh, TIds &ids)

Request for a list of all Seq-ids of a sequence.

EChoice

main blob is blob with sequence all other blobs are external and contain external annotations

virtual TTSE_LockSet GetRecords(const CSeq_id_Handle &idh, EChoice choice)

Request from a datasource using handles and ranges instead of seq-loc The TSEs loaded in this call wi...

virtual TTaxId GetTaxId(const CSeq_id_Handle &idh)

Request for a taxonomy id of a sequence.

virtual string GetLabel(const CSeq_id_Handle &idh)

Request for a label string of a sequence.

virtual STypeFound GetSequenceTypeFound(const CSeq_id_Handle &idh)

static CSeq_id_Handle x_GetAccVer(const TIds &ids)

virtual void GetSequenceTypes(const TIds &ids, TLoaded &loaded, TSequenceTypes &ret)

Bulk request for types of a set of sequences.

virtual void GetCDDAnnots(const TSeqIdSets &id_sets, TLoaded &loaded, TCDD_Locks &ret)

virtual void GetBlobs(TTSE_LockSets &tse_sets)

virtual SAccVerFound GetAccVerFound(const CSeq_id_Handle &idh)

void SetFailedCall(const string &call)

CBlobIdFor< const void * > CBlobIdPtr

virtual TSeqPos GetSequenceLength(const CSeq_id_Handle &idh)

Request for a length of a sequence.

virtual SHashFound GetSequenceHashFound(const CSeq_id_Handle &idh)

virtual SGiFound GetGiFound(const CSeq_id_Handle &idh)

virtual void GetSequenceLengths(const TIds &ids, TLoaded &loaded, TSequenceLengths &ret)

Bulk request for lengths of a set of sequences.

virtual void DropTSE(CRef< CTSE_Info > tse_info)

virtual void GetGis(const TIds &ids, TLoaded &loaded, TGis &ret)

Bulk request for gis of a set of sequences.

static TGi x_GetGi(const TIds &ids)

virtual TTSE_LockSet GetExternalAnnotRecordsNA(const CSeq_id_Handle &idh, const SAnnotSelector *sel, TProcessedNAs *processed_nas)

virtual void GetLabels(const TIds &ids, TLoaded &loaded, TLabels &ret)

Bulk request for label strings of a set of sequences.

virtual void GetSequenceStates(const TIds &ids, TLoaded &loaded, TSequenceStates &ret)

Bulk request for states of a set of sequences.

virtual void GetAccVers(const TIds &ids, TLoaded &loaded, TIds &ret)

Bulk request for accession.version Seq-ids of a set of sequences.

@ eBioseqCore

main blob with bioseq core (no seqdata and annots)

@ eFindConflict

Conflicting data found.

vector< CSeq_id_Handle > TId

bool IsIncludedAnyNamedAnnotAccession(void) const

check if any named annot accession is included in the search

const TNamedAnnotAccessions & GetNamedAnnotAccessions(void) const

@ eLevel_Parts

Parts only.

@ eLevel_Mains

Main bioseq only.

CConstRef< C > ConstRef(const C *object)

Template function for conversion of const object pointer to CConstRef.

CRef< C > Ref(C *object)

Helper functions to get CRef<> and CConstRef<> objects.

void Reset(void)

Reset reference object.

void Reset(void)

Reset reference object.

void Swap(TThisType &ref)

Swaps the pointer with another reference.

bool Referenced(void) const THROWS_NONE

Check if object is referenced.

#define NCBI_PARAM_TYPE(section, name)

Generate typename for a parameter from its {section, name} attributes.

@ eParam_NoThread

Do not use per-thread values.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define END_SCOPE(ns)

End the previously defined scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define BEGIN_SCOPE(ns)

Define a new scope.

bool Run(TRunMode flags=fRunDefault)

Run the thread.

static void GetSystemID(TThreadSystemID *id)

Get system ID of the current thread - for internal use only.

bool WaitForSignal(CMutex &mutex, const CDeadline &deadline=CDeadline::eInfinite)

Release mutex and lock the calling thread until the condition variable is signalled.

void SignalAll(void)

Wake all threads that are currently waiting on the condition variable.

pthread_t TThreadSystemID

Define platform-dependent thread ID type.

void Join(void **exit_data=0)

Wait for the thread termination.

@ eClass_parts

parts for 2 or 3

EMol

molecule class in living organism

@ eMol_not_set

> cdna = rna

EEmptyGuard

class CGuard<> implements a templatized "resource acquisition is initialization" (RAII) locking guard...

Definition of all error codes used in objmgr libraries (xobjmgr.lib, xobjutil.lib and others).

constexpr auto sort(_Init &&init)

double value_type

The numeric datatype used by the parser.

const GenericPointer< typename T::ValueType > T2 value

Common macro to detect used sanitizers and suppress memory leaks if run under LeakSanitizer.

Multi-threading – mutexes; rw-locks; semaphore.

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

void split(std::vector< std::string > *strVec, const std::string &str_, const std::string &split_)

static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)

Better replacement of GetAccVer(), this method should be defined in data loaders, GetAccVer() is left...

Better replacement of GetGi(), this method should be defined in data loaders, GetGi() is left for com...

Better replacement of GetSequenceHash(), this method should be defined in data loaders,...

Better replacement of GetSequenceType(), this method should be defined in data loaders,...

CConstRef< CBioseq_Info > m_Bioseq

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4