自学教程：C++ ASSUME_LOCK函数代码示例

// Find the newest neighbor objectCNeighbour* CNeighboursBase::GetNewest(PROTOCOLID nProtocol, int nState, int nNodeType) const{	ASSUME_LOCK( Network.m_pSection );	const DWORD tNow = GetTickCount();	DWORD tMinTime = 0xffffffff;	CNeighbour* pNewestNeighbour = NULL;	for ( POSITION pos = GetIterator() ; pos ; )	{		CNeighbour* pNeighbour = GetNext( pos );		if ( ( nProtocol == PROTOCOL_ANY || nProtocol == pNeighbour->m_nProtocol ) &&			 ( nState < 0 || nState == pNeighbour->m_nState ) &&			 ( nNodeType < 0 || nNodeType == pNeighbour->m_nNodeType ) )		{			DWORD tTime = tNow - pNeighbour->m_tConnected;			if ( tTime < tMinTime )			{				tMinTime = tTime;				pNewestNeighbour = pNeighbour;			}		}	}	return pNewestNeighbour;}

void CDownloadTransfer::Close(TRISTATE bKeepSource, DWORD nRetryAfter){	ASSUME_LOCK( Transfers.m_pSection );	SetState( dtsNull );//	if ( m_nProtocol != PROTOCOL_BT && m_nProtocol != PROTOCOL_ED2K )	CTransfer::Close();	if ( CDownloadSource* pSource = m_pSource )	{		m_pSource = NULL;		switch ( bKeepSource )		{		case TRI_TRUE:			if ( pSource->m_bCloseConn && pSource->m_nGnutella )				pSource->OnResumeClosed();			else				pSource->OnFailure( TRUE, nRetryAfter );			break;		case TRI_UNKNOWN:			pSource->OnFailure( FALSE );			break;		case TRI_FALSE:			pSource->Remove( FALSE, TRUE );			break;		}	}	if ( m_pDownload )		m_pDownload->RemoveTransfer( this );}

INT_PTR CDownloadSheet::DoModal(){	ASSUME_LOCK( Transfers.m_pSection );	CTorrentFilesPage		pFiles;	CTorrentTrackersPage	pTrackers;	CTorrentGeneralPage		pGeneral;	CDownloadEditPage		pDownload;	CDownloadActionsPage	pActions;	if ( m_pDownload->IsTorrent() )	{		SetTabTitle( &pFiles, m_sFilesTitle );		AddPage( &pFiles );		SetTabTitle( &pTrackers, m_sTrackersTitle );		AddPage( &pTrackers );		SetTabTitle( &pGeneral, m_sGeneralTitle );		AddPage( &pGeneral );	}	if ( ! m_pDownload->IsMoving() && ! m_pDownload->IsCompleted() )	{		SetTabTitle( &pDownload, m_sDownloadTitle );		AddPage( &pDownload );		SetTabTitle( &pActions, m_sActionsTitle );		AddPage( &pActions );	}	return CPropertySheetAdv::DoModal();}

void CDatagrams::remove(DatagramOut* pDatagramOut){	ASSUME_LOCK(m_pSection);	m_SendCacheMap.remove(pDatagramOut->m_nSequence);	QLinkedList<DatagramOut*>::iterator itFrame = m_SendCache.end();	while( itFrame != m_SendCache.begin() )	{		--itFrame;		if( *itFrame == pDatagramOut )		{			m_SendCache.erase(itFrame);			break;		}	}	m_FreeDatagramOut.append(pDatagramOut);	if(pDatagramOut->m_pBuffer)	{		m_FreeBuffer.append(pDatagramOut->m_pBuffer);		pDatagramOut->m_pBuffer->clear();		pDatagramOut->m_pBuffer = 0;	}}

bool CDownloadTransferBT::UnrequestRange(QWORD nOffset, QWORD nLength){	ASSUME_LOCK( Transfers.m_pSection );	if ( m_oRequested.empty() ) 		return false;	ASSERT( m_pDownload->m_pTorrent.m_nBlockSize != 0 );	if ( m_pDownload->m_pTorrent.m_nBlockSize == 0 )		return false;	Fragments::Queue oUnrequests = extract_range( m_oRequested,		Fragments::Fragment( nOffset, nOffset + nLength ) );	for ( Fragments::Queue::const_iterator pFragment = oUnrequests.begin();		pFragment != oUnrequests.end(); ++pFragment )	{		m_pClient->Cancel(			(DWORD)( pFragment->begin() / m_pDownload->m_pTorrent.m_nBlockSize ),			(DWORD)( pFragment->begin() % m_pDownload->m_pTorrent.m_nBlockSize ),			(DWORD)( pFragment->size() ) );	}	return !oUnrequests.empty();}

CTransfer::CTransfer(void* pOwner, QObject *parent) :	CNetworkConnection(parent),	m_pOwner(pOwner){	ASSUME_LOCK(Transfers.m_pSection);	Transfers.add(this);}

CFileList* CLibraryMaps::WhatsNew(const CQuerySearch* pSearch, int nMaximum) const{	ASSUME_LOCK( Library.m_pSection );	const DWORD tNow = static_cast< DWORD >( time( NULL ) );	CFileList* pHits = NULL;	for ( POSITION pos = GetFileIterator() ; pos ; )	{		CLibraryFile* pFile = GetNextFile( pos );		if ( pFile->IsAvailable() && pFile->IsShared() && pFile->m_oSHA1 &&			( ! pSearch->m_pSchema || pSearch->m_pSchema->Equals( pFile->m_pSchema ) ) )		{			const DWORD nTime = pFile->GetCreationTime();			if ( nTime && nTime + 12 * 60 * 60 > tNow )		// 12 hours			{				pFile->m_nHitsToday++;				pFile->m_nHitsTotal++;				if ( ! pHits )					pHits = new CFileList;				pHits->AddTail( pFile );				if ( nMaximum && pHits->GetCount() >= nMaximum )					break;			}		}	}	return pHits;}

bool CLibraryTileItem::Update(){	ASSUME_LOCK( Library.m_pSection );	if ( m_pAlbum->m_nUpdateCookie == m_nCookie ) return false;	m_nCookie		= m_pAlbum->m_nUpdateCookie;	m_sTitle		= m_pAlbum->m_sName;	m_nIcon32		= m_pAlbum->m_pSchema ? m_pAlbum->m_pSchema->m_nIcon32 : -1;	m_nIcon48		= m_pAlbum->m_pSchema ? m_pAlbum->m_pSchema->m_nIcon48 : -1;	m_bCollection	= m_pAlbum->m_oCollSHA1.isValid();	CSchemaPtr pSchema = m_pAlbum->m_pSchema;	if ( pSchema != NULL && m_pAlbum->m_pXML != NULL )	{		m_sSubtitle1 = pSchema->m_sTileLine1;		m_sSubtitle2 = pSchema->m_sTileLine2;		pSchema->ResolveTokens( m_sSubtitle1, m_pAlbum->m_pXML );		pSchema->ResolveTokens( m_sSubtitle2, m_pAlbum->m_pXML );	}	else	{		m_sSubtitle1.Empty();		m_sSubtitle2.Empty();	}	return true;}

void CDownloadWithSources::InternalAdd(CDownloadSource* pSource){	ASSUME_LOCK( Transfers.m_pSection );	ASSERT( m_pSources.Find( pSource ) == NULL );	m_pSources.AddTail( pSource );	switch ( pSource->m_nProtocol )	{	case PROTOCOL_G1:		m_nG1SourceCount++;		break;	case PROTOCOL_G2:		m_nG2SourceCount++;		break;	case PROTOCOL_ED2K:		m_nEdSourceCount++;		break;	case PROTOCOL_BT:		m_nBTSourceCount++;		break;	case PROTOCOL_HTTP:		m_nHTTPSourceCount++;		break;	case PROTOCOL_FTP:		m_nFTPSourceCount++;		break;	case PROTOCOL_DC:		m_nDCSourceCount++;		break;	default:		ASSERT( FALSE );	}}

BOOL CHostBrowser::StreamPacketsG2(){	ASSUME_LOCK( Transfers.m_pSection );	ASSERT( m_nProtocol == PROTOCOL_G2 );	while ( CG2Packet* pPacket = CG2Packet::ReadBuffer( m_pBuffer ) )	{		BOOL bSuccess = FALSE;		try		{			bSuccess = OnPacket( pPacket );		}		catch ( CException* pException )		{			pException->Delete();		}		pPacket->Release();		if ( ! bSuccess )		{			Stop();			return FALSE;		}	}	return TRUE;}

const CQueryHashTable* CLibraryDictionary::GetHashTable(){	ASSUME_LOCK( Library.m_pSection );	BuildHashTable();	return m_pTable;}

void CNeighboursConnections::RemoveNode(CNeighbour* pNode){	ASSUME_LOCK(m_pSection);	m_pController->RemoveSocket(pNode);	CNeighboursRouting::RemoveNode(pNode);}

BOOL CManagedSearch::Execute(int nPriorityClass){	ASSUME_LOCK( SearchManager.m_pSection );	if ( m_nPriority != nPriorityClass || ! m_bActive || ! m_pSearch )		return FALSE;	// Throttle this individual search (so it doesn't take up too many resources)	DWORD nThrottle = Settings.Search.GeneralThrottle;	if ( m_nPriority == spLowest )		nThrottle += 30000; // + 30s	else if ( m_nPriority == spMedium )		nThrottle += 800;	// + .8s	const DWORD tTicks = GetTickCount();	const DWORD tSecs = static_cast< DWORD >( time( NULL ) );	if ( tTicks < m_tExecute + nThrottle )		return FALSE;	m_tExecute = tTicks;	// Search local neighbours: hubs, servers and ultrapeers. (TCP)	BOOL bSuccess = ExecuteNeighbours( tTicks, tSecs );	// G1 multicast search. (UDP)	if ( Settings.Gnutella1.Enabled && m_bAllowG1 &&		 tTicks >= m_tLastG1 + Settings.Gnutella1.QueryGlobalThrottle &&		 Network.IsListening() )	{		bSuccess |= ExecuteG1Mesh( tTicks, tSecs );		m_tLastG1 = tTicks;	}	// G2 global search. (UDP)	if ( Settings.Gnutella2.Enabled && m_bAllowG2 &&		 tTicks >= m_tLastG2 + Settings.Gnutella2.QueryGlobalThrottle &&		 Network.IsListening() )	{		bSuccess |= ExecuteG2Mesh( tTicks, tSecs );		m_tLastG2 = tTicks;	}	// ED2K global search. (UDP)	if ( Settings.eDonkey.Enabled &&		 Settings.eDonkey.ServerWalk &&		 m_bAllowED2K &&		 tTicks >= m_tLastED2K + Settings.eDonkey.QueryGlobalThrottle &&		 Network.IsListening() &&		 ( m_pSearch->m_oED2K || IsLastSearch() ) )	{		bSuccess |= ExecuteDonkeyMesh( tTicks, tSecs );		m_tLastED2K = tTicks;	}	if ( bSuccess ) m_nQueryCount++;	return bSuccess;}

BOOL CUploadTransferDC::OnWrite(){	ASSUME_LOCK( Transfers.m_pSection );	ASSERT( m_pClient );	m_mOutput.tLast = m_pClient->m_mOutput.tLast;	if ( m_pClient->GetOutputLength() != 0 )		// There is data in output buffer		return TRUE;	if ( m_nState == upsUploading )	{		ASSERT( m_nLength != SIZE_UNKNOWN );		// No file data left to transfer		if ( m_nPosition >= m_nLength )		{			// File completed			Uploads.SetStable( GetAverageSpeed() );			m_nState = upsRequest;			m_tRequest = GetTickCount();			m_pBaseFile->AddFragment( m_nOffset, m_nLength );			theApp.Message( MSG_INFO, IDS_UPLOAD_FINISHED, (LPCTSTR)m_sName, (LPCTSTR)m_sAddress );		}		else		{			// Reading next data chunk of file			QWORD nToRead = min( m_nLength - m_nPosition, (QWORD)Settings.Uploads.ChunkSize );	// ~1000 KB			QWORD nRead = 0;			auto_array< BYTE > pBuffer( new BYTE[ nToRead ] );			if ( ! ReadFile( m_nFileBase + m_nOffset + m_nPosition, pBuffer.get(), nToRead, &nRead ) || nToRead != nRead )			{				// File error				return FALSE;			}			m_pClient->Write( pBuffer.get(), (DWORD)nRead );			m_nPosition += nRead;			m_nUploaded += nRead;			Statistics.Current.Uploads.Volume += ( nRead / 1024 );		}	}	else if ( m_nState >= upsResponse )	{		// Current transfer completed		m_nState	= ( m_nState == upsPreQueue ) ? upsQueued : upsRequest;		m_tRequest	= GetTickCount();	}	return TRUE;}

POSITION CUploadsCtrl::GetFileIterator(CUploadQueue* pQueue){	ASSUME_LOCK( Transfers.m_pSection );	if ( pQueue == UploadQueues.m_pTorrentQueue )	{		for ( POSITION posNext = UploadFiles.GetIterator() ; posNext ; )		{			POSITION posThis = posNext;			CUploadFile* pFile = UploadFiles.GetNext( posNext );			CUploadTransfer* pTransfer = pFile->GetActive();			if ( pTransfer == NULL || pTransfer->m_nState == upsNull ) continue;			if ( pTransfer->m_nProtocol != PROTOCOL_BT ) continue;			return posThis;		}				return NULL;	}	else if ( pQueue == UploadQueues.m_pHistoryQueue )	{		for ( POSITION posNext = UploadFiles.GetIterator() ; posNext ; )		{			POSITION posThis = posNext;			CUploadFile* pFile = UploadFiles.GetNext( posNext );			CUploadTransfer* pTransfer = pFile->GetActive();			if ( pTransfer != NULL )			{				if ( pTransfer->m_nProtocol == PROTOCOL_BT && pTransfer->m_nState != upsNull ) continue;				if ( pTransfer->m_pQueue != NULL ) continue;			}			return posThis;		}				return NULL;	}	else	{		if ( Settings.Uploads.FilterMask & ULF_ACTIVE )		{			if ( pQueue->GetActiveCount() > 0 )			{				return pQueue->GetActiveIterator();			}		}				if ( Settings.Uploads.FilterMask & ULF_QUEUED )		{			if ( pQueue->GetQueuedCount() > 0 )			{				return (POSITION)1;			}		}				return NULL;	}}