static FindFileTLS* CPLGetFindFileTLS()
{
FindFileTLS* pTLSData =
(FindFileTLS *) CPLGetTLS( CTLS_FINDFILE );
if (pTLSData == NULL)
{
pTLSData = (FindFileTLS*) CPLCalloc(1, sizeof(FindFileTLS));
CPLSetTLSWithFreeFunc( CTLS_FINDFILE, pTLSData, CPLFindFileFreeTLS );
}
return pTLSData;
}
static FindFileTLS* CPLGetFindFileTLS()
{
int bMemoryError = FALSE;
FindFileTLS* pTLSData =
reinterpret_cast<FindFileTLS *>(
CPLGetTLSEx( CTLS_FINDFILE, &bMemoryError ) );
if( bMemoryError )
return NULL;
if (pTLSData == NULL)
{
pTLSData = static_cast<FindFileTLS *>(
VSI_CALLOC_VERBOSE(1, sizeof(FindFileTLS) ) );
if( pTLSData == NULL )
return NULL;
CPLSetTLSWithFreeFunc( CTLS_FINDFILE, pTLSData, CPLFindFileFreeTLS );
}
return pTLSData;
}
void CPLCondWait( void *hCond, void* hClientMutex )
{
Win32Cond* psCond = (Win32Cond*) hCond;
HANDLE hEvent = (HANDLE) CPLGetTLS(CTLS_WIN32_COND);
if (hEvent == NULL)
{
hEvent = CreateEvent(NULL, /* security attributes */
0, /* manual reset = no */
0, /* initial state = unsignaled */
NULL /* no name */);
CPLAssert(hEvent != NULL);
CPLSetTLSWithFreeFunc(CTLS_WIN32_COND, hEvent, CPLTLSFreeEvent);
}
/* Insert the waiter into the waiter list of the condition */
CPLAcquireMutex(psCond->hInternalMutex, 1000.0);
WaiterItem* psItem = (WaiterItem*)malloc(sizeof(WaiterItem));
CPLAssert(psItem != NULL);
psItem->hEvent = hEvent;
psItem->psNext = psCond->psWaiterList;
psCond->psWaiterList = psItem;
CPLReleaseMutex(psCond->hInternalMutex);
/* Release the client mutex before waiting for the event being signaled */
CPLReleaseMutex(hClientMutex);
// Ideally we would check that we do not get WAIT_FAILED but it is hard
// to report a failure.
WaitForSingleObject(hEvent, INFINITE);
/* Reacquire the client mutex */
CPLAcquireMutex(hClientMutex, 1000.0);
}
void CPLSetTLS( int nIndex, void *pData, int bFreeOnExit )
{
CPLSetTLSWithFreeFunc(nIndex, pData, (bFreeOnExit) ? CPLFree : NULL);
}
static CSVTable *CSVAccess( const char * pszFilename )
{
CSVTable *psTable;
FILE *fp;
/* -------------------------------------------------------------------- */
/* Fetch the table, and allocate the thread-local pointer to it */
/* if there isn't already one. */
/* -------------------------------------------------------------------- */
CSVTable **ppsCSVTableList;
ppsCSVTableList = (CSVTable **) CPLGetTLS( CTLS_CSVTABLEPTR );
if( ppsCSVTableList == NULL )
{
ppsCSVTableList = (CSVTable **) CPLCalloc(1,sizeof(CSVTable*));
CPLSetTLSWithFreeFunc( CTLS_CSVTABLEPTR, ppsCSVTableList, CSVFreeTLS );
}
/* -------------------------------------------------------------------- */
/* Is the table already in the list. */
/* -------------------------------------------------------------------- */
for( psTable = *ppsCSVTableList;
psTable != NULL;
psTable = psTable->psNext )
{
if( EQUAL(psTable->pszFilename,pszFilename) )
{
/*
* Eventually we should consider promoting to the front of
* the list to accelerate frequently accessed tables.
*/
return( psTable );
}
}
/* -------------------------------------------------------------------- */
/* If not, try to open it. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create an information structure about this table, and add to */
/* the front of the list. */
/* -------------------------------------------------------------------- */
psTable = (CSVTable *) CPLCalloc(sizeof(CSVTable),1);
psTable->fp = fp;
psTable->pszFilename = CPLStrdup( pszFilename );
psTable->bNonUniqueKey = FALSE; /* as far as we know now */
psTable->psNext = *ppsCSVTableList;
*ppsCSVTableList = psTable;
/* -------------------------------------------------------------------- */
/* Read the table header record containing the field names. */
/* -------------------------------------------------------------------- */
psTable->papszFieldNames = CSVReadParseLine( fp );
return( psTable );
}
