void object::test<4>()
{
#define HASH_SET_SIZE 1000
CPLHashSet* set = CPLHashSetNew(NULL, NULL, NULL);
for(int i=0;i<HASH_SET_SIZE;i++)
{
ensure(CPLHashSetInsert(set, (void*)i) == TRUE);
}
ensure(CPLHashSetSize(set) == HASH_SET_SIZE);
for(int i=0;i<HASH_SET_SIZE;i++)
{
ensure(CPLHashSetInsert(set, (void*)i) == FALSE);
}
ensure(CPLHashSetSize(set) == HASH_SET_SIZE);
for(int i=0;i<HASH_SET_SIZE;i++)
{
ensure(CPLHashSetLookup(set, (const void*)i) == (const void*)i);
}
int sum = 0;
CPLHashSetForeach(set, sumValues, &sum);
ensure(sum == (HASH_SET_SIZE-1) * HASH_SET_SIZE / 2);
for(int i=0;i<HASH_SET_SIZE;i++)
{
ensure(CPLHashSetRemove(set, (void*)i) == TRUE);
}
ensure(CPLHashSetSize(set) == 0);
CPLHashSetDestroy(set);
}
void VRTRawRasterBand::GetFileList( char*** ppapszFileList, int *pnSize,
int *pnMaxSize, CPLHashSet* hSetFiles )
{
if (m_pszSourceFilename == NULL)
return;
/* -------------------------------------------------------------------- */
/* Is it already in the list ? */
/* -------------------------------------------------------------------- */
CPLString osSourceFilename;
if( m_bRelativeToVRT && strlen(poDS->GetDescription()) > 0 )
osSourceFilename = CPLFormFilename(
CPLGetDirname(poDS->GetDescription()), m_pszSourceFilename, NULL );
else
osSourceFilename = m_pszSourceFilename;
if( CPLHashSetLookup(hSetFiles, osSourceFilename) != NULL )
return;
/* -------------------------------------------------------------------- */
/* Grow array if necessary */
/* -------------------------------------------------------------------- */
if (*pnSize + 1 >= *pnMaxSize)
{
*pnMaxSize = 2 + 2 * (*pnMaxSize);
*ppapszFileList = reinterpret_cast<char **>(
CPLRealloc( *ppapszFileList, sizeof(char*) * (*pnMaxSize) ) );
}
/* -------------------------------------------------------------------- */
/* Add the string to the list */
/* -------------------------------------------------------------------- */
(*ppapszFileList)[*pnSize] = CPLStrdup(osSourceFilename);
(*ppapszFileList)[(*pnSize + 1)] = NULL;
CPLHashSetInsert(hSetFiles, (*ppapszFileList)[*pnSize]);
(*pnSize)++;
VRTRasterBand::GetFileList( ppapszFileList, pnSize,
pnMaxSize, hSetFiles);
}
void VRTRasterBand::GetFileList(char*** ppapszFileList, int *pnSize,
int *pnMaxSize, CPLHashSet* hSetFiles)
{
for( unsigned int iOver = 0; iOver < apoOverviews.size(); iOver++ )
{
CPLString &osFilename = apoOverviews[iOver].osFilename;
/* -------------------------------------------------------------------- */
/* Is the filename even a real filesystem object? */
/* -------------------------------------------------------------------- */
VSIStatBufL sStat;
if( VSIStatL( osFilename, &sStat ) != 0 )
return;
/* -------------------------------------------------------------------- */
/* Is it already in the list ? */
/* -------------------------------------------------------------------- */
if( CPLHashSetLookup(hSetFiles, osFilename) != NULL )
return;
/* -------------------------------------------------------------------- */
/* Grow array if necessary */
/* -------------------------------------------------------------------- */
if (*pnSize + 1 >= *pnMaxSize)
{
*pnMaxSize = 2 + 2 * (*pnMaxSize);
*ppapszFileList = (char **) CPLRealloc(
*ppapszFileList, sizeof(char*) * (*pnMaxSize) );
}
/* -------------------------------------------------------------------- */
/* Add the string to the list */
/* -------------------------------------------------------------------- */
(*ppapszFileList)[*pnSize] = CPLStrdup(osFilename);
(*ppapszFileList)[(*pnSize + 1)] = NULL;
CPLHashSetInsert(hSetFiles, (*ppapszFileList)[*pnSize]);
(*pnSize) ++;
}
}
OGRFeature*
OGRXPlaneAirwayIntersectionLayer::AddFeature(const char* pszIntersectionName,
double dfLat,
double dfLon)
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( 0, pszIntersectionName );
if (CPLHashSetLookup(poSet, poFeature) == NULL)
{
CPLHashSetInsert(poSet, poFeature->Clone());
RegisterFeature(poFeature);
return poFeature;
}
else
{
delete poFeature;
return NULL;
}
}
static
CPLXMLNode* CPLLoadSchemaStrInternal(CPLHashSet* hSetSchemas,
const char* pszFile)
{
if (CPLHashSetLookup(hSetSchemas, pszFile))
return NULL;
CPLHashSetInsert(hSetSchemas, CPLStrdup(pszFile));
CPLDebug("CPL", "Parsing %s", pszFile);
CPLXMLNode* psXML = CPLParseXMLFile(pszFile);
if (psXML == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot open %s", pszFile);
return NULL;
}
CPLXMLNode* psSchema = CPLGetXMLNode(psXML, "=schema");
if (psSchema == NULL)
psSchema = CPLGetXMLNode(psXML, "=xs:schema");
if (psSchema == NULL)
psSchema = CPLGetXMLNode(psXML, "=xsd:schema");
if (psSchema == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot find schema node in %s", pszFile);
CPLDestroyXMLNode(psXML);
return NULL;
}
CPLXMLNode* psPrev = NULL;
CPLXMLNode* psIter = psSchema->psChild;
while(psIter)
{
bool bDestroyCurrentNode = false;
#ifdef HAS_VALIDATION_BUG
if (bHasLibXMLBug)
bDestroyCurrentNode = CPLWorkaroundLibXMLBug(psIter);
#endif
/* Load the referenced schemas, and integrate them in the main schema */
if (psIter->eType == CXT_Element &&
(strcmp(psIter->pszValue, "include") == 0 ||
strcmp(psIter->pszValue, "xs:include") == 0||
strcmp(psIter->pszValue, "xsd:include") == 0) &&
psIter->psChild != NULL &&
psIter->psChild->eType == CXT_Attribute &&
strcmp(psIter->psChild->pszValue, "schemaLocation") == 0)
{
const char* pszIncludeSchema = psIter->psChild->psChild->pszValue;
char* pszFullFilename = CPLStrdup(
CPLFormFilename(CPLGetPath(pszFile), pszIncludeSchema, NULL));
CPLFixPath(pszFullFilename);
CPLXMLNode* psSubXML = NULL;
/* If we haven't yet loaded that schema, do it now */
if (!CPLHashSetLookup(hSetSchemas, pszFullFilename))
{
psSubXML = CPLLoadSchemaStrInternal(hSetSchemas, pszFullFilename);
if (psSubXML == NULL)
{
CPLFree(pszFullFilename);
CPLDestroyXMLNode(psXML);
return NULL;
}
}
CPLFree(pszFullFilename);
pszFullFilename = NULL;
if (psSubXML)
{
CPLXMLNode* psNext = psIter->psNext;
psSubXML = CPLExtractSubSchema(psSubXML, psSchema);
if (psSubXML == NULL)
{
CPLDestroyXMLNode(psXML);
return NULL;
}
/* Replace <include/> node by the subXML */
CPLXMLNode* psIter2 = psSubXML;
while(psIter2->psNext)
psIter2 = psIter2->psNext;
psIter2->psNext = psNext;
if (psPrev == NULL)
psSchema->psChild = psSubXML;
else
psPrev->psNext = psSubXML;
psIter->psNext = NULL;
CPLDestroyXMLNode(psIter);
psPrev = psIter2;
psIter = psNext;
continue;
}
else
{
/* We have already included that file, */
/* so just remove the <include/> node */
bDestroyCurrentNode = true;
}
}
/* Patch the schemaLocation of <import/> */
else if (psIter->eType == CXT_Element &&
(strcmp(psIter->pszValue, "import") == 0 ||
strcmp(psIter->pszValue, "xs:import") == 0||
strcmp(psIter->pszValue, "xsd:import") == 0))
{
CPLXMLNode* psIter2 = psIter->psChild;
while(psIter2)
{
if (psIter2->eType == CXT_Attribute &&
strcmp(psIter2->pszValue, "schemaLocation") == 0 &&
psIter2->psChild != NULL &&
!STARTS_WITH(psIter2->psChild->pszValue, "http://") &&
!STARTS_WITH(psIter2->psChild->pszValue, "ftp://") &&
/* If the top file is our warping file, don't alter the path of the import */
strstr(pszFile, "/vsimem/CPLValidateXML_") == NULL )
{
char* pszFullFilename = CPLStrdup(CPLFormFilename(
CPLGetPath(pszFile), psIter2->psChild->pszValue, NULL));
CPLFixPath(pszFullFilename);
CPLFree(psIter2->psChild->pszValue);
psIter2->psChild->pszValue = pszFullFilename;
}
psIter2 = psIter2->psNext;
}
}
if (bDestroyCurrentNode)
{
CPLXMLNode* psNext = psIter->psNext;
if (psPrev == NULL)
psSchema->psChild = psNext;
else
psPrev->psNext = psNext;
psIter->psNext = NULL;
CPLDestroyXMLNode(psIter);
psIter = psNext;
continue;
}
psPrev = psIter;
psIter = psIter->psNext;
}
return psXML;
}
