librarymaps.cpp

著名的下载软件核心Shareaza

//
// LibraryMaps.cpp
//
// Copyright (c) Shareaza Development Team, 2002-2004.
// This file is part of SHAREAZA (www.shareaza.com)
//
// Shareaza is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Shareaza is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Shareaza; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#include "StdAfx.h"
#include "Shareaza.h"
#include "Library.h"
#include "LibraryMaps.h"
#include "SharedFile.h"

#include "Application.h"
#include "QuerySearch.h"

#include "SHA.h"
#include "MD5.h"
#include "ED2K.h"
#include "TigerTree.h"

IMPLEMENT_DYNAMIC(CLibraryMaps, CComObject)

BEGIN_INTERFACE_MAP(CLibraryMaps, CComObject)
	INTERFACE_PART(CLibraryMaps, IID_ILibraryFiles, LibraryFiles)
END_INTERFACE_MAP()

#define HASH_SIZE	512
#define HASH_MASK	0x1FF

CLibraryMaps LibraryMaps;


//////////////////////////////////////////////////////////////////////
// CLibraryMaps construction

CLibraryMaps::CLibraryMaps()
{
	EnableDispatch( IID_ILibraryFiles );
	
	m_pSHA1Map		= new CLibraryFile*[HASH_SIZE];
	m_pTigerMap		= new CLibraryFile*[HASH_SIZE];
	m_pED2KMap		= new CLibraryFile*[HASH_SIZE];
	
	ZeroMemory( m_pSHA1Map, HASH_SIZE * 4 );
	ZeroMemory( m_pTigerMap, HASH_SIZE * 4 );
	ZeroMemory( m_pED2KMap, HASH_SIZE * 4 );
	
	m_nNextIndex	= 4;
	m_nFiles		= 0;
	m_nVolume		= 0;
}

