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

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

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

sx_Value->

();

sx_Value->

();

sx_Value->

();

ds.GetDataLoader() &&

ds.GetDataLoader()->CanGetBlobById()),

m_CanBeEdited(ds.CanBeEdited()),

m_CanRemoveOnResetHistory(

),

);

( st_Guard ==

) {

guard->m_UnlockedTSEsLock.push_back(

(&*lock));

guard->m_UnlockedTSEsInternal.push_back(lock);

guard->m_UnlockedTSEsInternal.insert

(guard->m_UnlockedTSEsInternal.end(), locks.begin(), locks.end());

++

->m_TSE_LockCounter;

++

->m_UserLockCounter;

->SetTSE_Lock(lock);

.m_DS_Info =

;

.SetTSE_Lock(lock);

( tse_it->second == &tse ) {

( !tse ||

(idh, *it->second, *tse) ) {

);

( !unlocked.empty() ) {

it->second->DropTSE_Lock();

it->second->x_DetachDS();

vector< CRef<CTSE_ScopeInfo> > TTSEs;

( it->second->IsUserLocked() ) {

);

tses.push_back(it->second);

( lock.first.first ) {

ret.first.first = lock.first.first;

ret.first.second =

(lock.first.second);

ret.second = lock.second;

(

& [

, idh ] : ids ) {

.m_Seq_id = idh;

.m_Bioseq = bioseqs[

];

matches.swap(matches2);

( resolved1 != resolved2 ) {

( order1 != order2 ) {

order1 < order2;

.m_Seq_id = idh;

.m_Bioseq =

.m_TSE_Lock->GetTSE_Lock()->FindBioseq(idh);

( !

.m_TSE_Lock ) {

.m_Seq_id.Reset();

.m_Bioseq.Reset();

( match_map.

() ) {

( !ds_match->second ) {

( !scope_match ) {

match_map.

(ds_match->first);

: m_Source(&tse_lock->GetDataSource()),

m_BlobId(tse_lock->GetBlobId()),

m_BlobOrder(tse_lock->GetBlobOrder())

lock = m_Source->GetDataLoader()->GetBlobById(m_BlobId);

<<m_BlobId.ToString()<<

);

can_be_unloaded)

( can_be_unloaded ) {

(it->second->m_UsedByTSE ==

);

it->second->m_UsedByTSE = 0;

self_lock.

(

);

( &add_info ==

||

( p == &add_info ) {

(add_slot, add_lock);

( iter == edit_map.

() ) {

(&*old_obj == &*old_tse_lock);

new_obj.

(&*new_tse_lock);

(&*new_obj != &*old_obj);

->m_ObjectInfo = new_obj;

new_ds.

(*

, new_tse_lock);

(

<<

(!it->second->m_TSE_HandleAssigned);

it->second->m_ObjectInfoAssigned =

;

it->second->m_ObjectInfo.Reset();

(!it->second->HasObject());

( it->second->IsTemporary() ) {

it->second->x_DetachTSE(

);

it->second->m_TSE_HandleAssigned =

;

it->second->m_TSE_Handle.Reset();

it->second->m_ObjectInfoAssigned =

;

it->second->m_ObjectInfo.Reset();

(!it->second->HasObject());

it->second->x_DetachTSE(

);

(

().TSEIsInQueue(*

) ) {

pair<bool, CScopeInfo_Base*> ret;

( &s.second->m_TSE_Handle == tseh ) {

(s.second->m_LockCounter >= 1);

ret.second = s.second.GetNCPointer();

ret.first = s.second->m_LockCounter > 1;

action_if_locked,

( locked.first ) {

( action_if_locked ) {

);

( locked.second ) {

locked.second->m_TSE_HandleAssigned =

;

tse.

(locked.second->m_TSE_Handle);

action_if_locked,

(

.HaveMatchingHandles() ) {

<

TScopeInfo>

TScopeInfo::TObjectInfo&

)

scope_info =

TScopeInfo(tse,

);

scope_info = &

TScopeInfo&

(*iter->second);

ret->x_SetTSE_Handle(tse);

x_GetScopeLock<CSeq_entry_ScopeInfo>(tse,

);

x_GetScopeLock<CSeq_annot_ScopeInfo>(tse,

);

x_GetScopeLock<CBioseq_set_ScopeInfo>(tse,

);

( !ids.empty() ) {

->m_ObjectInfo = &*bioseq;

->m_ObjectInfoAssigned =

;

(iter->second->HasObject(*bioseq));

ret->x_SetTSE_Lock(tse, *bioseq);

( !

->HasObject() ) {

( !ids.empty() ) {

(0 &&

);

ret->x_SetTSE_Lock(tse, *bioseq);

ret->x_SetTSE_Handle(tse);

(find(ids.begin(), ids.end(),

.m_Seq_id) != ids.end());

( !ids.empty() ) {

( it->second->GetIds() == ids ) {

( it->second ==

) {

(0 &&

);

.GetObjectInfo().GetSet()));

.GetNCObjectInfo().Reset();

(child->IsDetached());

pair<CConstRef<CTSE_Info_Object>,

(!

.GetObjectInfo_Base().HasParent_Info());

(

<<&

<<

<<

);

( !it->first->BelongsToTSE_Info(*

) ) {

(

<<it->second<<

<< it->first);

it->second->m_TSE_HandleAssigned =

;

it->second->m_TSE_Handle.Reset();

it->second->x_DetachTSE(

);

( &*it->second != &

) {

(it->first->HasParent_Info());

.m_DetachedInfo.Reset(save);

(!it->second->IsDetached());

(&it->second->x_GetTSE_ScopeInfo() ==

);

(!it->second->HasObject() || it->second->GetObjectInfo_Base().BelongsToTSE_Info(*

));

(!

.GetObjectInfo_Base().HasParent_Info());

(

<<&child<<

<<

);

infos->GetData().push_back

(

<<it->second<<

<< it->first);

(

.m_LockCounter > 0 ) {

.x_AttachTSE(

);

m_UnresolvedTimestamp(timestamp)

m_UnresolvedTimestamp(0)

m_UnresolvedTimestamp(0)

ids.empty()? 0: &ids;

(

<<

<<

<<tse);

(

<<

<<

<<tse);

(

<<

<<

<<tse<<

);

( it != ids.begin() )

os << it->AsString();

( !

.AddId(

) ) {

.push_back(

);

TIds::iterator it = find(

.begin(),

.end(),

);

( *iter ==

) {

static CRef< CScope > m_Scope

void RemoveAnnot(CRef< CSeq_annot_Info > annot)

vector< CSeq_id_Handle > TId

const TId & GetId(void) const

TBlobStateFlags GetBlobState(void) const

bool HasBioseq(void) const

bool AddId(const CSeq_id_Handle &id)

TBlobStateFlags m_BlobState

string IdString(void) const

bool RemoveId(const CSeq_id_Handle &id)

const CBioseq_Info & GetObjectInfo(void) const

CBioseq_Info & GetNCObjectInfo(void)

void SetUnresolved(TBlobStateFlags flag, int timestamp)

CInitMutex< CSynonymsSet > m_SynCache

CBioseq_ScopeInfo(TBlobStateFlags flag, int timestamp)

atomic< int > m_UnresolvedTimestamp

const TIndexIds * GetIndexIds(void) const

const TIds & GetIds(void) const

void SetResolved(CTSE_ScopeInfo &tse, const TIds &ids)

void x_AttachTSE(CTSE_ScopeInfo *tse)

void x_DetachTSE(CTSE_ScopeInfo *tse)

TBioseq_Lock GetLock(CConstRef< CBioseq_Info > bioseq)

void x_ResetAnnotRef_Info()

void RemoveEntry(CRef< CSeq_entry_Info > entry)

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

TTSE_InfoMapMutex m_TSE_InfoMapMutex

void x_UnindexTSE(const CTSE_ScopeInfo &tse)

const TTSE_InfoMap & GetTSE_InfoMap(void) const

TSeq_annot_Lock FindSeq_annot_Lock(const CSeq_annot &annot)

void SetCanRemoveOnResetHistory(void)

void ReleaseTSEUserLock(CTSE_ScopeInfo &tse)

bool TSEIsInQueue(const CTSE_ScopeInfo &tse) const

static bool x_IsBetter(const CSeq_id_Handle &idh, const CTSE_ScopeInfo &tse1, const CTSE_ScopeInfo &tse2)

~CDataSource_ScopeInfo(void)

TBioseq_set_Lock FindBioseq_set_Lock(const CBioseq_set &seqset)

const TTSE_LockSet & GetTSE_LockSet(void) const

CDataSource_ScopeInfo(CScope_Impl &scope, CDataSource &ds)

TTSE_ScopeInfo x_FindBestTSEInIndex(const CSeq_id_Handle &idh) const

pair< TSeq_annot_Lock, int > TSeq_feat_Lock

TTSE_UnlockQueue m_TSE_UnlockQueue

friend class CTSE_ScopeInfo

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

TTSE_LockSet m_TSE_LockSet

CTSE_ScopeUserLock TTSE_Lock

TTSE_BySeqId m_TSE_BySeqId

void AddTSE_Lock(const CTSE_Lock &lock)

bool TSEIsReplaced(const TBlobId &blob_id) const

TTSE_InfoMapMutex & GetTSE_InfoMapMutex(void) const

CScope_Impl & GetScopeImpl(void) const

set< TBlobId > m_ReplacedTSEs

bool CanRemoveOnResetHistory(void) const

CDataSource & GetDataSource(void)

void GetBlobs(TSeqMatchMap &match_map)

CScopeInfo_Ref< CBioseq_ScopeInfo > TBioseq_Lock

TBioseq_Lock FindBioseq_Lock(const CBioseq &bioseq)

TTSE_LockSetMutex m_TSE_LockSetMutex

void ResetHistory(int action_if_locked)

pair< CConstRef< CSeq_entry_Info >, TTSE_Lock > TSeq_entry_Lock

void RemoveTSE_Lock(const CTSE_Lock &lock)

void ForgetTSELock(CTSE_ScopeInfo &tse)

TTSE_Lock FindTSE_Lock(const CSeq_entry &tse)

TTSE_Lock GetTSE_Lock(const CTSE_Lock &tse)

TDataSourceLock m_DataSource

void AttachTSE(CTSE_ScopeInfo &tse, const CTSE_Lock &lock)

TSeq_entry_Lock FindSeq_entry_Lock(const CSeq_entry &entry)

CRef< CDataSource_ScopeInfo > m_EditDS

TTSE_InfoMap m_TSE_InfoMap

pair< CConstRef< CBioseq_set_Info >, TTSE_Lock > TBioseq_set_Lock

pair< CConstRef< CSeq_annot_Info >, TTSE_Lock > TSeq_annot_Lock

void x_IndexTSE(CTSE_ScopeInfo &tse)

SSeqMatch_Scope BestResolve(const CSeq_id_Handle &idh, int get_flag)

void x_SetMatch(SSeqMatch_Scope &match, CTSE_ScopeInfo &tse, const CSeq_id_Handle &idh) const

TTSE_LockSetMutex m_TSE_UnlockQueueMutex

void RemoveFromHistory(CTSE_ScopeInfo &tse, bool drop_from_ds=false)

bool m_CanRemoveOnResetHistory

SSeqMatch_Scope x_FindBestTSE(const CSeq_id_Handle &idh)

map< size_t, SSeqMatch_Scope > ResolveBulk(const map< size_t, CSeq_id_Handle > &ids, CTSE_ScopeInfo &tse)

void AcquireTSEUserLock(CTSE_ScopeInfo &tse)

CDataLoader * GetDataLoader(void)

SSeqMatch_Scope x_GetSeqMatch(const CSeq_id_Handle &idh)

bool CanBeEdited(void) const

SSeqMatch_Scope Resolve(const CSeq_id_Handle &idh, CTSE_ScopeInfo &tse)

TSeq_entry_Lock GetSeq_entry_Lock(const CBlobIdKey &blob_id)

pair< CConstRef< CSeq_annot_Info >, TTSE_Lock > TSeq_annot_Lock

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

TSeq_entry_Lock GetSeq_entry_Lock(const CBlobIdKey &blob_id)

SSeqMatch_DS BestResolve(const CSeq_id_Handle &idh)

bool CanBeEdited(void) const

bool DropStaticTSE(CTSE_Info &info)

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

void GetBlobs(TSeqMatchMap &match_map)

CDataLoader * GetDataLoader(void) const

pair< CConstRef< CSeq_entry_Info >, TTSE_Lock > TSeq_entry_Lock

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

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

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

vector< SSeqMatch_DS > TSeqMatches

pair< CConstRef< CBioseq_set_Info >, TTSE_Lock > TBioseq_set_Lock

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

pair< TSeq_annot_Lock, int > TSeq_feat_Lock

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

vector< value_type > TUnlockSet

void Clear(TUnlockSet *unlock_set=0)

void Put(const key_type &key, const value_type &value, value_type *unlock_ptr)

bool Contains(const key_type &key) const

void Erase(const key_type &key, value_type *unlock_ptr=0)

Data loader exceptions, used by GenBank loader.

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

Base class for all object manager exceptions.

T & Get(void)

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

CRef< CObject > m_DetachedInfo

bool IsDetached(void) const

const CTSE_Handle & GetTSE_Handle(void) const

virtual void x_DetachTSE(CTSE_ScopeInfo *tse)

bool IsAttached(void) const

CScope_Impl & x_GetScopeImpl(void) const

CTSE_ScopeInfo & x_GetTSE_ScopeInfo(void) const

vector< TIndexId > TIndexIds

virtual void x_AttachTSE(CTSE_ScopeInfo *tse)

const CTSE_Info_Object & GetObjectInfo_Base(void) const

bool HasObject(void) const

atomic< Uint8 > m_LockCounter

CRef< CObjectManager > m_ObjMgr

void x_ClearCacheOnRemoveSeqId(const CSeq_id_Handle &id, CBioseq_ScopeInfo &seq)

void x_ClearCacheOnNewData(const TIds &seq_ids, const TIds &annot_ids)

const CBioseq_Base_Info & GetParentBioseq_Base_Info(void) const

TSeq & SelectSeq(TSeq &seq)

CRef< CSeq_annot_Info > AddAnnot(CSeq_annot &annot)

E_Choice Which(void) const

const CBioseq_set_Info & GetParentBioseq_set_Info(void) const

namespace ncbi::objects::

static CSeq_id_Handle GetSeq_id_Handle(const const_iterator &iter)

bool ContainsSynonym(const CSeq_id_Handle &id) const

vector< value_type > TIdSet

void AddSynonym(const value_type &syn)

TIdSet::const_iterator const_iterator

void Swap(CTSE_Handle &tse)

TScopeInfo & x_GetScopeInfo(void) const

const CTSE_Info & x_GetTSE_Info(void) const

bool BelongsToTSE_Info(const CTSE_Info &tse) const

bool HasParent_Info(void) const

bool HasTSE_Info(void) const

TBlobOrder GetBlobOrder(void) const

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

CDataSource & GetDataSource(void) const

TBlobState GetBlobState(void) const

CSeq_id_Handle ContainsMatchingBioseq(const CSeq_id_Handle &id) const

unique_ptr< SBaseTSE > m_BaseTSE

virtual string GetDescription(void) const

const TBlobId & GetBlobId(void) const

virtual void GetBioseqsIds(TSeqIds &ids) const

bool ContainsBioseq(const CSeq_id_Handle &id) const

map< size_t, CConstRef< CBioseq_Info > > FindBioseqBulk(const map< size_t, CSeq_id_Handle > &ids) const

bool RemoveLock(const CTSE_Lock &lock)

bool AddLock(const CTSE_Lock &lock)

void Swap(CTSE_Lock &lock)

CScopeInfo_Ref< TScopeInfo > x_GetScopeLock(const CTSE_Handle &tse, const typename TScopeInfo::TObjectInfo &info)

CDataSource_ScopeInfo & GetDSInfo(void) const

void x_InternalUnlockTSE(void)

void x_CheckAdded(CScopeInfo_Base &parent, CScopeInfo_Base &child)

void AddAnnot(CSeq_entry_ScopeInfo &entry, CSeq_annot_ScopeInfo &info)

void ResetEntry(CSeq_entry_ScopeInfo &info)

pair< int, int > TBlobOrder

CRef< CBioseq_ScopeInfo > GetBioseqInfo(const SSeqMatch_Scope &match)

void x_UserRelockTSE(void)

pair< bool, CScopeInfo_Base * > GetUserLockState(const CTSE_Handle *tseh) const

bool x_VerifyTSE_LockIsNotAssigned() const

bool ContainsBioseq(const CSeq_id_Handle &id) const

CSeq_id_Handle ContainsMatchingBioseq(const CSeq_id_Handle &id) const

const CTSE_Lock & GetTSE_Lock(void) const

AutoPtr< SUnloadedInfo > m_UnloadedInfo

TSeq_entry_Lock GetScopeLock(const CTSE_Handle &tse, const CSeq_entry_Info &info)

bool CanBeUnloaded(void) const

bool HasResolvedBioseq(const CSeq_id_Handle &id) const

bool AddUsedTSE(const CTSE_ScopeUserLock &lock) const

int GetLoadIndex(void) const

atomic< Int8 > m_TSE_LockCounter

void x_SaveRemoved(CScopeInfo_Base &info)

void ReplaceTSE(const CTSE_Info &old_tse)

void x_UnindexBioseq(const CSeq_id_Handle &id, const CBioseq_ScopeInfo *info)

void x_IndexBioseq(const CSeq_id_Handle &id, CBioseq_ScopeInfo *info)

CMutex m_ScopeInfoMapMutex

TBlobId GetBlobId(void) const

void RestoreReplacedTSE(void)

vector< CSeq_id_Handle > TSeqIds

const TSeqIds & GetBioseqsIds(void) const

void x_InternalRelockTSE(void)

int x_GetDSLocksCount(void) const

bool x_TSE_LockIsAssigned() const

void RemoveFromHistory(const CTSE_Handle *tseh, int action_if_locked, bool drop_from_ds=false)

friend class CBioseq_ScopeInfo

bool IsUserLocked(void) const

atomic< Int8 > m_UserLockCounter

const CTSE_ScopeInfo * m_UsedByTSE

void RemoveAnnot(CSeq_annot_ScopeInfo &info)

atomic< Int1 > m_TSE_LockAssignState

void ForgetTSE_Lock(void)

CRef< CBioseq_ScopeInfo > x_FindBioseqInfo(const TSeqIds &ids) const

void SelectSet(CSeq_entry_ScopeInfo &entry, CBioseq_set_ScopeInfo &info)

TBlobOrder GetBlobOrder(void) const

bool x_TSE_LockIsNotAssigned() const

SSeqMatch_Scope Resolve(const CSeq_id_Handle &id)

bool CanBeEdited(void) const

map< size_t, SSeqMatch_Scope > ResolveBulk(const map< size_t, CSeq_id_Handle > &ids)

void SetTSE_Lock(const CTSE_Lock &lock)

void x_UserUnlockTSE(void)

void x_InternalLockTSE(void)

TUsedTSE_LockSet m_UsedTSE_Set

TBioseq_Lock GetBioseqLock(CRef< CBioseq_ScopeInfo > info, CConstRef< CBioseq_Info > bioseq)

void ReleaseUsedTSEs(void)

void SelectSeq(CSeq_entry_ScopeInfo &entry, CBioseq_ScopeInfo &info)

CDataSource_ScopeInfo * m_DS_Info

bool IsAttached(void) const

bool x_VerifyTSE_LockIsAssigned() const

bool x_SameTSE(const CTSE_Info &tse) const

void SetEditTSE(const CTSE_Lock &new_tse_lock, CDataSource_ScopeInfo &new_ds)

CTSE_ScopeInfo(CDataSource_ScopeInfo &ds_info, const CTSE_Lock &tse_lock, int load_index, bool can_be_unloaded)

CRef< CBioseq_ScopeInfo > x_CreateBioseqInfo(const TSeqIds &ids)

void x_RestoreAdded(CScopeInfo_Base &parent, CScopeInfo_Base &child)

void RemoveEntry(CSeq_entry_ScopeInfo &info)

void AddEntry(CBioseq_set_ScopeInfo &seqset, CSeq_entry_ScopeInfo &info, int index)

TScopeInfoMap m_ScopeInfoMap

void Lock(CTSE_ScopeInfo *tse) const

void Unlock(CTSE_ScopeInfo *tse) const

void Relock(CTSE_ScopeInfo *tse) const

void Lock(CTSE_ScopeInfo *tse) const

void Unlock(CTSE_ScopeInfo *tse) const

void Relock(CTSE_ScopeInfo *tse) const

TUnlockedTSEsLock m_UnlockedTSEsLock

vector< CTSE_ScopeInternalLock > TUnlockedTSEsInternal

vector< CConstRef< CTSE_Info > > TUnlockedTSEsLock

static void SaveInternal(const CTSE_ScopeInternalLock &lock)

TUnlockedTSEsInternal m_UnlockedTSEsInternal

static void SaveLock(const CTSE_Lock &lock)

~CUnlockedTSEsGuard(void)

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

container_type::const_iterator const_iterator

const_iterator find(const key_type &key) const

const_iterator lower_bound(const key_type &key) const

const_iterator end() const

iterator insert(const value_type &val)

const_iterator begin() const

container_type::iterator iterator

container_type::value_type value_type

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.

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

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

#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".

bool HaveMatchingHandles(void) const

void ReleaseDataSource(TDataSourceLock &data_source)

@ eGetBioseq_All

Search bioseq, load if not loaded yet.

TObjectInfo & GetNCObjectInfo(void)

const TObjectInfo & GetObjectInfo(void) const

TObjectInfo & GetNCObjectInfo(void)

TObjectInfo & GetNCObjectInfo(void)

const TObjectInfo & GetObjectInfo(void) const

TObjectType * GetNCPointer(void) const THROWS_NONE

Get pointer,.

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 Relock(const CObject *object) const

void Reset(void)

Reset reference object.

void Reset(void)

Reset reference object.

void Unlock(const CObject *object) const

void Lock(const CObject *object) const

#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.

@ e_not_set

No variant selected.

const struct ncbi::grid::netcache::search::fields::KEY key

const GenericPointer< typename T::ValueType > T2 value

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)

static DECLARE_TLS_VAR(CUnlockedTSEsGuard *, st_Guard)

static int s_GetScopePostponeDelete(void)

NCBI_PARAM_DECL(bool, OBJMGR, SCOPE_AUTORELEASE)

pair< CConstRef< CTSE_Info_Object >, CRef< CScopeInfo_Base > > TDetachedInfoElement

vector< TDetachedInfoElement > TDetachedInfo

DEFINE_STATIC_FAST_MUTEX(sx_UsedTSEMutex)

#define _TRACE_TSE_LOCK(x)

static unsigned s_GetScopeAutoReleaseSize(void)

static bool s_GetScopeAutoReleaseEnabled(void)

NCBI_PARAM_DEF_EX(bool, OBJMGR, SCOPE_AUTORELEASE, true, eParam_NoThread, OBJMGR_SCOPE_AUTORELEASE)

SUnloadedInfo(const CTSE_Lock &lock)

CRef< CDataSource > m_Source

CTSE_ScopeUserLock m_TSE_Lock

CConstRef< CBioseq_Info > m_Bioseq

CRef< CTSE_ScopeInfo, CTSE_ScopeInternalLocker > CTSE_ScopeInternalLock

CRef< CTSE_ScopeInfo, CTSE_ScopeUserLocker > CTSE_ScopeUserLock

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