matchobjects.cpp

著名的下载软件核心Shareaza

{
	if ( pHit->m_nSize != m_nSize ) return FALSE;
	
	if ( ! bForce )
	{
		if ( m_bSHA1 && ( pHit->m_bSHA1 || Settings.General.HashIntegrity ) )
		{
			if ( ! pHit->m_bSHA1 ) return FALSE;
			if ( m_pSHA1 != pHit->m_pSHA1 ) return FALSE;
			bForce = TRUE;
		}
		else if ( ! m_bSHA1 && pHit->m_bSHA1 && Settings.General.HashIntegrity && m_pHits )
		{
			return FALSE;
		}
	}
	
	BOOL bSubstituted = FALSE;
	
	if ( m_pHits )
	{
		for ( CQueryHit* pOld = m_pHits ; pOld ; pOld = pOld->m_pNext )
		{
			BOOL bName = _tcsicmp( pHit->m_sName, pOld->m_sName ) == 0;
			
			if ( ! bForce && bName ) bForce = TRUE;
			
			if ( bName && pHit->m_pAddress.S_un.S_addr == pOld->m_pAddress.S_un.S_addr &&
				 pHit->m_nPort == pOld->m_nPort )
			{
				if ( pOld->m_bFiltered )
				{
					m_nFiltered --;
					m_nSources -= pOld->GetSources();
					m_nSpeed -= pOld->m_nSpeed;
				}
				
				pOld->Copy( pHit );
				delete pHit;
				
				pHit = pOld;
				bForce = bSubstituted = TRUE;
				break;
			}
		}
		
		if ( ! bForce ) return FALSE;
	}
	
	if ( ! bSubstituted )
	{
		pHit->m_pNext = m_pHits;
		m_pHits = pHit;
		m_nTotal++;
	}
	
	CSingleLock pLock1( &Library.m_pSection );
	BOOL bLocked = FALSE;
	
	if ( ! m_bSHA1 && pHit->m_bSHA1 )
	{
		m_pSHA1 = pHit->m_pSHA1;
		m_bSHA1 = TRUE;
		
		if ( ! m_bExisting && pLock1.Lock( 100 ) )
		{
			if ( CLibraryFile* pExisting = LibraryMaps.LookupFileBySHA1( &m_pSHA1 ) )
				m_bExisting = pExisting->IsAvailable() ? 1 : 2;
			bLocked = TRUE;
		}
	}
	
	if ( ! m_bTiger && pHit->m_bTiger )
	{
		m_pTiger = pHit->m_pTiger;
		m_bTiger = TRUE;
		
		if ( ! m_bExisting && ( bLocked || pLock1.Lock( 100 ) ) )
		{
			if ( CLibraryFile* pExisting = LibraryMaps.LookupFileByTiger( &m_pTiger ) )
				m_bExisting = pExisting->IsAvailable() ? 1 : 2;
			bLocked = TRUE;
		}
	}
	
	if ( ! m_bED2K && pHit->m_bED2K )
	{
		m_pED2K = pHit->m_pED2K;
		m_bED2K = TRUE;
		
		if ( ! m_bExisting && ( bLocked || pLock1.Lock( 100 ) ) )
		{
			if ( CLibraryFile* pExisting = LibraryMaps.LookupFileByED2K( &m_pED2K ) )
				m_bExisting = pExisting->IsAvailable() ? 1 : 2;
			bLocked = TRUE;
		}
	}
	
	if ( bLocked ) pLock1.Unlock();
	
	if ( ! m_bDownload && ! m_bExisting && ( m_bSHA1 || m_bTiger ) )
	{
		CSingleLock pLock2( &Transfers.m_pSection );
		
		if ( pLock2.Lock( 50 ) )
		{
			if ( m_bSHA1 && Downloads.FindBySHA1( &m_pSHA1 ) != NULL )
			{
				m_bDownload = TRUE;
			}
			else if ( m_bTiger && Downloads.FindByTiger( &m_pTiger ) != NULL )
			{
				m_bDownload = TRUE;
			}
		}
	}
	
	if ( pHit->m_bFiltered ) Added( pHit );
	
	if ( ! m_bOneValid && ! pHit->m_bBogus && pHit->m_bMatched ) m_bOneValid = TRUE;
	
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile check

BOOL CMatchFile::Check(CQueryHit* pHit) const
{
	for ( CQueryHit* pOld = m_pHits ; pOld ; pOld = pOld->m_pNext )
	{
		if ( pOld == pHit ) return TRUE;
	}
	
	return FALSE;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile expand/collapse

BOOL CMatchFile::Expand(BOOL bExpand)
{
	if ( m_bExpanded == bExpand ) return FALSE;

	m_pList->m_nItems -= GetItemCount();
	m_bExpanded = bExpand;
	m_pList->m_nItems += GetItemCount();

	if ( ! m_bExpanded )
	{
		for ( CQueryHit* pHit = m_pHits ; pHit ; pHit = pHit->m_pNext )
		{
			if ( pHit->m_bSelected ) m_pList->Select( this, pHit, FALSE );
		}
	}

	m_pList->UpdateRange( m_pList->FileToItem( this ) );

	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile filter

DWORD CMatchFile::Filter()
{
	m_bBusy			= TS_UNKNOWN;
	m_bPush			= TS_UNKNOWN;
	m_bStable		= TS_UNKNOWN;
	m_bPreview		= FALSE;
	m_nSpeed		= 0;
	m_nRating		= 0;
	m_nRated		= 0;
	m_bDRM			= FALSE;
	m_bCollection	= FALSE;
	
	m_nFiltered		= 0;
	m_nSources		= 0;
	m_pBest			= NULL;
	
	for ( CQueryHit* pHit = m_pHits ; pHit ; pHit = pHit->m_pNext )
	{
		if ( m_pList->FilterHit( pHit ) )
		{
			Added( pHit );
		}
		else if ( pHit->m_bSelected )
		{
			m_pList->Select( this, pHit, FALSE );
		}
	}
	
	if ( m_pList->m_bFilterLocal && m_bExisting ) return 0;
	// if ( m_nFiltered < m_pList->m_nFilterSources ) return 0;
	if ( m_nSources < m_pList->m_nFilterSources ) return 0;
	
	if ( m_nFiltered == 1 || ! m_bExpanded )
		return 1;
	else
		return m_nFiltered + 1;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile averaging

void CMatchFile::Added(CQueryHit* pHit)
{
	m_pBest = pHit;
	
	m_nFiltered ++;
	m_nSources += pHit->GetSources();
	m_nSpeed += pHit->m_nSpeed;
	
	if ( m_nFiltered && m_nSpeed )
		m_sSpeed = Settings.SmartVolume( m_nFiltered ? m_nSpeed / m_nFiltered : 0, TRUE, TRUE );
	else
		m_sSpeed.Empty();
	
	if ( pHit->m_bPush == TS_FALSE )
		m_bPush = TS_FALSE;
	else if ( pHit->m_bPush == TS_TRUE && m_bPush == TS_UNKNOWN )
		m_bPush = TS_TRUE;
	
	if ( pHit->m_bBusy == TS_FALSE )
		m_bBusy = TS_FALSE;
	else if ( pHit->m_bBusy == TS_TRUE && m_bBusy == TS_UNKNOWN )
		m_bBusy = TS_TRUE;
	
	if ( pHit->m_bStable == TS_TRUE )
		m_bStable = TS_TRUE;
	else if ( pHit->m_bStable == TS_FALSE && m_bStable == TS_UNKNOWN )
		m_bStable = TS_FALSE;
	
	m_bPreview |= pHit->m_bPreview;
	m_bCollection |= ( pHit->m_bCollection && ! pHit->m_bBogus );
	
	if ( pHit->m_nRating )
	{
		m_nRating += pHit->m_nRating;
		m_nRated ++;
	}
	
	if ( m_nShellIndex == -1 )
	{
		LPCTSTR pszExt = _tcsrchr( pHit->m_sName, '.' );
		m_nShellIndex = pszExt ? ShellIcons.Get( pszExt, 16 ) : 0;
	}
	
	BOOL bSchema;
	
	if ( m_pList->m_pSchema &&
		 ( bSchema = m_pList->m_pSchema->CheckURI( pHit->m_sSchemaURI ) || pHit->m_bSHA1 ) )
	{
		if ( m_pColumns == NULL )
		{
			m_nColumns = m_pList->m_nColumns;
			m_pColumns = new CString[ m_nColumns ];
		}
		
		CSchemaMember** pMember = m_pList->m_pColumns;
		CString strValue;
		
		for ( int nCount = 0 ; nCount < m_nColumns ; nCount ++, pMember ++ )
		{
			if ( _tcsicmp( (*pMember)->m_sName, _T("SHA1") ) == 0 )
			{
				if ( pHit->m_bSHA1 )
				{
					m_pColumns[ nCount ] = CSHA::HashToString( &m_pSHA1 );
				}
			}
			else if ( bSchema )
			{
				strValue = (*pMember)->GetValueFrom( pHit->m_pXML, NULL, TRUE );
				if ( strValue.GetLength() ) m_pColumns[ nCount ] = strValue;
			}
		}
	}
	else if ( m_pColumns != NULL )
	{
		delete [] m_pColumns;
		m_pColumns = NULL;
		m_nColumns = 0;
	}
	
	if ( ! m_bDRM && pHit->m_pXML != NULL )
	{
		if ( pHit->m_pXML->GetAttributeValue( _T("DRM") ).GetLength() > 0 )
			m_bDRM = TRUE;
	}
	
	if ( m_bDownload ) pHit->m_bDownload = TRUE;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile clear new

void CMatchFile::ClearNew()
{
	m_bNew = FALSE;
	for ( CQueryHit* pHit = m_pHits ; pHit ; pHit = pHit->m_pNext )
		pHit->m_bNew = FALSE;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile compare (for sort)

int CMatchFile::Compare(CMatchFile* pFile) const
{
	register int x, y;
	
	/*
	if ( m_bCollection != pFile->m_bCollection )
	{
		return m_bCollection ? -m_pList->m_bSortDir : m_pList->m_bSortDir;
	}
	*/
	
	switch ( m_pList->m_nSortColumn )
	{
	case MATCH_COL_NAME:
		x = _tcsicoll( m_pHits->m_sName, pFile->m_pHits->m_sName );
		if ( ! x ) return 0;
		return x > 0 ? 1 : -1;

	case MATCH_COL_TYPE:
		{
			LPCTSTR pszType1 = _tcsrchr( m_pHits->m_sName, '.' );
			LPCTSTR pszType2 = _tcsrchr( pFile->m_pHits->m_sName, '.' );
			if ( ! pszType1 ) return ( pszType2 ? -1 : 0 );
			if ( ! pszType2 ) return 1;
			x = _tcsicmp( pszType1, pszType2 );
			if ( ! x ) return 0;
			return x > 0 ? 1 : -1;
		}
		
	case MATCH_COL_SIZE:
		return m_nSize == pFile->m_nSize ? 0 : ( m_nSize > pFile->m_nSize ? 1 : -1 );
	
	case MATCH_COL_RATING:
		x = m_nRated ? m_nRating / m_nRated : 0;
		y = pFile->m_nRated ? pFile->m_nRating / pFile->m_nRated : 0;
		return x == y ? 0 : ( x > y ? 1 : -1 );
		
	case MATCH_COL_STATUS:
		x = y = 0;
		if ( m_bPush != TS_TRUE ) x += 4;
		if ( m_bBusy != TS_TRUE ) x += 2;
		if ( m_bStable == TS_TRUE ) x ++;
		if ( pFile->m_bPush != TS_TRUE ) y += 4;
		if ( pFile->m_bBusy != TS_TRUE ) y += 2;
		if ( pFile->m_bStable == TS_TRUE ) y ++;
		return x == y ? 0 : ( x > y ? 1 : -1 );
		
	case MATCH_COL_COUNT:
		return m_nSources == pFile->m_nSources ? 0 : ( m_nSources > pFile->m_nSources ? 1 : -1 );
		
	case MATCH_COL_CLIENT:
		{
			LPCTSTR pszType1 = ( m_nFiltered == 1 ) ? (LPCTSTR)m_pHits->m_pVendor->m_sName : NULL;
			LPCTSTR pszType2 = ( pFile->m_nFiltered == 1 ) ? (LPCTSTR)pFile->m_pHits->m_pVendor->m_sName : NULL;
			if ( ! pszType1 ) return ( pszType2 ? -1 : 0 );
			if ( ! pszType2 ) return 1;
			x = _tcsicmp( pszType1, pszType2 );
			if ( ! x ) return 0;
			return x > 0 ? 1 : -1;
		}
		
	case MATCH_COL_SPEED:
		x = m_nFiltered ? m_nSpeed / m_nFiltered : 0;
		y = pFile->m_nFiltered ? pFile->m_nSpeed / pFile->m_nFiltered : 0;
		return x == y ? 0 : ( x > y ? 1 : -1 );
		
	default:
		if ( ! m_pColumns ) return ( pFile->m_pColumns ? -1 : 0 );
		else if ( ! pFile->m_pColumns ) return 1;
		
		x = ( m_pList->m_nSortColumn - MATCH_COL_MAX >= m_nColumns );
		y = ( m_pList->m_nSortColumn - MATCH_COL_MAX >= pFile->m_nColumns );
		if ( x ) return ( y ? 0 : -1 );
		else if ( y ) return 1;
		
		{
			LPCTSTR pszA = m_pColumns[ m_pList->m_nSortColumn - MATCH_COL_MAX ];
			LPCTSTR pszB = pFile->m_pColumns[ m_pList->m_nSortColumn - MATCH_COL_MAX ];
			
#if 0
			if ( *pszA && *pszB &&
				( pszA[ _tcslen( pszA ) - 1 ] == 'k' || pszA[ _tcslen( pszA ) - 1 ] == '~' )
				&&
				( pszB[ _tcslen( pszB ) - 1 ] == 'k' || pszB[ _tcslen( pszB ) - 1 ] == '~' ) )
			{
				x = CLiveList::SortProc( pszA, pszB, TRUE );
			}
			else
			{
				x = _tcsicoll(	m_pColumns[ m_pList->m_nSortColumn - MATCH_COL_MAX ],
								pFile->m_pColumns[ m_pList->m_nSortColumn - MATCH_COL_MAX ] );
			}
#else
			x = CLiveList::SortProc( pszA, pszB );
#endif
		}
		if ( ! x ) return 0;
		return x > 0 ? 1 : -1;
	}
}

//////////////////////////////////////////////////////////////////////
// CMatchFile URN

CString CMatchFile::GetURN() const
{
	CString strURN;
	
	if ( m_bSHA1 && m_bTiger )
	{
		strURN	= _T("urn:bitprint:")
				+ CSHA::HashToString( &m_pSHA1 ) + '.'
				+ CTigerNode::HashToString( &m_pTiger );
	}
	else if ( m_bSHA1 )
	{
		strURN = CSHA::HashToString( &m_pSHA1, TRUE );
	}
	else if ( m_bTiger )
	{
		strURN = CTigerNode::HashToString( &m_pTiger, TRUE );
	}
	else if ( m_bED2K )
	{
		strURN = CED2K::HashToString( &m_pED2K, TRUE );
	}
	
	return strURN;
}

//////////////////////////////////////////////////////////////////////
// CMatchFile serialize

void CMatchFile::Serialize(CArchive& ar, int nVersion)
{
	if ( ar.IsStoring() )
	{
		ar << m_nSize;
		ar << m_sSize;
		ar << m_bSHA1;
		if ( m_bSHA1 ) ar.Write( &m_pSHA1, sizeof(SHA1) );
		ar << m_bTiger;
		if ( m_bTiger ) ar.Write( &m_pTiger, sizeof(TIGEROOT) );
		ar << m_bED2K;
		if ( m_bED2K ) ar.Write( &m_pED2K, sizeof(MD4) );

		ar << m_bBusy;
		ar << m_bPush;
		ar << m_bStable;
		ar << m_nSpeed;
		ar << m_sSpeed;
		ar << m_bExpanded;
		ar << m_bExisting;
		ar << m_bDownload;
		ar << m_bOneValid;
		
		if ( m_pPreview == NULL ) m_nPreview = 0;
		ar.WriteCount( m_nPreview );
		if ( m_nPreview > 0 ) ar.Write( m_pPreview, m_nPreview );
		
		ar.WriteCount( m_nTotal );
		CPtrArray pHits;
		
		for ( CQueryHit* pHit = m_pHits ; pHit ; pHit = pHit->m_pNext )
		{
			pHits.Add( pHit );
		}
		
		for ( int nHit = m_nTotal - 1 ; nHit >= 0 ; nHit-- )
		{
			pHit = (CQueryHit*)pHits.GetAt( nHit );
			pHit->Serialize( ar, nVersion );
		}
	}
	else
	{
		if ( nVersion >= 10 )
		{
			ar >> m_nSize;
		}
		else
		{
			DWORD nSize;
			ar >> nSize;
			m_nSize = nSize;
		}
		
		ar >> m_sSize;
		ar >> m_bSHA1;
		if ( m_bSHA1 ) ar.Read( &m_pSHA1, sizeof(SHA1) );
		ar >> m_bTiger;
		if ( m_bTiger ) ar.Read( &m_pTiger, sizeof(TIGEROOT) );
		ar >> m_bED2K;
		if ( m_bED2K ) ar.Read( &m_pED2K, sizeof(MD4) );
		
		ar >> m_bBusy;
		ar >> m_bPush;
		ar >> m_bStable;
		ar >> m_nSpeed;
		ar >> m_sSpeed;
		ar >> m_bExpanded;
		ar >> m_bExisting;
		ar >> m_bDownload;
		ar >> m_bOneValid;
		
		if ( m_nPreview = ar.ReadCount() )
		{
			m_pPreview = new BYTE[ m_nPreview ];
			ar.Read( m_pPreview, m_nPreview );
		}
		
		m_nTotal = ar.ReadCount();
		
		for ( int nCount = m_nTotal ; nCount > 0 ; nCount-- )
		{
			CQueryHit* pNext = new CQueryHit( PROTOCOL_NULL );
			pNext->m_pNext = m_pHits;
			m_pHits = pNext;
			m_pHits->Serialize( ar, nVersion );
		}
	}
}