CLibraryMaps::~CLibraryMaps()
{
	delete [] m_pED2KMap;
	delete [] m_pTigerMap;
	delete [] m_pSHA1Map;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps file list

POSITION CLibraryMaps::GetFileIterator() const
{
	return m_pIndexMap.GetStartPosition();
}

CLibraryFile* CLibraryMaps::GetNextFile(POSITION& pos) const
{
	LPVOID pIndex;
	CLibraryFile* pFile = NULL;
	m_pIndexMap.GetNextAssoc( pos, pIndex, (void*&)pFile );
	return pFile;
}

int CLibraryMaps::GetFileCount() const
{
	return m_pIndexMap.GetCount();
}

void CLibraryMaps::GetStatistics(DWORD* pnFiles, QWORD* pnVolume)
{
	if ( pnFiles ) *pnFiles = m_nFiles;
	if ( pnVolume ) *pnVolume = m_nVolume;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps lookup file by index

CLibraryFile* CLibraryMaps::LookupFile(DWORD nIndex, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	if ( ! nIndex ) return NULL;
	
	CLibraryFile* pFile = NULL;
	
	Library.Lock();
	
	if ( m_pIndexMap.Lookup( (LPVOID)nIndex, (void*&)pFile ) && ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
	{
		if ( ! bLockOnSuccess ) Library.Unlock();
		return pFile;
	}
	
	Library.Unlock();
	
	return NULL;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps lookup file by name and/or path

CLibraryFile* CLibraryMaps::LookupFileByName(LPCTSTR pszName, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	CLibraryFile* pFile = NULL;
	CString strName( pszName );
	
	Library.Lock();
	strName.MakeLower();
	
	if ( m_pNameMap.Lookup( strName, (CObject*&)pFile ) && ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
	{
		if ( ! bLockOnSuccess ) Library.Unlock();
		return pFile;
	}
	
	Library.Unlock();
	
	return NULL;
}

CLibraryFile* CLibraryMaps::LookupFileByPath(LPCTSTR pszPath, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	CLibraryFile* pFile = NULL;
	
	Library.Lock();
	
	if ( m_pPathMap.Lookup( pszPath, (CObject*&)pFile ) && ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
	{
		if ( ! bLockOnSuccess ) Library.Unlock();
		return pFile;
	}
	
	Library.Unlock();
	
	return NULL;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps lookup file by URN

CLibraryFile* CLibraryMaps::LookupFileByURN(LPCTSTR pszURN, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	CLibraryFile* pFile;
	TIGEROOT pTiger;
	SHA1 pSHA1;
	MD4 pED2K;
	
	if ( CSHA::HashFromURN( pszURN, &pSHA1 ) )
	{
		if ( pFile = LookupFileBySHA1( &pSHA1, bLockOnSuccess, bSharedOnly ) ) return pFile;
	}
	
	if ( CTigerNode::HashFromURN( pszURN, &pTiger ) )
	{
		if ( pFile = LookupFileByTiger( &pTiger, bLockOnSuccess, bSharedOnly ) ) return pFile;
	}
	
	if ( CED2K::HashFromURN( pszURN, &pED2K ) )
	{
		if ( pFile = LookupFileByED2K( &pED2K, bLockOnSuccess, bSharedOnly ) ) return pFile;
	}
	
	return NULL;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps lookup file by individual hash types

CLibraryFile* CLibraryMaps::LookupFileBySHA1(const SHA1* pSHA1, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	Library.Lock();
	
	CLibraryFile* pFile = m_pSHA1Map[ *(WORD*)pSHA1 & HASH_MASK ];
	
	for ( ; pFile ; pFile = pFile->m_pNextSHA1 )
	{
		if ( *pSHA1 == pFile->m_pSHA1 )
		{
			if ( ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
			{
				if ( ! bLockOnSuccess ) Library.Unlock();
				return pFile;
			}
			else
			{
				Library.Unlock();
				return NULL;
			}
		}
	}
	
	Library.Unlock();
	
	return NULL;
}

CLibraryFile* CLibraryMaps::LookupFileByTiger(const TIGEROOT* pTiger, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	Library.Lock();
	
	CLibraryFile* pFile = m_pTigerMap[ *(WORD*)pTiger & HASH_MASK ];
	
	for ( ; pFile ; pFile = pFile->m_pNextTiger )
	{
		if ( *pTiger == pFile->m_pTiger )
		{
			if ( ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
			{
				if ( ! bLockOnSuccess ) Library.Unlock();
				return pFile;
			}
			else
			{
				Library.Unlock();
				return NULL;
			}
		}
	}
	
	Library.Unlock();
	
	return NULL;
}

CLibraryFile* CLibraryMaps::LookupFileByED2K(const MD4* pED2K, BOOL bLockOnSuccess, BOOL bSharedOnly, BOOL bAvailableOnly)
{
	Library.Lock();
	
	CLibraryFile* pFile = m_pED2KMap[ *(WORD*)pED2K & HASH_MASK ];
	
	for ( ; pFile ; pFile = pFile->m_pNextED2K )
	{
		if ( *pED2K == pFile->m_pED2K )
		{
			if ( ( ! bSharedOnly || pFile->IsShared() ) && ( ! bAvailableOnly || pFile->IsAvailable() ) )
			{
				if ( ! bLockOnSuccess ) Library.Unlock();
				return pFile;
			}
			else
			{
				Library.Unlock();
				return NULL;
			}
		}
	}
	
	Library.Unlock();
	
	return NULL;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps clear

void CLibraryMaps::Clear()
{
	for ( POSITION pos = GetFileIterator() ; pos ; ) delete GetNextFile( pos );
	
	ASSERT( m_pIndexMap.GetCount() == 0 );
	ASSERT( m_pNameMap.GetCount() == 0 );
	ASSERT( m_pPathMap.GetCount() == 0 );
	
	ZeroMemory( m_pSHA1Map, HASH_SIZE * 4 );
	ZeroMemory( m_pTigerMap, HASH_SIZE * 4 );
	ZeroMemory( m_pED2KMap, HASH_SIZE * 4 );
	
	m_nFiles  = 0;
	m_nVolume = 0;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps index manager

DWORD CLibraryMaps::AllocateIndex()
{
	while ( ( m_nNextIndex & 3 ) == 0 || LookupFile( m_nNextIndex ) ) m_nNextIndex++;
	return m_nNextIndex;
}

//////////////////////////////////////////////////////////////////////
// CLibraryMaps add a file to the maps

void CLibraryMaps::OnFileAdd(CLibraryFile* pFile)
{
	if ( pFile->m_nIndex )
	{
		if ( CLibraryFile* pOld = LookupFile( pFile->m_nIndex ) )
		{
			if ( pOld != pFile )
			{
				pFile->m_nIndex = AllocateIndex();
				m_pIndexMap.SetAt( (LPVOID)pFile->m_nIndex, pFile );
				m_nVolume += ( pFile->m_nSize >> 10 );
				m_nFiles ++;
			}
		}
		else
		{
			m_pIndexMap.SetAt( (LPVOID)pFile->m_nIndex, pFile );
			m_nVolume += ( pFile->m_nSize >> 10 );
			m_nFiles ++;
		}
	}
	else
	{
		pFile->m_nIndex = AllocateIndex();
		m_pIndexMap.SetAt( (LPVOID)pFile->m_nIndex, pFile );
		m_nVolume += ( pFile->m_nSize >> 10 );
		m_nFiles ++;
	}
	
	m_pNameMap.SetAt( pFile->GetNameLC(), pFile );