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

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

NCBI C++ ToolKit: include/corelib/ncbimtx.hpp Source File

pthread_self();

GetCurrentThreadId();

m_ID == tid.

;

m_ID != tid.

;

m_ID == tid.

;

m_ID != tid.

;

* GetErrCodeString(

)

;

CAutoInitializeStaticMutex;

CAutoInitializeStaticFastMutex;

eMutexUninitialized = 0,

eMutexInitialized = 0x2487adab

Lock(ELockSemantics lock = eNormal);

Unlock(ELockSemantics lock = eNormal);

TryLock(

);

ThrowUninitialized(

);

ThrowLockFailed(

);

ThrowUnlockFailed(

);

ThrowTryLockFailed(

);

InitializeStatic(

);

InitializeDynamic(

);

Destroy(

);

InitializeHandle(

);

DestroyHandle(

);

class ::ncbi::CAutoInitializeStaticFastMutex;

class ::ncbi::CFastMutex;

class ::ncbi::CSafeStaticPtr_Base;

NCBI_NAMESPACE_MUTEX::SSystemFastMutex;

TryLock(

);

ThrowNotOwned(

);

Destroy(

);

class ::ncbi::CAutoInitializeStaticMutex;

class ::ncbi::CMutex;

NCBI_NAMESPACE_MUTEX::SSystemMutex;

CAutoInitializeStaticFastMutex

SSystemFastMutex TObject;

TryLock(

);

TObject&(void);

Initialize(

);

TObject&

(

);

CAutoInitializeStaticMutex

SSystemMutex TObject;

TryLock(

);

TObject&(void);

Initialize(

);

TObject&

(

);

SSystemFastMutex&(void);

SSystemMutex&(void);

<

Class>

<

Class>

ReadLock(

);

WriteLock(

);

TryReadLock(

);

TryReadLock(

& timeout);

TryWriteLock(

);

TryWriteLock(

& timeout);

Unlock(

);

condition_variable m_Cv;

atomic<long> m_Count;

m_WaitingWriters;

vector<TThreadSystemID> m_Readers;

m_TrackReaders;

m_FavorWriters;

vector<TThreadSystemID>::const_iterator x_FindReader(

self_id);

x_TryReadLock();

x_TryWriteLock();

fTrackReaders = 0x40000000

<

Class>

<

Class>

ReadLock(

);

ReadUnlock(

);

WriteLock(

);

WriteUnlock(

);

kWriteLockValue = 0x100000

x_OnLockAcquired(

);

x_OnLockReleased(

);

DeleteThis(

);

(

init_count,

max_count);

TryWait(

timeout_sec = 0,

timeout_nsec = 0);

TryWait(

& timeout);

Post(

= 1);

condition_variable m_Cv;

m_Max;

m_Count;

x_TryAcquire(

);

IsSupported(

);

SignalSome(

);

SignalAll(

);

x_WaitForSignal(SSystemFastMutex& mutex,

& timeout);

pthread_cond_t m_ConditionVar;

* GetErrCodeString(

)

;

CAtomicCounter_WithAutoInit –.

CConditionVariableException –.

CNoLock is a simple no-op lock which does no real locking.

Holder of the lock inside CYieldingRWLock.

CTimeout – Timeout interval.

Read/write lock without blocking calls.

Interface for factory creating CRWLockHolder objects.

Interface for receiving messages about state changes in CRWLockHolder.

EErrCode

Error types that an application can generate.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

volatile unsigned int m_WaitingWriters

Number of writers waiting; zero if not keeping track.

CWriteLockGuard TWriteLockGuard

Define Write Lock Guard.

CSpinLock(const CSpinLock &)

Prohibit copying of the object.

TWriteLockGuard CWriteLockGuard

CGuard< CRWLock, SSimpleReadLock< CRWLock > > TReadLockGuard

bool operator!=(const CThreadSystemID &tid) const

Non-equality operator for thread ID.

ERWLockType

Type of locking provided by CYieldingRWLock.

CGuard< CFastRWLock, SSimpleReadLock< CFastRWLock >, SSimpleReadUnlock< CFastRWLock > > CFastReadGuard

ELockSemantics

This is for condition variables.

CSpinGuard TWriteLockGuard

Define Write Lock Guard.

CMutex(const CMutex &)

Private copy constructor to disallow initialization.

unique_ptr< CInternalRWLock > m_RW

Platform-dependent RW-lock data.

