csgo/cstrike15_src/filesystem/filesystemasync.cpp

//========== Copyright � 2009, Valve Corporation, All rights reserved. ========
//
// file:	filesystem_newasync.cpp
//
// Purpose: Upgraded Async I/O system for source 2.0
//
//
// System Support (so far): Win32, 360  (see #POSIX usage in filesystem_async.cpp)
//
//=============================================================================



#include "basefilesystem.h"
#include "filesystem.h"
#include "filesystemasync.h"
#include "threadtools.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"



#ifdef _DEBUG
	#define  VALIDATE_REQUEST_MODIFICATION    	if ( !ValidateRequestModification() ) { return; }
#else
	#define  VALIDATE_REQUEST_MODIFICATION      (void) 0;
#endif

//-----------------------------------------------------------------------------
// Globals object instance?  put in tier2.cpp?
//-----------------------------------------------------------------------------
extern CAsyncFileSystem g_FileSystem_Async;



//-----------------------------------------------------------------------------
// CAsyncRequestBase::Default Constructor
//		-- inits all members common to all Async Requests
//-----------------------------------------------------------------------------
CAsyncRequestBase::CAsyncRequestBase()
{
	m_pOuter = NULL;
	
	m_pCallback	= NULL;
	m_pResultQueue = NULL;
	
	m_Operation	= ASYNC_OP_UNDEFINED;
	m_priority = 0;

	m_pNext	= NULL;
	m_pPrev	= NULL;
	
	m_RequestState = ASYNC_REQUEST_STATE_COMPOSING;
	m_RequestStatus	= ASYNC_REQUEST_OK;
	
	m_bAbortRequest	= false;
	m_bProcessingCallback = false;
	m_bDontAutoRelease = false;
	
	m_pSyncThreadEvent = NULL;
	
	m_pOldAsyncControl = NULL;
	m_pOldAsyncStatus = FSASYNC_OK;
	
	m_pGroup = NULL;
	
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::Destructor
//		
//-----------------------------------------------------------------------------
CAsyncRequestBase::~CAsyncRequestBase()
{
	RefreshCallback( NULL );		// Release functor
	
	// We do this in the base class as it will be the last destructor called

	g_FileSystem_Async.RemoveRequest( this );		// Tell the Async System to remove us from its lists
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::Destructor
//		
//-----------------------------------------------------------------------------
IAsyncRequestBase* CAsyncRequestBase::GetInterfaceBase()
{
	if ( m_pOuter != NULL )
	{
		switch ( m_Operation )
		{
			case ASYNC_OP_READFILE:
			case ASYNC_OP_WRITEFILE:
			case ASYNC_OP_APPENDFILE:
			{
				CAsyncFileRequest* pOuter = ( CAsyncFileRequest* ) m_pOuter;
				return static_cast< IAsyncRequestBase* >( pOuter );
			}

			case ASYNC_OP_SCANDIR:
			{
				CAsyncSearchRequest* pOuter = ( CAsyncSearchRequest* ) m_pOuter;
				return static_cast< IAsyncRequestBase* >( pOuter );
			}

			default:
			{
				Error( "Bad Outer in CAsyncRequestBase::DeleteOuter" );
				break;
			}
		}
	}
	
	return NULL;
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::AssignCallback
//		Add a completion callback to this request
//-----------------------------------------------------------------------------
void CAsyncRequestBase::AssignCallback( CFunctor* pCallback )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshCallback( pCallback );
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::AssignResultQueue
//		Send the results to this queue object
//-----------------------------------------------------------------------------
void CAsyncRequestBase::AssignResultQueue( CIOCompletionQueue* pMsgQueue )
{
	VALIDATE_REQUEST_MODIFICATION;
	m_pResultQueue = pMsgQueue;
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::AssignCallbackAndQueue
//		
//-----------------------------------------------------------------------------
void CAsyncRequestBase::AssignCallbackAndQueue( CIOCompletionQueue* pMsgQueue, CFunctor* pCallback )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshCallback( pCallback );
	m_pResultQueue = pMsgQueue;
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::RefreshFileName
//		Change the filename, release memory held by previous
//-----------------------------------------------------------------------------
void CAsyncRequestBase::ProcessCallback( bool bRelease )
{
	if ( m_RequestState != ASYNC_REQUEST_STATE_AWATING_FINISH )
	{
		Error( "Callback called at wrong time" );
		return;
	}

	// Callback is a one shot thing	
	if ( m_pCallback != NULL )
	{
		m_bProcessingCallback = true;
		(*m_pCallback)();
		m_pCallback->Release();
		m_pCallback = NULL;
		m_bProcessingCallback = false;
	}
	
	// Callback is completed (or NULL), move to next state
	m_RequestState = ASYNC_REQUEST_STATE_COMPLETED;	

	// Do we release automatically this object?
	if ( bRelease && !m_bDontAutoRelease )
	{
		// Upon return, this object will no longer be in the Async System...
		Release();
	}
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::Release
//	   Let's the user manually release/destroy an async request object	
//     Can only be done once the request is complete, if the async system
//     needs to at other times, call DeleteOuter() instead
//-----------------------------------------------------------------------------
void CAsyncRequestBase::Release()
{
	if ( m_RequestState != ASYNC_REQUEST_STATE_COMPLETED )
	{
		Error( "Async Request has not finished, unable to release" );
		return;
	}

	// The magic is in the destructor...
	// the destructor will detach this request from the async filesystem 
	// and clean everything up
	
	DeleteOuter();
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::DeleteOuter
//	   calls the destructor on the containing object	
//     must update this when adding a new async request type
//-----------------------------------------------------------------------------
void CAsyncRequestBase::DeleteOuter()
{
	if ( m_pOuter != NULL )
	{
		switch ( m_Operation )
		{
			case ASYNC_OP_READFILE:
			case ASYNC_OP_WRITEFILE:
			case ASYNC_OP_APPENDFILE:
			{
				CAsyncFileRequest* pOuter = ( CAsyncFileRequest* ) m_pOuter;
				delete pOuter;
				return;
			}

			case ASYNC_OP_SCANDIR:
			{
				CAsyncSearchRequest* pOuter = ( CAsyncSearchRequest* ) m_pOuter;
				delete pOuter;
				return;
			}

			default:
			{
				Error( "Bad Outer in CAsyncRequestBase::DeleteOuter" );
				break;
			}
		}
	}
}




//-----------------------------------------------------------------------------
// CAsyncRequestBase::SetPriority
//		
//-----------------------------------------------------------------------------
void CAsyncRequestBase::SetPriority( int32 nPriority )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	m_priority = nPriority;
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::RefreshCallback
//		Update the callback functor, release the previous one (if any)
//-----------------------------------------------------------------------------
void CAsyncRequestBase::RefreshCallback( CFunctor* pCallback )
{
	// release existing callback
	if ( m_pCallback != NULL )
	{
		m_pCallback->Release();
	}
	m_pCallback = pCallback;
}


//-----------------------------------------------------------------------------
// CAsyncRequestBase::AbortAfterServicing
//	  calls the correct containing object's method and does any cleanup needed
//    by the base object
//-----------------------------------------------------------------------------
 void CAsyncRequestBase::AbortAfterServicing( CAsyncResultInfo_t& results )
 {
 
	if ( m_pOuter != NULL )
	{
		switch ( m_Operation )
		{
			case ASYNC_OP_READFILE:
			case ASYNC_OP_WRITEFILE:
			case ASYNC_OP_APPENDFILE:
			{
				CAsyncFileRequest* pOuter = ( CAsyncFileRequest* ) m_pOuter;
				pOuter->AbortAfterServicing( results );
				break;
			}

			case ASYNC_OP_SCANDIR:
			{
				CAsyncSearchRequest* pOuter = ( CAsyncSearchRequest* ) m_pOuter;
				pOuter->AbortAfterServicing( results );
				break;
			}

			default:
			{
				Error( "Bad Outer in CAsyncRequestBase::AbortAfterServicing" );
				break;
			}
		}
	}
	
 }
 
 
//-----------------------------------------------------------------------------
// CAsyncRequestBase::UpdateAfterServicing
//	  calls the correct containing object's method and does any update needed
//    by the base object
//-----------------------------------------------------------------------------
void CAsyncRequestBase::UpdateAfterServicing( CAsyncResultInfo_t& results )
 {
 
 	if ( m_pOuter != NULL )
	{
		switch ( m_Operation )
		{
			case ASYNC_OP_READFILE:
			case ASYNC_OP_WRITEFILE:
			case ASYNC_OP_APPENDFILE:
			{
				CAsyncFileRequest* pOuter = ( CAsyncFileRequest* ) m_pOuter;
				pOuter->UpdateAfterServicing( results );
				break;
			}

			case ASYNC_OP_SCANDIR:
			{
				CAsyncSearchRequest* pOuter = ( CAsyncSearchRequest* ) m_pOuter;
				pOuter->UpdateAfterServicing( results );
				break;
			}

			default:
			{
				Error( "Bad Outer in CAsyncRequestBase::UpdateAfterServicing" );
				break;
			}
		}
	}

 }
 
 
//-----------------------------------------------------------------------------
// CAsyncRequestBase::ValidateSubmittedRequest
//	  calls the correct containing object's method and does any validation needed
//    by the base object
//-----------------------------------------------------------------------------
 AsyncRequestStatus_t CAsyncRequestBase::ValidateSubmittedRequest( bool bPerformSync )
 {

 	if ( m_pOuter != NULL )
	{
		switch ( m_Operation )
		{
			case ASYNC_OP_READFILE:
			case ASYNC_OP_WRITEFILE:
			case ASYNC_OP_APPENDFILE:
			{
				CAsyncFileRequest* pOuter = ( CAsyncFileRequest* ) m_pOuter;
				return pOuter->ValidateSubmittedRequest( bPerformSync );
			}

			case ASYNC_OP_SCANDIR:
			{
				CAsyncSearchRequest* pOuter = ( CAsyncSearchRequest* ) m_pOuter;
				return pOuter->ValidateSubmittedRequest( bPerformSync );
			}

			default:
			{
				Error( "Bad Outer in CAsyncRequestBase::ValidateSubmittedRequest" );
				break;
			}
		}
	}

 
   return ASYNC_REQUEST_OK;
 }


//-----------------------------------------------------------------------------
// CAsyncRequestBase::ValidateRequestModification
//		Makes sure it's ok to modify this request
//-----------------------------------------------------------------------------
bool CAsyncRequestBase::ValidateRequestModification()
{
	if ( m_RequestState == ASYNC_REQUEST_STATE_COMPOSING )
	{
		return true;
	}
	
	Error( "Modifying Async Filesystem Request after it has been submitted" );
	return false;
}




//-----------------------------------------------------------------------------
// CAsyncGroupRequest::Default Constructor
//		-- inits all members
//-----------------------------------------------------------------------------
CAsyncGroupRequest::CAsyncGroupRequest() 	
{
	m_Base.SetOuter( this );
	m_nNumRequestsOutstanding = 0;
}


//-----------------------------------------------------------------------------
// CAsyncGroupRequest::Destructor
//		-- cleans up a group request..  we should assume that 
//-----------------------------------------------------------------------------
CAsyncGroupRequest::~CAsyncGroupRequest() 	
{
	// We shouldn't be destroying ourself unless the entire group has released
	
	Assert ( m_RequestList.Count() == 0 );
	Assert ( m_nNumRequestsOutstanding == 0 );
		
}


//-----------------------------------------------------------------------------
// CAsyncGroupRequest::AddAsyncRequest   Adds a request to a group.
//	
//-----------------------------------------------------------------------------
void CAsyncGroupRequest::AddAsyncRequest( IAsyncRequestBase* pRequest )
{
	// A bunch of assertions.  we're moving away from error checking in release builds
	Assert( pRequest != NULL );	
	Assert( g_FileSystem_Async.ValidateRequestPtr( pRequest->GetBase() ) );
	Assert( m_RequestList.Find( pRequest ) == -1 );
	Assert( pRequest->GetRequestStatus()  == ASYNC_REQUEST_STATE_COMPOSING );
	Assert( pRequest->GetBase()->m_pGroup == NULL );

	// Add a valid request to the end of the list
	m_RequestList.AddToTail( pRequest );
	m_ValidList.AddToTail( true );
	
}



//-----------------------------------------------------------------------------
// CAsyncGroupRequest::GetAsyncRequest - 
//	
//-----------------------------------------------------------------------------
IAsyncRequestBase* CAsyncGroupRequest::GetAsyncRequest( int32 nRNum )
{
	if ( nRNum < 0 || nRNum >=  m_RequestList.Count() )
	{
		Assert( false );
		return NULL;	
	}
	
	return m_RequestList[ nRNum ];
}


//-----------------------------------------------------------------------------
// CAsyncGroupRequest::GetAsyncFileRequest
//	
//-----------------------------------------------------------------------------
IAsyncFileRequest* CAsyncGroupRequest::GetAsyncFileRequest( int32 nRNum )
{
	if ( nRNum < 0 || nRNum >=  m_RequestList.Count() )
	{
		Assert( false );
		return NULL;	
	}
	
	IAsyncRequestBase* pRequest = m_RequestList[ nRNum ];
	AsyncFileOperation_t opType = pRequest->GetAsyncOperationType();
	
	if ( opType == ASYNC_OP_READFILE || opType == ASYNC_OP_WRITEFILE || opType == ASYNC_OP_APPENDFILE )
	{
		return ( IAsyncFileRequest* ) pRequest;
	}
	else
	{
		return NULL;
	}

}


//-----------------------------------------------------------------------------
// CAsyncGroupRequest::GetAsyncSearchRequest
//	
//-----------------------------------------------------------------------------
IAsyncSearchRequest* CAsyncGroupRequest::GetAsyncSearchRequest( int32 nRNum )
{
	if ( nRNum < 0 || nRNum >=  m_RequestList.Count() )
	{
		Assert( false );
		return NULL;	
	}
	
	IAsyncRequestBase* pRequest = m_RequestList[ nRNum ];
	AsyncFileOperation_t opType = pRequest->GetAsyncOperationType();
	
	if ( opType == ASYNC_OP_SCANDIR )
	{
		return ( IAsyncSearchRequest* ) pRequest;
	}
	else
	{
		return NULL;
	}
}



//-----------------------------------------------------------------------------
// CAsyncGroupRequest::
//	
//-----------------------------------------------------------------------------
void CAsyncGroupRequest::ReleaseAsyncRequest( int32 nRNum )
{


}



//-----------------------------------------------------------------------------
// CAsyncGroupRequest::
//	
//-----------------------------------------------------------------------------
void CAsyncGroupRequest::NotifyOfCompletion(  IAsyncRequestBase* pRequest )
{


}



//-----------------------------------------------------------------------------
// CAsyncFileRequest::Default Constructor
//		-- inits all members
//-----------------------------------------------------------------------------
CAsyncFileRequest::CAsyncFileRequest() 	
{
	m_Base.SetOuter( this );
	m_pFileName	= NULL;
	
	m_pUserProvidedDataBuffer = NULL;
	m_nUserProvidedBufferSize = 0;
	
	m_nFileSeekOffset = 0;
	m_nMaxIOSizeInBytes = 0;
	
	m_pResultsBuffer = NULL;
	m_nResultsBufferSize = 0;
	m_nIOActualSize	= 0;
	
	m_bDeleteBufferMemory = false;

}



									
//-----------------------------------------------------------------------------
// CAsyncFileRequest::Destructor
//		
//-----------------------------------------------------------------------------
CAsyncFileRequest::~CAsyncFileRequest()
{
	// Release memory we own...
	RefreshFileName( NULL );		// Release our copy of filename
	
	// and the data buffer? 
	if ( m_bDeleteBufferMemory )
	{
		if ( m_pResultsBuffer != NULL )
		{
			g_FileSystem_Async.ReleaseBuffer( m_pResultsBuffer );
		}
	}
	
	// The CAsyncRequestBase Release/DeleteOuter will take care of the rest and the release
}

	
//-----------------------------------------------------------------------------
// methods from the IAsyncFileRequest Interface
//-----------------------------------------------------------------------------
	
		
//-----------------------------------------------------------------------------
// CAsyncFileRequest::LoadFile
//	 	
//-----------------------------------------------------------------------------
void CAsyncFileRequest::LoadFile( const char* pFileName )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshFileName( pFileName );
	m_Base.m_Operation = ASYNC_OP_READFILE;
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::SaveFile
//		
//-----------------------------------------------------------------------------
void CAsyncFileRequest::SaveFile( const char* pFileName )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshFileName( pFileName );
	m_Base.m_Operation = ASYNC_OP_WRITEFILE;
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::AppendFile
//		
//-----------------------------------------------------------------------------
void CAsyncFileRequest::AppendFile( const char* pFileName )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshFileName( pFileName );
	m_Base.m_Operation = ASYNC_OP_APPENDFILE;
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::AppendFile
//		
//-----------------------------------------------------------------------------
void CAsyncFileRequest::SetFileName( const char* pFileName )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	RefreshFileName( pFileName );
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::SetUserBuffer
//		- user supplies buffer to use
//-----------------------------------------------------------------------------
void CAsyncFileRequest::SetUserBuffer( void* pDataBuffer, size_t nBufferSize )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	m_pUserProvidedDataBuffer = pDataBuffer;
	m_nUserProvidedBufferSize = nBufferSize;
	m_bDeleteBufferMemory = false;
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::ProvideDataBuffer
//		file system provide a buffer with the results
//-----------------------------------------------------------------------------
void CAsyncFileRequest::ProvideDataBuffer()
{
	VALIDATE_REQUEST_MODIFICATION;
	
	m_pUserProvidedDataBuffer = NULL;
	m_nUserProvidedBufferSize = 0;
	m_bDeleteBufferMemory = true;
}
		

//-----------------------------------------------------------------------------
// CAsyncFileRequest::ReadFileDataAt
//		Read file data starting at supplied offset, optional max size to read
//-----------------------------------------------------------------------------
void CAsyncFileRequest::ReadFileDataAt( int64 nOffset, size_t nReadSize )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	m_nFileSeekOffset	= nOffset;
	m_nMaxIOSizeInBytes = nReadSize;
}
//-----------------------------------------------------------------------------
// CAsyncFileRequest::WriteFileDataAt
//		Write data to file at supplied offset, optional size to write (max size of buffer)
//-----------------------------------------------------------------------------
void CAsyncFileRequest::WriteFileDataAt( int64 nOffset, size_t nWriteSize )
{
	VALIDATE_REQUEST_MODIFICATION;
	
	m_nFileSeekOffset	  = nOffset;
	m_nMaxIOSizeInBytes   = nWriteSize;
	m_bDeleteBufferMemory = false;
}

//-----------------------------------------------------------------------------
// CAsyncFileRequest::AbortAfterServicing
//		Handle a request that got aborted while being serviced
//-----------------------------------------------------------------------------
void CAsyncFileRequest::AbortAfterServicing( CAsyncResultInfo_t& results )
{

	// was it a read and did the request allocate a buffer?
	if ( GetAsyncOperationType()== ASYNC_OP_READFILE && m_pUserProvidedDataBuffer == NULL )
	{
		// the old async code allocated a buffer that we aren't going to use/return
		if ( results.m_pAllocatedBuffer != NULL )
		{
			// this should call our allocation function
			delete[] results.m_pAllocatedBuffer;
		}
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::UpdateAfterServicing
//		Handle a request that was successfully serviced
//-----------------------------------------------------------------------------
void CAsyncFileRequest::UpdateAfterServicing( CAsyncResultInfo_t& results )
{

	// copy our return info from the old results struct
	m_pResultsBuffer = results.m_pAllocatedBuffer;
	m_nResultsBufferSize = ( m_pUserProvidedDataBuffer == NULL ) ? results.m_nBytesTransferred : m_nUserProvidedBufferSize;
	m_nIOActualSize = results.m_nBytesTransferred;

}


//-----------------------------------------------------------------------------
// CAsyncFileRequest::ValidateSubmittedRequest
//		Validate that this request can be submitted successfully
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileRequest::ValidateSubmittedRequest( bool bPerformSync )
{

	// filename must be supplied
	if ( GetFileName() == NULL )
	{
		return ASYNC_REQUEST_ERROR_BADOPER;			
	}

#ifdef _DEBUG
	// In debug mode, Check the filename for length, usage issues
	AsyncRequestStatus_t err =  ValidateFileName( GetFileName() );
	if ( err != ASYNC_REQUEST_OK ) return err;
#endif	
	// if the user supplies a buffer, it must have a size
	if ( GetUserBuffer() != NULL && GetUserBufferSize() == 0 )
	{
		return ASYNC_REQUEST_ERROR_BADUSERBUFFER;		// cant supply a zero sized buffer
	}

	// if we are writing, then a buffer must be specified
	if ( ( CAsyncFileRequest::GetAsyncOperationType() == ASYNC_OP_WRITEFILE || CAsyncFileRequest::GetAsyncOperationType() == ASYNC_OP_APPENDFILE ) && GetUserBuffer() == NULL )   
	{
		return ASYNC_REQUEST_ERROR_NOBUFFER;
	}

	return ASYNC_REQUEST_OK;
}



		
					
//-----------------------------------------------------------------------------
// CAsyncFileRequest::RefreshFileName
//		Change the filename, release memory held by previous
//-----------------------------------------------------------------------------
void CAsyncFileRequest::RefreshFileName( const char* pNewFileName )
{
	// release existing filename
	if ( m_pFileName != NULL )
	{
		delete[] m_pFileName;
	}
	// we duplicate the file name, and own its memory
	if ( pNewFileName != NULL )
	{
		m_pFileName	= strdup( pNewFileName );
	}
	else
	{
		m_pFileName = NULL;
	}
}

//-----------------------------------------------------------------------------
// CAsyncFileRequest::ValidateRequestModification
//		Makes sure it's ok to modify this request
//-----------------------------------------------------------------------------
bool CAsyncFileRequest::ValidateRequestModification()
{
	return m_Base.ValidateRequestModification();
}





//-----------------------------------------------------------------------------
// CAsyncSearchRequest::Default Constructor
//		-- inits all members
//-----------------------------------------------------------------------------
CAsyncSearchRequest::CAsyncSearchRequest()
{
	m_Base.SetOuter( this );

	V_memset( m_FileSpec, 0, sizeof( m_FileSpec ) );
	V_memset( m_PathID, 0, sizeof( m_PathID ) );
	V_memset( m_SearchPath, 0, sizeof( m_SearchPath ) );
	V_memset( m_SearchSpec, 0, sizeof( m_SearchSpec ) );
	
	m_nNumResults = 0;
	m_bRecurseSubdirs = false;
}


//-----------------------------------------------------------------------------
// CAsyncSearchRequest::Destructor
//		
//-----------------------------------------------------------------------------
CAsyncSearchRequest::~CAsyncSearchRequest()
{
	// Release any memory we own...
	
	
	// The base object destructor will take care of the rest and the release
}



	
//-----------------------------------------------------------------------------
// Methods from the IAsyncSearchRequest Interface
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// CAsyncSearchRequest::SetSearchFilespec
//    - assign the path and filename to search for
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::SetSearchFilespec( const char* pFullSearchSpec )
{
	VALIDATE_REQUEST_MODIFICATION;

	Assert( pFullSearchSpec != NULL && strlen( pFullSearchSpec ) < sizeof( m_SearchSpec ) );
	
	V_strcpy( m_SearchSpec, pFullSearchSpec );
	
	m_Base.m_Operation = ASYNC_OP_SCANDIR;
}



//-----------------------------------------------------------------------------
// CAsyncSearchRequest::SetSearchFilespec
//    - assign the path and filename to search for
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::SetSearchPathAndFileSpec( const char* pPathId, const char* pRelativeSearchSpec )
{
	VALIDATE_REQUEST_MODIFICATION;

	Assert( pPathId != NULL && strlen( pPathId ) < sizeof( m_PathID ) );
	Assert( pRelativeSearchSpec != NULL && strlen( pRelativeSearchSpec ) < sizeof( m_FileSpec ) );

	Q_strcpy( m_FileSpec, V_UnqualifiedFileName( pRelativeSearchSpec) );

	V_ExtractFilePath (pRelativeSearchSpec, m_SearchPath, sizeof(m_SearchPath) );
	V_StripTrailingSlash( m_SearchPath );
	
	char pTempPath[MAX_PATH];
	g_pFullFileSystem->RelativePathToFullPath( m_SearchPath, pPathId, pTempPath, sizeof(pTempPath) );
	
	char pFixedupPath[MAX_PATH];
	Q_FixupPathName( pFixedupPath, sizeof(pFixedupPath), pTempPath );
	
	V_ComposeFileName( pFixedupPath, m_FileSpec, m_SearchSpec, sizeof(m_SearchSpec) );
	
	m_Base.m_Operation = ASYNC_OP_SCANDIR;

}



//-----------------------------------------------------------------------------
// CAsyncSearchRequest::SetSearchFilespec
//    - assign the path and filename to search for
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::SetSearchPathAndFileSpec( const char* pPathId, const char* pRelativeSearchPath, const char* pSearchSpec )
{
	VALIDATE_REQUEST_MODIFICATION;

	Assert( pPathId != NULL && strlen( pPathId ) < sizeof( m_PathID ) );
	Assert( pRelativeSearchPath != NULL && strlen( pRelativeSearchPath ) < sizeof( m_SearchPath ) );
	Assert( pSearchSpec != NULL && strlen( pSearchSpec ) < sizeof( m_FileSpec ) );


	Q_strcpy( m_FileSpec, pSearchSpec );
	Q_strcpy( m_SearchPath, pRelativeSearchPath );
	V_StripTrailingSlash( m_SearchPath );
	
	char pTempPath[MAX_PATH];
	g_pFullFileSystem->RelativePathToFullPath( m_SearchPath, pPathId, pTempPath, sizeof(pTempPath) );
	
	char pFixedupPath[MAX_PATH];
	Q_FixupPathName( pFixedupPath, sizeof(pFixedupPath), pTempPath );
	
	V_ComposeFileName( pFixedupPath, m_FileSpec, m_SearchSpec, sizeof(m_SearchSpec) );
	
	m_Base.m_Operation = ASYNC_OP_SCANDIR;
}




//-----------------------------------------------------------------------------
// CAsyncSearchRequest::SetSubdirectoryScan
// 
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::SetSubdirectoryScan( const bool bInclude )
{
	VALIDATE_REQUEST_MODIFICATION;

	m_bRecurseSubdirs = bInclude;
}



//-----------------------------------------------------------------------------
// CAsyncSearchRequest::GetResult
//    returns a search result
//-----------------------------------------------------------------------------
CDirectoryEntryInfo_t*	CAsyncSearchRequest::GetResult( int rNum )
{
	if ( m_Base.GetRequestState() < ASYNC_REQUEST_STATE_AWATING_FINISH || m_Base.GetRequestState() > ASYNC_REQUEST_STATE_COMPLETED )
	{
		Assert( false );
		return NULL;
	}

	if ( rNum < 0 || rNum >= m_nNumResults )
	{
		Assert( false );
		return NULL;
	}
	
	return &( m_Results[ rNum ] );
}


//-----------------------------------------------------------------------------
// CAsyncSearchRequest::GetMatchedFile
//    returns a search result
//-----------------------------------------------------------------------------
const char*	CAsyncSearchRequest::GetMatchedFile( int rNum )
{
	if ( m_Base.GetRequestState() < ASYNC_REQUEST_STATE_AWATING_FINISH || m_Base.GetRequestState() > ASYNC_REQUEST_STATE_COMPLETED )
	{
		Assert( false );
		return NULL;
	}

	if ( rNum < 0 || rNum >= m_nNumResults )
	{
		Assert( false );
		return NULL;
	}
	
	return m_Results[ rNum ].m_FullFileName ;
}


//-----------------------------------------------------------------------------
// CAsyncSearchRequest::AbortAfterServicing
//		Handle a request that got aborted while being serviced
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::AbortAfterServicing( CAsyncResultInfo_t& results ) 
{
	// nothing dynamic to release
}


//-----------------------------------------------------------------------------
// CAsyncSearchRequest::UpdateAfterServicing
//		Handle a request that was successfully serviced
//-----------------------------------------------------------------------------
void CAsyncSearchRequest::UpdateAfterServicing( CAsyncResultInfo_t& results ) 
{
	// determine request specific values
	m_nNumResults = m_Results.Count();
}

//-----------------------------------------------------------------------------
// CAsyncSearchRequest::ValidateSubmittedRequest
//		Validate that this request can be submitted successfully
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncSearchRequest::ValidateSubmittedRequest( bool bPerformSync )
{
	// filespec missing?
	if ( V_strlen( m_FileSpec ) < 1 )
	{
		return ASYNC_REQUEST_ERROR_INVALIDFILENAME;
	}

	return ASYNC_REQUEST_OK;
}





//-----------------------------------------------------------------------------
// CAsyncSearchRequest::ValidateRequestModification
//		Makes sure it's ok to modify this request
//-----------------------------------------------------------------------------
bool CAsyncSearchRequest::ValidateRequestModification()
{
	return m_Base.ValidateRequestModification();
}







//-----------------------------------------------------------------------------
// CAsyncRequestQueue::constructor
//		
//-----------------------------------------------------------------------------
CAsyncRequestQueue::CAsyncRequestQueue()
{
	m_nQueueSize = 0;
	m_pHead = NULL;
	m_pTail = NULL;
}


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::destructor
//		
//-----------------------------------------------------------------------------
CAsyncRequestQueue::~CAsyncRequestQueue()
{
	AUTO_LOCK_FM( m_Mutex );		// wait for any other operations to finish
	
	// Delete any requests remaining in the queue
	if ( m_pHead != NULL )
	{
		Warning( " CAsyncRequestQueue destructor called while queue was not empty" );
		while ( m_pHead != NULL )
		{
			CAsyncRequestBase* pNext = m_pHead->m_pNext;
			delete m_pHead;
			m_pHead = pNext;	
		}
	}
}


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::IsInQueue
//			- asks if a request is in this queue
//-----------------------------------------------------------------------------
bool CAsyncRequestQueue::IsInQueue( CAsyncRequestBase* pItem )
{
	AUTO_LOCK_FM( m_Mutex );		// synchronize since we are scanning the queue?
	
	if ( pItem == NULL || m_pHead == NULL ) return false;
	
	CAsyncRequestBase* pCur = m_pHead;
	while ( pCur != NULL )
	{
		if ( pCur == pItem ) return true;
		pCur = pCur->m_pNext;
	}
	
	return false;
}


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::IsInQueueIp - Interface pointer version of IsInQueue
//			- asks if a request is in this queue
//-----------------------------------------------------------------------------
bool CAsyncRequestQueue::IsInQueueIp( const IAsyncRequestBase* pInterfaceBase )
{
	AUTO_LOCK_FM( m_Mutex );		// synchronize since we are scanning the queue?

	if ( pInterfaceBase == NULL || m_pHead == NULL ) return false;
	
	CAsyncRequestBase* pCur = m_pHead;
	while ( pCur != NULL )
	{
		if ( ( const IAsyncRequestBase* ) ( pCur->GetOuter() ) == pInterfaceBase ) return true;
		pCur = pCur->m_pNext;
	}
	
	return false;

}


		
//-----------------------------------------------------------------------------
// CAsyncRequestQueue::AddToHead
//		
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::AddToHead( CAsyncRequestBase* pItem )
{
	AUTO_LOCK_FM( m_Mutex );
		
	// Empty queue?
	if ( m_pHead == NULL )
	{
		Assert( pItem != NULL );
		Assert( m_pHead == m_pTail && m_nQueueSize == 0 );
		
		m_pHead = m_pTail = pItem;
		pItem->m_pPrev = NULL;
		pItem->m_pNext = NULL;
		m_nQueueSize = 1;
	}
	else
	{
		pItem->m_pPrev = NULL;
		pItem->m_pNext = m_pHead;
		m_pHead = pItem;
		pItem->m_pNext->m_pPrev = pItem;	// Fixup previous head item
		m_nQueueSize++;
	}
	
}	


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::AddToTail
//		
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::AddToTail( CAsyncRequestBase* pItem )
{
	AUTO_LOCK_FM( m_Mutex );
		
	// Empty queue?
	if ( m_pTail == NULL )
	{
		Assert( pItem != NULL );
		Assert( m_pHead == m_pTail && m_nQueueSize == 0 );
		
		m_pHead = m_pTail = pItem;
		pItem->m_pPrev = NULL;
		pItem->m_pNext = NULL;
		m_nQueueSize = 1;
	}
	else
	{
		pItem->m_pPrev = m_pTail;
		pItem->m_pNext = NULL;
		m_pTail = pItem;
		pItem->m_pPrev->m_pNext = pItem;	// Fixup previous tail item
		m_nQueueSize++;
	}
	
}	


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::InsertBefore
//		
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::InsertBefore( CAsyncRequestBase* pItem, CAsyncRequestBase* pInsertAt )
{
	AUTO_LOCK_FM( m_Mutex );
	
	if ( pInsertAt == NULL || m_nQueueSize == 0 || pItem == NULL || !IsInQueue( pInsertAt ) )
	{
		return;
	}
	
	// Inserting at the head of the queue?
	if ( pInsertAt == m_pHead ) 
	{
		AddToHead( pItem );
	}
	else // is somewhere in the middle of the list
	{
		CAsyncRequestBase* pPrev = pInsertAt->m_pPrev;
		pPrev->m_pNext = pItem;
		pInsertAt->m_pPrev = pItem;
		pItem->m_pPrev = pPrev;
		pItem->m_pNext = pInsertAt;
		m_nQueueSize++;
	}

};


//-----------------------------------------------------------------------------
// CAsyncRequestQueue::InsertAfter
//		
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::InsertAfter( CAsyncRequestBase* pItem, CAsyncRequestBase* pInsertAt )
{
	AUTO_LOCK_FM( m_Mutex );
	
	if ( pInsertAt == NULL || m_nQueueSize == 0 || pItem == NULL ||  !IsInQueue( pInsertAt ) )
	{
		return;
	}
	
	// Inserting at the end of the queue?
	if ( pInsertAt == m_pTail ) 
	{
		AddToTail( pItem );
	}
	else // is somewhere in the middle of the list
	{
		CAsyncRequestBase* pNext = pInsertAt->m_pNext;
		pNext->m_pPrev = pItem;
		pInsertAt->m_pNext = pItem;
		pItem->m_pPrev = pInsertAt;
		pItem->m_pNext = pNext;
		m_nQueueSize++;
	}
}
	
	
//-----------------------------------------------------------------------------
// CAsyncRequestQueue::PriorityInsert
//		- inserts an async request in the list (assumed sorted) by priority
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::PriorityInsert( CAsyncRequestBase* pItem )
{
	AUTO_LOCK_FM( m_Mutex );
	
	if ( pItem == NULL )
	{	
		return;
	}
	
	CAsyncRequestBase* pCur = m_pHead;
	bool bInserted = false;
	
	while ( pCur != NULL )
	{
		if ( pCur->GetPriority() < pItem->GetPriority() )
		{
			InsertBefore( pItem, pCur );
			bInserted = true;
			break;
		}
		pCur = pCur->m_pNext;
	}

	// Did not find a lower priority item to insert before?	
	if ( !bInserted )
	{
		AddToTail( pItem );
	}
	
}
	
											
//-----------------------------------------------------------------------------
// CAsyncRequestQueue::Remove
//		
//-----------------------------------------------------------------------------
void CAsyncRequestQueue::Remove( CAsyncRequestBase* pItem )											
{
	AUTO_LOCK_FM( m_Mutex );
		
	if ( pItem == NULL || m_nQueueSize == 0 || !IsInQueue( pItem ) )
	{
		return;
	}
	
	if ( m_nQueueSize == 1 )		// emptying queue?
	{
		m_pHead = m_pTail = NULL;
	}
	else
	{
		// removing head?
		if ( pItem->m_pPrev == NULL )
		{
			Assert( pItem == m_pHead );
			m_pHead = pItem->m_pNext;
		}
		else
		{
			pItem->m_pPrev->m_pNext = pItem->m_pNext;
		}
		// removing tail?
		if ( pItem->m_pNext == NULL )
		{
			Assert( pItem == m_pTail );
			m_pTail = pItem->m_pPrev;
		}
		else
		{
			pItem->m_pNext->m_pPrev = pItem->m_pPrev;
		}
	}
	m_nQueueSize--;
	
	pItem->m_pNext = NULL;			// clear links inside removed request
	pItem->m_pPrev = NULL;

}



//-----------------------------------------------------------------------------
// CAsyncRequestQueue::RemoveHead
//		Pops the first item off the queue and returns it
//-----------------------------------------------------------------------------
CAsyncRequestBase* CAsyncRequestQueue::RemoveHead()											
{
	AUTO_LOCK_FM( m_Mutex );
	
	if ( m_nQueueSize == 0 || m_pHead == NULL )
	{
		return NULL;
	}
	
	CAsyncRequestBase* pItem = m_pHead;	
	Remove( pItem );
	
	return pItem;
}










//-----------------------------------------------------------------------------
// CAsyncFileSystem::constructor
//	
//-----------------------------------------------------------------------------
CAsyncFileSystem::CAsyncFileSystem()
{
	m_nJobsInflight = 0;
	m_nSuspendCount	= 0;
	
	m_bIOSuspended = false;
	
}

//-----------------------------------------------------------------------------
// CAsyncFileSystem::destructor
//	
//-----------------------------------------------------------------------------
CAsyncFileSystem::~CAsyncFileSystem()
{	
	m_nSuspendCount = 1;			// don't let any jobs slip status on us
	AbortAllAsyncIO( true );		// finish any work in flight
	
	// Queue destructors will release the requests
}

											

//-----------------------------------------------------------------------------
// CAsyncFileSystem::QueryInterface
//	
//-----------------------------------------------------------------------------
void *CAsyncFileSystem::QueryInterface( const char *pInterfaceName )
{
	// Make sure we are asking for the right version	
	if ( !Q_strncmp(	pInterfaceName, ASYNCFILESYSTEM_INTERFACE_VERSION, Q_strlen( ASYNCFILESYSTEM_INTERFACE_VERSION ) + 1) )
	{
		return ( IAsyncFileSystem* ) this;
	}

	return NULL;
}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::CreateNewFileRequest
//	 Gets a new async read/write request object
//-----------------------------------------------------------------------------
IAsyncFileRequest* CAsyncFileSystem::CreateNewFileRequest()
{
	// Allocate a new request object, it's constructor will set everything up
	CAsyncFileRequest* pNewRequest = new CAsyncFileRequest;
	
	// add it to our list of requests being composed
	m_Composing.AddToTail( &pNewRequest->m_Base );
	
	// pass back the public interface pointer
	return pNewRequest;
}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::CreateNewSearchRequest
//	 Gets a new async directory search request object
//-----------------------------------------------------------------------------
IAsyncSearchRequest* CAsyncFileSystem::CreateNewSearchRequest()
{
	// Allocate a new request object, it's constructor will set everything up
	CAsyncSearchRequest* pNewRequest = new CAsyncSearchRequest;
	
	// add it to our list of requests being composed
	m_Composing.AddToTail( &pNewRequest->m_Base );
	
	// pass back the public interface pointer
	return pNewRequest;
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::CreateNewAsyncRequestGroup
//	 Gets a new async request group object
//-----------------------------------------------------------------------------
IAsyncGroupRequest*	CAsyncFileSystem::CreateNewAsyncRequestGroup()
{
	// Allocate a new request object, it's constructor will set everything up
	CAsyncGroupRequest* pNewRequest = new CAsyncGroupRequest;
	
	// add it to our list of requests being composed
	m_Composing.AddToTail( &pNewRequest->m_Base );
	
	// pass back the public interface pointer
	return pNewRequest;

}



		
//-----------------------------------------------------------------------------
// CAsyncFileSystem::ReleaseAsyncRequest
//	 Disposes of a File Request Object
//   Public interface 
//-----------------------------------------------------------------------------
void CAsyncFileSystem::ReleaseAsyncRequest( const IAsyncRequestBase* pRequest )
{
	CAsyncRequestBase* pRequestBase = ( (IAsyncRequestBase* ) pRequest )->GetBase();
	
	AUTO_LOCK_FM ( m_AsyncStateUpdateMutex );

	if ( !ValidateRequestPtr( pRequestBase ) )
	{
		Error( "Bad Release Request" );
		return;
	}

	// If we are servicing the request, just mark it to abort when done	
	if ( pRequestBase->m_RequestState == ASYNC_REQUEST_STATE_SERVICING ) 
	{
		pRequestBase->m_bAbortRequest = true;		// have it delete itself when done
		return;
	}

	// If we are processing a callback, wait until finished
	if ( pRequestBase->m_bProcessingCallback )
	{
		pRequestBase->m_bDontAutoRelease = false;
		return;
	}

	// Delete the request object
	pRequestBase->DeleteOuter();
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::SubmitAsyncIORequest
//	
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::SubmitAsyncFileRequest( const IAsyncRequestBase* pRequest )
{
	CAsyncRequestBase* pRequestBase = ( (IAsyncRequestBase* ) pRequest )->GetBase();

	// Validate the request from the user....
	AsyncRequestStatus_t RStatus = ValidateRequest( pRequestBase, false );
	
	// An error is preventing this from being submitted
	if ( RStatus != ASYNC_REQUEST_OK )
	{
		m_AsyncStateUpdateMutex.Lock();
		{
			// Move the job to the completed queue
			m_Composing.Remove( pRequestBase );
			m_Completed.AddToTail( pRequestBase );
	
			// mark request as completed, with error
			pRequestBase->m_RequestState = ASYNC_REQUEST_STATE_COMPLETED;
			pRequestBase->m_RequestStatus = RStatus;
		}		
		m_AsyncStateUpdateMutex.Unlock();

		// notify any designed message queue and/or callback
		NotifyMessageQueueOrCallback( pRequestBase );
		
		// notify the submitter as well
		return RStatus;
	}
	
	m_AsyncStateUpdateMutex.Lock();
	{
		// Move the job to the submitted queue and insert according to priority
		m_Composing.Remove( pRequestBase );
		pRequestBase->m_RequestState = ASYNC_REQUEST_STATE_SUBMITTED;
		m_Submitted.PriorityInsert( pRequestBase );
	}		
	m_AsyncStateUpdateMutex.Unlock();
	
	// See if we can hand this request off to the old async system
	KickOffFileJobs();
	
	return RStatus;
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::SubmitSyncIORequest
//	
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::SubmitSyncFileRequest( const IAsyncRequestBase* pRequest )
{
	CAsyncRequestBase* pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();

	// Validate the request from the user....
	AsyncRequestStatus_t RStatus = ValidateRequest( pRequestBase, true );
	if ( RStatus != ASYNC_REQUEST_OK )
	{
		m_AsyncStateUpdateMutex.Lock();
		{
			// Move the job to the completed queue
			m_Composing.Remove( pRequestBase );
			m_Completed.AddToTail( pRequestBase );
	
			// mark request as completed, with error
			pRequestBase->m_RequestState = ASYNC_REQUEST_STATE_COMPLETED;
			pRequestBase->m_RequestStatus = RStatus;
		}		
		m_AsyncStateUpdateMutex.Unlock();
	
		return RStatus;
	}

	CThreadEvent syncEvent;
	
	// Move the job to the submitted queue and insert according to priority

	m_AsyncStateUpdateMutex.Lock();
	{
		m_Composing.Remove( pRequestBase );
		pRequestBase->m_RequestState = ASYNC_REQUEST_STATE_SUBMITTED;

		// We are making a local thread event, so this routine can be called simultaneously / overlapping
		// by multiple threads.  I know it is "expensive" to new up a CThreadEvent, but we want to discourage
		// people from doing this anyway...
		pRequestBase->m_pSyncThreadEvent = &syncEvent;
		
		m_Submitted.PriorityInsert( pRequestBase );
	}		
	m_AsyncStateUpdateMutex.Unlock();

	// Submit to the async system
	KickOffFileJobs();

	// Wait for the job to finish, and for us to be signaled
	pRequestBase->m_pSyncThreadEvent->Wait();

	// Get the IO status to return....  (user has to delete the object anyway)	
	RStatus = pRequestBase->GetRequestStatus();
	
	return RStatus;
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::KickOffFileJobs
//	 hand off async jobs to the old async file system
//-----------------------------------------------------------------------------
void CAsyncFileSystem::KickOffFileJobs()
{
	// Are we suspended?
	if ( m_nSuspendCount > 0 )
	{	
		return;
	}

#if 0
	// Are the too many requests already being serviced?
	// TODO - throttle at 2 jobs?
	if ( m_nJobsInflight >= 1 )
	{	
		return;
	}

#endif

	m_AsyncStateUpdateMutex.Lock();

	// are there any requests waiting to be submitted?
	if ( m_Submitted.GetSize() < 1 )
	{	
		m_AsyncStateUpdateMutex.Unlock();
		return;
	}

	// ok.  translate our request to the current system

	CAsyncRequestBase* pRequestBase = m_Submitted.RemoveHead();

	FileAsyncRequest_t asJobReq;
	
	CAsyncFileRequest* pFileRequest = NULL;
	CAsyncSearchRequest* pSearchRequest = NULL;
	
	
	char* pSearchSpec = NULL;
	bool bRecurseFolders = false;
	
	if ( pRequestBase->GetAsyncOperationType() == ASYNC_OP_READFILE ||
		 pRequestBase->GetAsyncOperationType() == ASYNC_OP_WRITEFILE || 
		 pRequestBase->GetAsyncOperationType() == ASYNC_OP_APPENDFILE )
	{
		// Get the FileRequest that contains the base
		pFileRequest = reinterpret_cast< CAsyncFileRequest* >( pRequestBase->GetOuter() );
		

		// IO operation size is smaller of optionally supplied buffer size and optionally supplied IO size	
		
		int nIOMax = 0;
		if ( pFileRequest->GetUserBuffer() != NULL )	
		{
			nIOMax = pFileRequest->GetUserBufferSize();
			if ( pFileRequest->m_nMaxIOSizeInBytes > 0 && pFileRequest->m_nMaxIOSizeInBytes > nIOMax )
			{
				Error( "Buffer not big enough to hold requested File IO" );
			}
		}
		if ( pFileRequest->m_nMaxIOSizeInBytes > 0 && pFileRequest->m_nMaxIOSizeInBytes < nIOMax ) 
		{
			nIOMax = pFileRequest->m_nMaxIOSizeInBytes;
		}
		
		// translate to old request format...
		asJobReq.pszFilename = pFileRequest->GetFileName();
		asJobReq.pData = pFileRequest->GetUserBuffer();
		asJobReq.nOffset = pFileRequest->m_nFileSeekOffset;
		asJobReq.nBytes = nIOMax;
		asJobReq.pfnCallback = &CAsyncFileSystem::AsyncIOCallbackGateway;
		asJobReq.pContext = (void*) pRequestBase;
		asJobReq.priority = 0;
		asJobReq.flags = ( pFileRequest->GetUserBuffer() == NULL ) ? FSASYNC_FLAGS_ALLOCNOFREE : 0 ;
		asJobReq.pszPathID = NULL;
		asJobReq.hSpecificAsyncFile = FS_INVALID_ASYNC_FILE;
		asJobReq.pfnAlloc = &CAsyncFileSystem::OldAsyncAllocatorCallback;
	}
	
	if ( pRequestBase->GetAsyncOperationType() == ASYNC_OP_SCANDIR )
	{
		// Get the Search Request that contains the base
		pSearchRequest = reinterpret_cast< CAsyncSearchRequest* >( pRequestBase->GetOuter() );
		
		pSearchSpec = pSearchRequest->m_SearchSpec;
		bRecurseFolders = pSearchRequest->m_bRecurseSubdirs;
		
		
		
		
	
	}
	
	m_InFlight.AddToTail( pRequestBase );
	
	m_nJobsInflight++;
	pRequestBase->m_RequestState = ASYNC_REQUEST_STATE_SERVICING;
	
	// Make the call based on what sort of job is it...
	FSAsyncStatus_t	jStatus = FSASYNC_OK;

	switch ( pRequestBase->GetAsyncOperationType() )
	{
		case ASYNC_OP_READFILE:
		{
			jStatus = g_pFullFileSystem->AsyncRead( asJobReq, &(pRequestBase->m_pOldAsyncControl) );
			break;
		}
		case ASYNC_OP_WRITEFILE:
		{
			jStatus = g_pFullFileSystem->AsyncWrite( asJobReq.pszFilename, asJobReq.pData, pFileRequest->GetResultBufferSize(), false, false, &(pRequestBase->m_pOldAsyncControl) );
			break;
		}
		case ASYNC_OP_SCANDIR:
		{
			jStatus = g_pFullFileSystem->AsyncDirectoryScan( pSearchSpec, bRecurseFolders, pRequestBase, &CAsyncFileSystem::AsyncSearchCallbackAddItem, &CAsyncFileSystem::AsyncSearchCallbackGateway, &(pRequestBase->m_pOldAsyncControl) );
			break;
		}
		default:
		{
			Error( "Unable to determing async job type" );
			break;
		}
	}
	
	if ( jStatus != FSASYNC_OK )
	{
		// Error translating...
		Error( "Basefilesystem Async Job submission failed" );
		
		// TO-DO: go straight to notification/callback with failure info
	}
	
	m_AsyncStateUpdateMutex.Unlock();

}

//-----------------------------------------------------------------------------
// STATIC CAsyncFileSystem::OldAsyncAllocatorCallback
//	 - receives callbacks from the old Async file system 
//     allocates a buffer from the new async system
//-----------------------------------------------------------------------------
void* CAsyncFileSystem::OldAsyncAllocatorCallback( const char *pszFilename, unsigned nBytes )
{
	return ((CAsyncFileSystem*) g_pAsyncFileSystem)->AllocateBuffer( nBytes, 16 );
}


//-----------------------------------------------------------------------------
// STATIC CAsyncFileSystem::AsyncIOCallbackGateway
//	 - receives callbacks from the old Async file system 
//     Thunks the callback back into the context of the CAsyncFileSystem object
//-----------------------------------------------------------------------------
void CAsyncFileSystem::AsyncIOCallbackGateway(const FileAsyncRequest_t &request, int nBytesRead, FSAsyncStatus_t err)
{
	CAsyncRequestBase* pRequest = static_cast<CAsyncRequestBase*>( request.pContext );

	// Pack the results we care about into our own structure	
	CAsyncResultInfo_t results;
	results.m_nBytesTransferred = nBytesRead;
	results.m_pAllocatedBuffer = request.pData;
	results.m_ErrorCode = err;

	// gateway back to the CAsyncFileSystem object instance
	((CAsyncFileSystem*) g_pAsyncFileSystem)->AsyncIOCallBackHandler( pRequest, results );
}


//-----------------------------------------------------------------------------
// STATIC CAsyncFileSystem::AsyncSearchCallbackGateway
//	 - receives callbacks from the old Async file system search function
//     Thunks the callback back into the context of the CAsyncFileSystem object
//-----------------------------------------------------------------------------
void CAsyncFileSystem::AsyncSearchCallbackGateway( void* pContext, FSAsyncStatus_t err )
{
	CAsyncRequestBase* pRequest = static_cast<CAsyncRequestBase*>( pContext );
	
	// Pack the results we care about into our own structure	
	CAsyncResultInfo_t results;
	results.m_ErrorCode = err;
	
	// gateway back to the CAsyncFileSystem object instance
	((CAsyncFileSystem*) g_pAsyncFileSystem)->AsyncIOCallBackHandler( pRequest, results );
}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::AsyncIOCallBackReadJob
//	 - Handler for a completed file Read Job
//-----------------------------------------------------------------------------
void CAsyncFileSystem::AsyncIOCallBackHandler(CAsyncRequestBase* pRequest, CAsyncResultInfo_t& results )
{
	// Get the base info from the request
	// CAsyncRequestBase* pRequest = static_cast<CAsyncRequestBase*>( request.pContext );
	
	if ( !m_InFlight.IsInQueue( pRequest ) )
	{
		Error( "Can't find completed Async IO request" );
		return;
	}

	// Move the request to the completed list
	m_AsyncStateUpdateMutex.Lock();
	
	m_InFlight.Remove( pRequest );
	pRequest->m_RequestState = ASYNC_REQUEST_STATE_AWATING_FINISH;
	
	m_nJobsInflight--;

	// Were we asked to abort while we were servicing?
	if ( pRequest->m_bAbortRequest )
	{
		pRequest->AbortAfterServicing( results );			// Clean up any work in progress
		pRequest->DeleteOuter();							// Destroy the request
		
		m_AsyncStateUpdateMutex.Unlock();		
		KickOffFileJobs();									// go on to next ho
		return;
	}
	
	// we're not aborting, so do the task specific work
	pRequest->UpdateAfterServicing( results );

	// handle the error results from the old system
	pRequest->m_pOldAsyncStatus = results.m_ErrorCode;
	
	switch ( results.m_ErrorCode )
	{
		case FSASYNC_ERR_ALIGNMENT:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_ALIGNMENT;
			break;	
		}
		case FSASYNC_ERR_FAILURE:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_FAILURE; 
			break;
		}
		case FSASYNC_ERR_READING:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_READING; 
			break;
		}
		case FSASYNC_ERR_NOMEMORY:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_NOMEMORY; 
			break;
		}
		case FSASYNC_ERR_UNKNOWNID:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_UNKNOWNID; 
			break;
		}
		case FSASYNC_ERR_FILEOPEN:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_ERROR_FILEOPEN; 
			break;
		}
		case FSASYNC_OK:
		{
			pRequest->m_RequestStatus = ASYNC_REQUEST_OK; 
			break;	
		}
		case FSASYNC_STATUS_PENDING:		
		case FSASYNC_STATUS_INPROGRESS:		
		case FSASYNC_STATUS_ABORTED:		
		case FSASYNC_STATUS_UNSERVICED:		
		default:
		{
			Error( "Async result Status makes no sense" );
			pRequest->m_RequestStatus = ASYNC_REQUEST_OK;
			break;
		}
	};

	m_Completed.AddToTail( pRequest );

	m_AsyncStateUpdateMutex.Unlock();

	// Notify anyone who is listening that an IO has completed
	m_CompletionSignal.Set();
	
	// if we have other jobs in the priority queue, we have the ability to submit them now
	KickOffFileJobs();

	// Was this a synchronous operation?
	if ( pRequest->m_pSyncThreadEvent != NULL )
	{
		// wake up the calling thread...
		pRequest->m_pSyncThreadEvent->Set();
	}
	else
	{
		// This was an Async operation, so we notify anyone who cares...
		NotifyMessageQueueOrCallback( pRequest );
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::NotifyMessageQueueOrCallback
//    Places a notification in the designated message queue.
//    if no queue is specified, a callback can be directly performed
//	
//-----------------------------------------------------------------------------
void CAsyncFileSystem::NotifyMessageQueueOrCallback( CAsyncRequestBase* pRequest )
{
	// ok, do we have an IO completion queue to add this to?
	if ( pRequest->m_pResultQueue != NULL )	
	{
		CAsyncIOResult_t result;
		result.m_pRequest = pRequest->GetInterfaceBase();
		result.m_Status	= pRequest->GetRequestStatus();	
		
		pRequest->m_pResultQueue->Insert( result );
	}
	else	// otherwise we want to do the callback directly from this thread?
	{
		pRequest->ProcessCallback( true );			// remove request upon completion
	}
}





//-----------------------------------------------------------------------------
// STATIC CAsyncFileSystem::AsyncSearchCallbackAddItem
//	 - receives callbacks from the old Async file system directory search 
//     Adds the results to the desired list
//-----------------------------------------------------------------------------
void CAsyncFileSystem::AsyncSearchCallbackAddItem( void* pContext, char* pFoundPath, char* pFoundFile )
{
	CAsyncSearchRequest* pRequest = reinterpret_cast< CAsyncSearchRequest* >( ((CAsyncRequestBase*) pContext)->GetOuter() );

	CDirectoryEntryInfo_t result;
	V_ComposeFileName( pFoundPath, pFoundFile, result.m_FullFileName, sizeof(result.m_FullFileName) );
	
	pRequest->m_Results.AddToTail( result );
}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::GetAsyncIORequestStatus
//	
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::GetAsyncFileRequestStatus( const IAsyncRequestBase* pRequest )
{
	CAsyncRequestBase* pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();

	if ( !ValidateRequestPtr( pRequestBase ) )
	{
		return ASYNC_REQUEST_ERROR_BADPTR;
	}

	return pRequestBase->m_RequestStatus;
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::AbortAsyncIORequest
//	
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::AbortAsyncFileRequest( const IAsyncRequestBase* pRequest )
{
	AUTO_LOCK_FM( m_AsyncStateUpdateMutex );
	
	CAsyncRequestBase*	pRequestBase = NULL;
	AsyncRequestState_t CurrentStage = ASYNC_REQUEST_STATE_UNDEFINED;

	// determine if the pointer is still valid, and get info on it if so
	if ( !ResolveAsyncRequest( pRequest, pRequestBase, CurrentStage ) )
	{
		return ASYNC_REQUEST_ERROR_BADPTR;
	}

	switch( CurrentStage )
	{
		case ASYNC_REQUEST_STATE_COMPOSING:
		{
			return ASYNC_REQUEST_ERROR_NOTSUBMITTED;
		}
		case ASYNC_REQUEST_STATE_SUBMITTED:
		{
			pRequestBase->DeleteOuter();	// destroy request, it's destructor will remove it from m_Submitted
			return ASYNC_REQUEST_OK;
		
		}
		case ASYNC_REQUEST_STATE_SERVICING:
		{
			// Need to flag it for auto-release once it completes
			return ASYNC_REQUEST_ERROR_NOTSUBMITTED;
		}
		
		// already completed, nothing to abort
		case ASYNC_REQUEST_STATE_AWATING_FINISH:
		case ASYNC_REQUEST_STATE_COMPLETED:
		{
			return ASYNC_REQUEST_ERROR_ALREADYSERVICED;
		}
		default:
		{
			return ASYNC_REQUEST_ERROR_BADPTR;
		}
	}

}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::ResolveAsyncRequest - take an interface pointer supplied
//	  by a caller and 1) Determine if it is valid and 2) return base info if so
//-----------------------------------------------------------------------------
bool CAsyncFileSystem::ResolveAsyncRequest( const IAsyncRequestBase* pRequest, CAsyncRequestBase*& pRequestBase, AsyncRequestState_t& CurrentStage )
{
	// We should only be called when the Mutex is taken
	Assert( m_AsyncStateUpdateMutex.GetDepth() > 0 );

	// search our queues for the pointer
	// We do it the slow way, on the rare chance that the pointer pRequest points to invalid memory
	// Once we know it is valid, we can probe it.

	if ( m_Composing.IsInQueueIp( pRequest ) )
	{
		pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();
		CurrentStage = ASYNC_REQUEST_STATE_COMPOSING;
		return true;
	}

	if ( m_Submitted.IsInQueueIp( pRequest ) )
	{
		pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();
		CurrentStage = ASYNC_REQUEST_STATE_SUBMITTED;
		return true;
	}
	
	if ( m_InFlight.IsInQueueIp( pRequest ) )
	{
		pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();
		CurrentStage = ASYNC_REQUEST_STATE_SERVICING;
		return true;
	}
	
	if ( m_Completed.IsInQueueIp( pRequest ) )
	{
		pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();
		CurrentStage = ( (IAsyncRequestBase* ) pRequest)->GetRequestState();
		return true;
	}

	pRequestBase = NULL;
	CurrentStage = ASYNC_REQUEST_STATE_UNDEFINED;
	return false;

}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::RemoveRequest
//	  - remove request from any queue (assume it is being deleted)
//-----------------------------------------------------------------------------
void CAsyncFileSystem::RemoveRequest( CAsyncRequestBase* pRequest )
{
	AUTO_LOCK_FM( m_AsyncStateUpdateMutex );
	
	// Is status trustworthy?  maybe not?

	switch ( pRequest->m_RequestState )
	{
		case ASYNC_REQUEST_STATE_COMPOSING:
		{
			m_Composing.Remove( pRequest );
			break;
		}
		case ASYNC_REQUEST_STATE_SUBMITTED:
		{
			m_Submitted.Remove( pRequest );
			break;
		}
		case ASYNC_REQUEST_STATE_SERVICING:		
		{
			m_InFlight.Remove( pRequest);
			break;
		}
		case ASYNC_REQUEST_STATE_AWATING_FINISH:
		case ASYNC_REQUEST_STATE_COMPLETED:
		{
			m_Completed.Remove( pRequest );
			break;
		}
		default:
		{
			Error( " Couldn't Find Async Request to Remove" );
			break;
		}
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::AsyncIOSuspendAll
//	  - will suspend the servicing of queued file requests
//    - returns immediately unless bWaitForIOCompletion set, in which case
//        returns after all jobs in the process of being serviced complete
//-----------------------------------------------------------------------------
void CAsyncFileSystem::SuspendAllAsyncIO(  bool bWaitForIOCompletion )
{
	m_nSuspendCount++;

	if ( bWaitForIOCompletion && m_nSuspendCount > 0 )
	{
		WaitForServincingIOCompletion();
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::ResumeAllAsyncIO
//	 - Cancels a previous request to suspect all Async IO
//   - resumes the servicing of async jobs that are queued
//-----------------------------------------------------------------------------
void CAsyncFileSystem::ResumeAllAsyncIO()
{
	Assert ( m_nSuspendCount > 0 );
	
	m_nSuspendCount--;
	
	if ( m_nSuspendCount <= 0 )
	{
		Assert( m_nSuspendCount == 0 );
		m_nSuspendCount = 0;
		KickOffFileJobs();
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::AsyncIOAbortAll
//	    aborts all file requests submitted but not serviced
//      requests that have been created, but not submitted are unaffected
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::AbortAllAsyncIO( bool bWaitForIOCompletion )
{
	{
		AUTO_LOCK_FM( m_AsyncStateUpdateMutex );

		if ( m_Submitted.GetSize() <= 0 )
		{
			// return immediately if we're not waiting on jobs to finish 
			if ( m_nJobsInflight == 0 || bWaitForIOCompletion == false )
			{
				return ASYNC_REQUEST_OK;
			}
		}
	
		// Remove all jobs from the priority queue and discard
		while ( m_Submitted.GetSize() > 0 )
		{
			CAsyncRequestBase* pRequest = m_Submitted.RemoveHead();
			pRequest->DeleteOuter();		// Destroy the request
		}

		// Tell jobs currently being serviced to abort when finished
		while ( m_InFlight.GetSize() > 0 )
		{
			CAsyncRequestBase* pRequest = m_InFlight.RemoveHead();
			pRequest->m_bAbortRequest = true;
		}
	}
	
	if ( bWaitForIOCompletion )
	{
		WaitForServincingIOCompletion();
	}


	return ASYNC_REQUEST_OK;

}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::BlockUntilAsyncIOComplete
//      Suspends the calling thread until a pending IO completes
//-----------------------------------------------------------------------------
bool CAsyncFileSystem::BlockUntilAsyncIOComplete( const IAsyncRequestBase* pRequest )
{
	//CAsyncRequestBase* theRequest = reinterpret_cast<CAsyncRequestBase*>( const_cast<IAsyncRequestBase*>( pRequest ) );
	
	CAsyncRequestBase* pRequestBase = ( (IAsyncRequestBase* ) pRequest)->GetBase();

	// Validate the request from the user....
	if ( !ValidateRequestPtr( pRequestBase ) )
	{
		return false;
	}
	
	// Can't block while all IO is turned off
	if ( m_bIOSuspended )
	{
		return false;
	}

	// has to be submitted
	if ( pRequestBase->GetRequestState() <= ASYNC_REQUEST_STATE_COMPOSING )
	{
		return false;
	}

	// Ok, we have to grab the mutex to safely check the request state
	bool waitforIt = false;
	CThreadEvent syncEvent;
	
	m_AsyncStateUpdateMutex.Lock();
	// Can we just add the signaling request?
	if ( pRequestBase->GetRequestState() < ASYNC_REQUEST_STATE_AWATING_FINISH )
	{
		Assert( pRequestBase->m_pSyncThreadEvent);
		pRequestBase->m_pSyncThreadEvent = &syncEvent;
		waitforIt = true;
	}
	m_AsyncStateUpdateMutex.Unlock();
	
	// ok, no matetr what the request has the event set before it was finished, so even if
	// it finished in the meantime, the thred event will get signaled and it won't notify a completion queue
	if ( waitforIt )
	{
		pRequestBase->m_pSyncThreadEvent->Wait();
		NotifyMessageQueueOrCallback( pRequestBase );
	}
	
	return true;

}

		
//-----------------------------------------------------------------------------
// CAsyncFileSystem::WaitForServincingIOCompletion
//	    pauses the calling thread until all IO jobs being serviced
//      by the old system are completed..
//-----------------------------------------------------------------------------
void CAsyncFileSystem::WaitForServincingIOCompletion()
{
	while ( m_nJobsInflight > 0 )
	{
		m_CompletionSignal.Wait( 10 );
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::AllocateBuffer
//	
//-----------------------------------------------------------------------------
void* CAsyncFileSystem::AllocateBuffer( size_t nBufferSize, int nAlignment)
{
	Assert( nAlignment >= 0 );
	Assert( ValueIsPowerOfTwo( nAlignment ) );

	void* pMem = MemAlloc_AllocAligned( nBufferSize, nAlignment );
 #if defined(_DEBUG)
 	// In debug mode we track allocations so we later can track down leaks, etc
 	m_MemoryTrackMutex.Lock();
 	m_AllocList.AddToTail( pMem );
 	m_MemoryTrackMutex.Unlock();
 #endif

	return pMem;
}



//-----------------------------------------------------------------------------
// CAsyncFileSystem::ReleaseBuffer
//	
//-----------------------------------------------------------------------------
void CAsyncFileSystem::ReleaseBuffer( void* pBuffer )
{
	Assert ( pBuffer != NULL );

#if defined(_DEBUG)
	// In debug mode we verify that we had actually allocated this
	m_MemoryTrackMutex.Lock();
	Assert( m_AllocList.FindAndFastRemove( pBuffer ) == true );
	m_MemoryTrackMutex.Unlock();
#endif

	MemAlloc_FreeAligned( pBuffer );
}




//-----------------------------------------------------------------------------
// CAsyncFileSystem::ValidateRequestPtr
//	
//-----------------------------------------------------------------------------
bool CAsyncFileSystem::ValidateRequestPtr( CAsyncRequestBase* pRequest )
{
	// can't let it slip state between lines here...
	AUTO_LOCK_FM( m_AsyncStateUpdateMutex );
	
	switch ( pRequest->m_RequestState )
	{
		case ASYNC_REQUEST_STATE_COMPOSING:
		{
			if ( m_Composing.IsInQueue( pRequest ) )
			{
				return true;
			}
		}
		case ASYNC_REQUEST_STATE_SUBMITTED:
		{
			if ( m_Submitted.IsInQueue( pRequest ) ) 
			{
				return true;
			}
		}
		case ASYNC_REQUEST_STATE_SERVICING:		
		{
			if ( m_InFlight.IsInQueue( pRequest ) )
			{
				return true;
			}
		}
		case ASYNC_REQUEST_STATE_AWATING_FINISH:
		case ASYNC_REQUEST_STATE_COMPLETED:
		{
			if ( m_Completed.IsInQueue( pRequest ) )
			{
				return true;
			}
		}
		default:
		{
			return false;
		}
	}
}


//-----------------------------------------------------------------------------
// CAsyncFileSystem::ValidateRequest
//	
//-----------------------------------------------------------------------------
AsyncRequestStatus_t CAsyncFileSystem::ValidateRequest( CAsyncRequestBase* pRequest, bool bPerformSync )
{

	// Is this a request we know about and is awaiting submission?
	if ( !m_Composing.IsInQueue( pRequest ) ) 
	{
		// Can we find it already being processed?
		if ( m_Submitted.IsInQueue( pRequest ) ||
		      m_InFlight.IsInQueue( pRequest ) || 
		      m_Completed.IsInQueue( pRequest ) )
		{
			return ASYNC_REQUEST_ERROR_ALREADYSUBMITTED;
		}
		return ASYNC_REQUEST_ERROR_BADPTR;			// We think the pointer is bad
	}

	// Now we check the contents of the request to make sure it makes sense...
	
	// file operation must be set
	if ( pRequest->GetAsyncOperationType() <= ASYNC_OP_UNDEFINED || pRequest->GetAsyncOperationType() >= ASYNC_OP_COUNT )
	{
		return ASYNC_REQUEST_ERROR_BADOPER;	
	}
	

	// Are we doing synchronous IO?
	if ( bPerformSync )
	{
		// No callback is allowable in sync mode
		if ( pRequest->m_pCallback != NULL || pRequest->m_pResultQueue != NULL )
		{
			// return ASYNC_REQUEST_ERROR_NOTVALIDSYNCRONOUS;
			// just ignore the callbacks and do the type specific validation
		}
	}
	else
	{
		// We need a completion queue, a callback or both
		if ( pRequest->m_pResultQueue == NULL && pRequest->m_pCallback == NULL )
		{
			return ASYNC_REQUEST_ERROR_NONOTIFICATION;	// must have a notification or callback
		}
	}

	// Do the request specific validation
	return pRequest->ValidateSubmittedRequest( bPerformSync );


}

//-----------------------------------------------------------------------------
// s_FileNameCharMap  - helper table for validating filenames and path processing
//  The values are control vales for ASCII character 0 to 127.  They are
//
//  0  - invalid character
//  1  - uppercase character (convert to lower and complain)
//  2  - valid anytime character
//  3  - path divider ( "\" or "/" )
//  4  - valid only in the middle of a name
//  5  - name extension character ( "." )
//  6  - drive specifier ":"
//	
//-----------------------------------------------------------------------------
byte s_FileNameCharMap[128] = {
// 0-31 - control codes
           0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,
// 32-63  sp  !	 "  #   $  %  &  '   (  )  *  +   ,  -  .  /    0  1  2  3   4  5  6  7   8  9  :  ;   <  =  >  ?
           4, 2, 0, 2,  2, 2, 2, 2,  2, 2, 0, 0,  2, 2, 5, 3,   2, 2, 2, 2,  2, 2, 2, 2,  2, 2, 6, 0,  0, 0, 0, 0,
// 64-95   @  A  B  C   D  E  F  G   H  I  J  K   L  M  N  O    P  Q  R  S   T  U  V  W   X  Y  Z  [   \  ]  ^  _
           2, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 0,  3, 0, 2, 2, 
// 96-127  `  a  b  c   d  e  f  g   h  i  j  k   l  m  n  o    p  q  r  s   t  u  v  w   x  y  z  {   |  }  ~  del
           2, 2, 2, 2,  2, 2, 2, 2,  2, 2, 2, 2,  2, 2, 2, 2,   2, 2, 2, 2,  2, 2, 2, 2,  2, 2, 2, 2,  0, 2, 2, 0  };


//-----------------------------------------------------------------------------
// CAsyncFileSystem::ValidateFileName
//	  - examines the filename for problems, fixes or rejects it if so.
//  
//-----------------------------------------------------------------------------
AsyncRequestStatus_t ValidateFileName( const char* pFileName )
{
	// todo - this code doesn't examine each filename or path as closely as could be done
	// According to ChrisB, we shouldn't do all this validation as it's a time suck
	//  and our pack files won't care...
	
	int32	theLength = Q_strlen( pFileName );
	
	char*	theFilename = const_cast<char*>( pFileName );
	
	if ( theLength >= MAX_PATH )
	{
		return ASYNC_REQUEST_ERROR_PATHTOOLONG;
	}
	
	int32   lastPathSeparator = -1;
	int32	i = 0;
	bool	bUpperCaseWarn = false;
	
	while ( i < theLength )
	{
		char c = theFilename[i];
		if ( c > 250 )   // allow western european file chars...
		{
			
			return ASYNC_REQUEST_ERROR_INVALIDFILENAME;		
		}
		switch ((int32) s_FileNameCharMap[c])
		{
			case 0:	// invalid character
			{
				return ASYNC_REQUEST_ERROR_INVALIDFILENAME;		
			}
			case 1: // uppercase character
			{
				theFilename[i] = (char) (c + 0x20);		// convert to lower case
				bUpperCaseWarn = true;
				break;
			}
			case 2: // valid character
			{
				break;
			}
			case 3: // path divider
			{
				if ( lastPathSeparator >= 0 )
				{
					if ( i-1 == lastPathSeparator || i == theLength-1 )
					{
						return ASYNC_REQUEST_ERROR_BADPATHSPEC;
					}
				}
				lastPathSeparator = i;
				break;
			}
			case 4:  // valid only in the middle of a filename
			{
				if ( i-1 == lastPathSeparator )	// 1st character in this section?
					{
						return ASYNC_REQUEST_ERROR_INVALIDFILENAME;
					}
				break;
			}
			case 5:	 // extension separator
			{
				break;
			}
			case 6:	// drive : 
			{
				// Always needs to occur as the 2nd character in the name if at all
				if ( i != 1 )
				{
					return ASYNC_REQUEST_ERROR_BADPATHSPEC;
				}
				break;
			}
			default:
			{
				break;
			}
		}
	
		i++;
	}
	
	// check filename length
	int32 nameLen;
	if ( lastPathSeparator < 0 )
	{
		nameLen = i;
	}
	else
	{
		nameLen = i - lastPathSeparator -1;
	}
	
	if ( nameLen >= CAsyncFileSystem::s_MaxPlatformFileNameLength )			// 40 is maximum length for Xbox STFS
	{
		return ASYNC_REQUEST_ERROR_FILENAMETOOLONG;
	}

	// make sure the path characters are platform correct	
	if ( lastPathSeparator >= 0 )
	{
		Q_FixSlashes( theFilename );		// use the library to correct the path dividers for the OS
											// Yes, I know.. not as efficient as we could make it...
	}

	if ( bUpperCaseWarn )
	{
		Warning( "Linux/platform issue - filename '%s' contains uppercase\n", theFilename );
	}

	return ASYNC_REQUEST_OK;

}