CRWLockHolder(const CRWLockHolder &)

CGuard< SSystemFastMutex > TFastMutexGuard

typedefs for ease of use

struct SSemaphore * m_Sem

System-specific semaphore data.

CFastMutexGuard TReadLockGuard

Define Read Lock Guard.

EFlags

Flags (passed at construction time) for fine-tuning lock behavior.

CFastRWLock(const CFastRWLock &)

friend class CYieldingRWLock

bool TryLock(void)

Attempt to lock the mutex and return TRUE if it succeeded or FALSE if mutex is locked by other thread...

CFastMutex(const CFastMutex &)

Private copy constructor to disallow initialization.

void operator()(Class &inst) const

void Lock(void)

Acquire mutex for the current thread with no nesting checks.

bool IsInitialized(void) const

Check if mutex is initialized.

CRWLockHolder(IRWLockHolder_Factory *factory)

Create lock holder bound to given object factory.

void Lock(void)

Lock mutex.

TFastMutexGuard CFastMutexGuard

...and backward compatibility

TReadLockGuard CReadLockGuard

bool IsLocked(void)

Check if any type of lock on this object is held.

TSystemMutex * GetHandle(void)

Get handle - Unix version.

EMagic

Initialization flag values.

CReadLockGuard TReadLockGuard

Define Read Lock Guard.

void InitializeDynamic(void)

Initialize dynamic mutex.

CSpinLock & operator=(const CSpinLock &)

CNoLock CNoMutex

CNoMutex –.

ERWLockType m_Type

Type of lock held.

~CFastMutex(void)

Destructor.

CFastMutex(void)

Constructor.

static CThreadSystemID GetCurrent(void)

Get the current thread ID.

virtual void OnLockAcquired(CRWLockHolder *holder)=0

Callback called when lock represented by CRWLockHolder is acquired.

CGuard< CSpinLock > CSpinGuard

bool IsLockAcquired(void) const

Check if lock requested is already granted.

CFastMutex m_WriteLock

Mutex implementing write lock.

CGuard< CRWLock, SSimpleWriteLock< CRWLock > > TWriteLockGuard

CYieldingRWLock * GetRWLock(void) const

Get lock object that is locked by this holder.

void Reset(void)

Reset holder to be able to use it later (after calling Init() )

bool operator==(const CThreadSystemID &tid) const

Equality operator for thread ID.

TThreadSystemID TID

Define a simpler alias for TThreadSystemID.

CSpinLock m_ObjLock

Main locking mutex for object operations.

CRef< CRWLockHolder > TRWLockHolderRef

Type that should be always used to store pointers to CRWLockHolder.

CMutex(void)

Constructor.

CMutexGuard TWriteLockGuard

Define Write Lock Guard.

SSystemFastMutex m_Mutex

Mutex value.

TFlags m_Flags

Configuration flags.

~CMutex(void)

Destructor.

virtual void OnLockReleased(CRWLockHolder *holder)=0

Callback called when lock represented by CRWLockHolder is released.

bool IsLocked(void) const

Check if mutex is currently locked.

THoldersList m_LockWaits

Queue for waiting lock requests.

TRWLockHolderRef AcquireWriteLock(void)

Write lock.

CIRef< IRWLockHolder_Listener > TRWLockHolder_ListenerRef

Types of smart references to IRWLockHolder_Listener.

virtual CRWLockHolder * CreateHolder(CYieldingRWLock *lock, ERWLockType typ)=0

Obtain new CRWLockHolder object for given CYieldingRWLock and necessary lock type.

vector< TThreadSystemID > m_Readers

List of all readers or writers.

CSemaphore(const CSemaphore &)

Private copy constructor to disallow initialization.

volatile long m_Count

Number of readers (if >0) or writers (if <0)

SSystemFastMutex *volatile m_WaitMutex

void RemoveListener(IRWLockHolder_Listener *listener)

Remove object keeping track of holder state changes.

SSystemFastMutex m_Mutex

Platform-dependent mutex handle, also used by CRWLock.

IRWLockHolder_Factory * m_Factory

Factory created the holder.

bool TryLock(void)

Try locking mutex.

CGuard< SSystemMutex > TMutexGuard

typedefs for ease of use

void Set(const CThreadSystemID &tid) volatile

volatile versions of above methods

TListenersList m_Listeners

List of holder listeners.

IRWLockHolder_Factory * m_Factory

Factory creating CRWLockHolder objects.

bool Is(const CThreadSystemID &tid) const volatile

bool IsNot(const CThreadSystemID &tid) const volatile

pthread_mutex_t TSystemMutex

Define a platform independent system mutex.

void AddListener(IRWLockHolder_Listener *listener)

Add object keeping track of holder state changes.

volatile EMagic m_Magic

Magic flag.

CAtomicCounter_WithAutoInit m_WaitCounter

CFastMutexGuard TWriteLockGuard

Define Write Lock Guard.

volatile TThreadSystemID m_Owner

Writer ID, one of the readers ID.

void Init(CYieldingRWLock *lock, ERWLockType typ)

Initialize holder for given CYieldingRWLock and necessary lock type.

bool IsUninitialized(void) const

Check if mutex is un-initialized.

void Unlock(void)

Unlock the mutex.

void ReleaseLock(void)

Release the lock held or cancel request for the lock.

CRWLock(const CRWLock &)

Private copy constructor to disallow initialization.

CMutex & operator=(const CMutex &)

Private assignment operator to disallow assignment.

virtual void DeleteHolder(CRWLockHolder *holder)=0

Free unnecessary (and unreferenced by anybody) CRWLockHolder object.

CWeakIRef< IRWLockHolder_Listener > TRWLockHolder_ListenerWeakRef

NCBI_EXCEPTION_DEFAULT(CConditionVariableException, CCoreException)

NCBI_EXCEPTION_DEFAULT(CMutexException, CCoreException)

CAtomicCounter m_LockCount

Number of read locks acquired or value of kWriteLockValue if write lock was acquired.

CSpinGuard TReadLockGuard

Define Read Lock Guard.

CFastMutex & operator=(const CFastMutex &)

Private assignment operator to disallow assignment.

void Unlock(void)

Unlock mutex.

bool IsUninitialized(void) const

Check if mutex is un-initialized.

void InitializeStatic(void)

Initialize static mutex.

SSystemMutex m_Mutex

System mutex.

void operator()(Class &inst) const

void operator()(Class &inst) const

CFastWriteGuard TWriteLockGuard

deque< TRWLockHolderRef > THoldersList

IRWLockHolder_Factory * GetFactory(void) const

Get factory which this object was created from.

bool IsInitialized(void) const

Check if mutex is initialized.

void Lock(void)

Lock the mutex.

list< TRWLockHolder_ListenerWeakRef > TListenersList

TMutexGuard CMutexGuard

...and backward compatibility

CYieldingRWLock * m_Lock

Lock object the holder is assigned to.

void operator()(Class &inst) const

CONDITION_VARIABLE m_ConditionVar

pthread_t TThreadSystemID

Define platform-dependent thread ID type.

atomic< TThreadSystemID > m_Owner

Platform-dependent owner thread ID.

TRWLockHolderRef AcquireReadLock(void)

Read lock.

CMutexGuard TReadLockGuard

Define Read Lock Guard.

atomic< int > m_Count

# of recursive (in the same thread) locks

CFastReadGuard TReadLockGuard

CGuard< CFastRWLock, SSimpleWriteLock< CFastRWLock >, SSimpleWriteUnlock< CFastRWLock > > CFastWriteGuard

CSpinLock m_ObjLock

Mutex for operating listeners.

int TFlags

binary OR of EFlags

void *volatile m_Value

Flag showing if mutex is locked (non-NULL value) or unlocked (NULL value).

TSystemMutex m_Handle

Mutex handle.

void Unlock(void)

Release mutex with no owner or nesting checks.

void CheckInitialized(void) const

Check initialized value of mutex.

bool m_LockAcquired

Flag if lock was acquired.

static TThreadSystemID GetCurrentThreadSystemID(void)

Get the current thread ID.

bool TryLock(void)

Try locking the mutex.

ERWLockType GetLockType(void) const

Get type of lock held.

#define NCBI_NAMESPACE_MUTEX

@ eTryLock

Attempted lock error.

@ eOwner

Not owned error.

@ eInfinite

Infinite deadline.

#define NCBI_XNCBI_EXPORT

#define HANDLE

An abstraction for a file handle.

const TYPE & Get(const CNamedParameterList *param)

Portable reference counted smart and weak pointers using CWeakRef, CRef, CObject and CObjectEx.

Multi-threading configuration.

Defines: CTimeFormat - storage class for time format.

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