// decode s from base64, XMLencoded or read from the file name s
const char *WMSUtilDecode(CPLString &s, const char *encoding) {
if (EQUAL(encoding, "base64")) {
std::vector<char> buffer(s.begin(), s.end());
buffer.push_back('\0');
int nSize =
CPLBase64DecodeInPlace(reinterpret_cast<GByte *>(&buffer[0]));
s.assign(&buffer[0], nSize);
}
else if (EQUAL(encoding, "XMLencoded")) {
int len = static_cast<int>(s.size());
char *result = CPLUnescapeString(s.c_str(), &len, CPLES_XML);
s.assign(result, static_cast<size_t>(len));
CPLFree(result);
}
else if (EQUAL(encoding, "file")) { // Not an encoding but an external file
VSILFILE *f = VSIFOpenL(s.c_str(), "rb");
s.clear(); // Return an empty string if file can't be opened or read
if (f) {
VSIFSeekL(f, 0, SEEK_END);
size_t size = static_cast<size_t>(VSIFTellL(f));
VSIFSeekL(f, 0, SEEK_SET);
std::vector<char> buffer(size);
if (VSIFReadL(reinterpret_cast<void *>(&buffer[0]), size, 1, f))
s.assign(&buffer[0], buffer.size());
VSIFCloseL(f);
}
}
return s.c_str();
}
OGRLayer* OGRCouchDBDataSource::OpenDatabase(const char* pszLayerName)
{
CPLString osTableName;
CPLString osEscapedName;
if (pszLayerName)
{
osTableName = pszLayerName;
char* pszEscapedName = CPLEscapeString(pszLayerName, -1, CPLES_URL);
osEscapedName = pszEscapedName;
CPLFree(pszEscapedName);
}
else
{
char* pszURL = CPLStrdup(osURL);
char* pszLastSlash = strrchr(pszURL, '/');
if (pszLastSlash)
{
osEscapedName = pszLastSlash + 1;
char* l_pszName = CPLUnescapeString(osEscapedName, NULL, CPLES_URL);
osTableName = l_pszName;
CPLFree(l_pszName);
*pszLastSlash = 0;
}
osURL = pszURL;
CPLFree(pszURL);
pszURL = NULL;
if (pszLastSlash == NULL)
return NULL;
}
CPLString osURI("/");
osURI += osEscapedName;
json_object* poAnswerObj = GET(osURI);
if (poAnswerObj == NULL)
return NULL;
if ( !json_object_is_type(poAnswerObj, json_type_object) ||
CPL_json_object_object_get(poAnswerObj, "db_name") == NULL )
{
IsError(poAnswerObj, "Database opening failed");
json_object_put(poAnswerObj);
return NULL;
}
OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, osTableName);
if ( CPL_json_object_object_get(poAnswerObj, "update_seq") != NULL )
{
int nUpdateSeq = json_object_get_int(CPL_json_object_object_get(poAnswerObj, "update_seq"));
poLayer->SetUpdateSeq(nUpdateSeq);
}
json_object_put(poAnswerObj);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
int main( int argc, char ** argv )
{
const char *pszLocX = NULL, *pszLocY = NULL;
const char *pszSrcFilename = NULL;
char *pszSourceSRS = NULL;
std::vector<int> anBandList;
bool bAsXML = false, bLIFOnly = false;
bool bQuiet = false, bValOnly = false;
int nOverview = -1;
char **papszOpenOptions = NULL;
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-b") && i < argc-1 )
{
anBandList.push_back( atoi(argv[++i]) );
}
else if( EQUAL(argv[i],"-overview") && i < argc-1 )
{
nOverview = atoi(argv[++i]) - 1;
}
else if( EQUAL(argv[i],"-l_srs") && i < argc-1 )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS(argv[++i]);
}
else if( EQUAL(argv[i],"-geoloc") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = CPLStrdup("-geoloc");
}
else if( EQUAL(argv[i],"-wgs84") )
{
CPLFree(pszSourceSRS);
pszSourceSRS = SanitizeSRS("WGS84");
}
else if( EQUAL(argv[i],"-xml") )
{
bAsXML = true;
}
else if( EQUAL(argv[i],"-lifonly") )
{
bLIFOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i],"-valonly") )
{
bValOnly = true;
bQuiet = true;
}
else if( EQUAL(argv[i], "-oo") && i < argc-1 )
{
papszOpenOptions = CSLAddString( papszOpenOptions,
argv[++i] );
}
else if( argv[i][0] == '-' && !isdigit(argv[i][1]) )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszLocX == NULL )
pszLocX = argv[i];
else if( pszLocY == NULL )
pszLocY = argv[i];
else
Usage();
}
if( pszSrcFilename == NULL || (pszLocX != NULL && pszLocY == NULL) )
Usage();
/* -------------------------------------------------------------------- */
/* Open source file. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL;
hSrcDS = GDALOpenEx( pszSrcFilename, GDAL_OF_RASTER, NULL,
(const char* const* )papszOpenOptions, NULL );
if( hSrcDS == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Setup coordinate transformation, if required */
/* -------------------------------------------------------------------- */
OGRSpatialReferenceH hSrcSRS = NULL, hTrgSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
if( pszSourceSRS != NULL && !EQUAL(pszSourceSRS,"-geoloc") )
{
hSrcSRS = OSRNewSpatialReference( pszSourceSRS );
hTrgSRS = OSRNewSpatialReference( GDALGetProjectionRef( hSrcDS ) );
hCT = OCTNewCoordinateTransformation( hSrcSRS, hTrgSRS );
if( hCT == NULL )
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If no bands were requested, we will query them all. */
/* -------------------------------------------------------------------- */
if( anBandList.size() == 0 )
{
for( i = 0; i < GDALGetRasterCount( hSrcDS ); i++ )
anBandList.push_back( i+1 );
}
/* -------------------------------------------------------------------- */
/* Turn the location into a pixel and line location. */
/* -------------------------------------------------------------------- */
int inputAvailable = 1;
double dfGeoX;
double dfGeoY;
CPLString osXML;
if( pszLocX == NULL && pszLocY == NULL )
{
if (fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2)
{
inputAvailable = 0;
}
}
else
{
dfGeoX = CPLAtof(pszLocX);
dfGeoY = CPLAtof(pszLocY);
}
while (inputAvailable)
{
int iPixel, iLine;
if (hCT)
{
if( !OCTTransform( hCT, 1, &dfGeoX, &dfGeoY, NULL ) )
exit( 1 );
}
if( pszSourceSRS != NULL )
{
double adfGeoTransform[6], adfInvGeoTransform[6];
if( GDALGetGeoTransform( hSrcDS, adfGeoTransform ) != CE_None )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot get geotransform");
exit( 1 );
}
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot invert geotransform");
exit( 1 );
}
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
}
else
{
iPixel = (int) floor(dfGeoX);
iLine = (int) floor(dfGeoY);
}
/* -------------------------------------------------------------------- */
/* Prepare report. */
/* -------------------------------------------------------------------- */
CPLString osLine;
if( bAsXML )
{
osLine.Printf( "<Report pixel=\"%d\" line=\"%d\">",
iPixel, iLine );
osXML += osLine;
}
else if( !bQuiet )
{
printf( "Report:\n" );
printf( " Location: (%dP,%dL)\n", iPixel, iLine );
}
int bPixelReport = TRUE;
if( iPixel < 0 || iLine < 0
|| iPixel >= GDALGetRasterXSize( hSrcDS )
|| iLine >= GDALGetRasterYSize( hSrcDS ) )
{
if( bAsXML )
osXML += "<Alert>Location is off this file! No further details to report.</Alert>";
else if( bValOnly )
printf("\n");
else if( !bQuiet )
printf( "\nLocation is off this file! No further details to report.\n");
bPixelReport = FALSE;
}
/* -------------------------------------------------------------------- */
/* Process each band. */
/* -------------------------------------------------------------------- */
for( i = 0; bPixelReport && i < (int) anBandList.size(); i++ )
{
GDALRasterBandH hBand = GDALGetRasterBand( hSrcDS, anBandList[i] );
int iPixelToQuery = iPixel;
int iLineToQuery = iLine;
if (nOverview >= 0 && hBand != NULL)
{
GDALRasterBandH hOvrBand = GDALGetOverview(hBand, nOverview);
if (hOvrBand != NULL)
{
int nOvrXSize = GDALGetRasterBandXSize(hOvrBand);
int nOvrYSize = GDALGetRasterBandYSize(hOvrBand);
iPixelToQuery = (int)(0.5 + 1.0 * iPixel / GDALGetRasterXSize( hSrcDS ) * nOvrXSize);
iLineToQuery = (int)(0.5 + 1.0 * iLine / GDALGetRasterYSize( hSrcDS ) * nOvrYSize);
if (iPixelToQuery >= nOvrXSize)
iPixelToQuery = nOvrXSize - 1;
if (iLineToQuery >= nOvrYSize)
iLineToQuery = nOvrYSize - 1;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot get overview %d of band %d",
nOverview + 1, anBandList[i] );
}
hBand = hOvrBand;
}
if (hBand == NULL)
continue;
if( bAsXML )
{
osLine.Printf( "<BandReport band=\"%d\">", anBandList[i] );
osXML += osLine;
}
else if( !bQuiet )
{
printf( " Band %d:\n", anBandList[i] );
}
/* -------------------------------------------------------------------- */
/* Request location info for this location. It is possible */
/* only the VRT driver actually supports this. */
/* -------------------------------------------------------------------- */
CPLString osItem;
osItem.Printf( "Pixel_%d_%d", iPixelToQuery, iLineToQuery );
const char *pszLI = GDALGetMetadataItem( hBand, osItem, "LocationInfo");
if( pszLI != NULL )
{
if( bAsXML )
osXML += pszLI;
else if( !bQuiet )
printf( " %s\n", pszLI );
else if( bLIFOnly )
{
/* Extract all files, if any. */
CPLXMLNode *psRoot = CPLParseXMLString( pszLI );
if( psRoot != NULL
&& psRoot->psChild != NULL
&& psRoot->eType == CXT_Element
&& EQUAL(psRoot->pszValue,"LocationInfo") )
{
CPLXMLNode *psNode;
for( psNode = psRoot->psChild;
psNode != NULL;
psNode = psNode->psNext )
{
if( psNode->eType == CXT_Element
&& EQUAL(psNode->pszValue,"File")
&& psNode->psChild != NULL )
{
char* pszUnescaped = CPLUnescapeString(
psNode->psChild->pszValue, NULL, CPLES_XML);
printf( "%s\n", pszUnescaped );
CPLFree(pszUnescaped);
}
}
}
CPLDestroyXMLNode( psRoot );
}
}
/* -------------------------------------------------------------------- */
/* Report the pixel value of this band. */
/* -------------------------------------------------------------------- */
double adfPixel[2];
if( GDALRasterIO( hBand, GF_Read, iPixelToQuery, iLineToQuery, 1, 1,
adfPixel, 1, 1, GDT_CFloat64, 0, 0) == CE_None )
{
CPLString osValue;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<Value>";
osXML += osValue;
osXML += "</Value>";
}
else if( !bQuiet )
printf( " Value: %s\n", osValue.c_str() );
else if( bValOnly )
printf( "%s\n", osValue.c_str() );
// Report unscaled if we have scale/offset values.
int bSuccess;
double dfOffset = GDALGetRasterOffset( hBand, &bSuccess );
double dfScale = GDALGetRasterScale( hBand, &bSuccess );
if( dfOffset != 0.0 || dfScale != 1.0 )
{
adfPixel[0] = adfPixel[0] * dfScale + dfOffset;
adfPixel[1] = adfPixel[1] * dfScale + dfOffset;
if( GDALDataTypeIsComplex( GDALGetRasterDataType( hBand ) ) )
osValue.Printf( "%.15g+%.15gi", adfPixel[0], adfPixel[1] );
else
osValue.Printf( "%.15g", adfPixel[0] );
if( bAsXML )
{
osXML += "<DescaledValue>";
osXML += osValue;
osXML += "</DescaledValue>";
}
else if( !bQuiet )
printf( " Descaled Value: %s\n", osValue.c_str() );
}
}
if( bAsXML )
osXML += "</BandReport>";
}
osXML += "</Report>";
if( (pszLocX != NULL && pszLocY != NULL) ||
(fscanf(stdin, "%lf %lf", &dfGeoX, &dfGeoY) != 2) )
{
inputAvailable = 0;
}
}
/* -------------------------------------------------------------------- */
/* Finalize xml report and print. */
/* -------------------------------------------------------------------- */
if( bAsXML )
{
CPLXMLNode *psRoot;
char *pszFormattedXML;
psRoot = CPLParseXMLString( osXML );
pszFormattedXML = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
printf( "%s", pszFormattedXML );
CPLFree( pszFormattedXML );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if (hCT) {
OSRDestroySpatialReference( hSrcSRS );
OSRDestroySpatialReference( hTrgSRS );
OCTDestroyCoordinateTransformation( hCT );
}
if (hSrcDS)
GDALClose(hSrcDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLFree(pszSourceSRS);
CSLDestroy(papszOpenOptions);
CSLDestroy( argv );
return 0;
}
CPLXMLNode *WCTSCollectKVPRequest()
{
char **papszParmList;
/* -------------------------------------------------------------------- */
/* Parse the query string. */
/* -------------------------------------------------------------------- */
if( getenv("QUERY_STRING") == NULL )
WCTSEmitServiceException( "QUERY_STRING not set." );
papszParmList = CSLTokenizeString2( getenv("QUERY_STRING"), "&",
CSLT_PRESERVEESCAPES );
/* -------------------------------------------------------------------- */
/* Un-url-encode the items. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; papszParmList != NULL && papszParmList[i] != NULL; i++ )
{
char *pszNewValue = CPLUnescapeString( papszParmList[i],
NULL, CPLES_URL );
CPLFree( papszParmList[i] );
papszParmList[i] = pszNewValue;
}
/* -------------------------------------------------------------------- */
/* Check for REQUEST */
/* -------------------------------------------------------------------- */
const char *pszVersion = CSLFetchNameValue(papszParmList,"VERSION");
const char *pszRequest = CSLFetchNameValue(papszParmList,"REQUEST");
if( pszRequest == NULL )
WCTSEmitServiceException( "REQUEST not provided in KVP URL." );
/* -------------------------------------------------------------------- */
/* Handle GetCapabilities */
/* -------------------------------------------------------------------- */
else if( EQUAL(pszRequest,"GetCapabilities") )
{
CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element,
"GetCapabilities" );
if( pszVersion != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ),
CXT_Text, pszVersion );
}
if( CSLFetchNameValue(papszParmList,"SERVICE") != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "service" ),
CXT_Text, CSLFetchNameValue(papszParmList,"SERVICE") );
}
return psRequest;
}
/* ==================================================================== */
/* Handle IsTransformable */
/* ==================================================================== */
else if( EQUAL(pszRequest,"IsTransformable") )
{
CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element,
"IsTransformable" );
/* -------------------------------------------------------------------- */
/* Translate the source crs. */
/* -------------------------------------------------------------------- */
CPLAddXMLChild(
CPLCreateXMLNode( psRequest, CXT_Element, "SourceCRS" ),
WCTSAuthId2crsId( papszParmList, "SOURCECRS" ) );
/* -------------------------------------------------------------------- */
/* Translate the destination crs. */
/* -------------------------------------------------------------------- */
CPLAddXMLChild(
CPLCreateXMLNode( psRequest, CXT_Element, "TargetCRS" ),
WCTSAuthId2crsId( papszParmList, "TARGETCRS" ) );
/* -------------------------------------------------------------------- */
/* Handle version. */
/* -------------------------------------------------------------------- */
if( pszVersion != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ),
CXT_Text, pszVersion );
}
/* -------------------------------------------------------------------- */
/* geometric primitive. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") != NULL )
{
CPLCreateXMLElementAndValue(
psRequest, "GeometricPrimitive",
CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") );
}
/* Add COVERAGETYPE and COVERAGEINTERPOLATIONMETHOD layer? */
return psRequest;
}
/* -------------------------------------------------------------------- */
/* Unrecognised. */
/* -------------------------------------------------------------------- */
else
WCTSEmitServiceException(
CPLSPrintf( "Unrecognised REQUEST value (%.500s).", pszRequest) );
return NULL;
}
OGRGmtLayer::OGRGmtLayer( const char * pszFilename, int bUpdateIn ) :
poSRS(NULL),
poFeatureDefn(NULL),
iNextFID(0),
bUpdate(CPL_TO_BOOL(bUpdateIn)),
// Assume header complete in readonly mode.
bHeaderComplete(CPL_TO_BOOL(!bUpdate)),
bRegionComplete(false),
nRegionOffset(0),
papszKeyedValues(NULL),
bValidFile(FALSE)
{
/* -------------------------------------------------------------------- */
/* Open file. */
/* -------------------------------------------------------------------- */
if( bUpdate )
fp = VSIFOpenL( pszFilename, "r+" );
else
fp = VSIFOpenL( pszFilename, "r" );
if( fp == NULL )
return;
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
CPLString osFieldNames;
CPLString osFieldTypes;
CPLString osGeometryType;
CPLString osRegion;
CPLString osWKT;
CPLString osProj4;
CPLString osEPSG;
vsi_l_offset nStartOfLine = VSIFTellL(fp);
while( ReadLine() && osLine[0] == '#' )
{
if( strstr( osLine, "FEATURE_DATA" ) )
{
bHeaderComplete = TRUE;
ReadLine();
break;
}
if( STARTS_WITH_CI(osLine, "# REGION_STUB ") )
nRegionOffset = nStartOfLine;
for( int iKey = 0;
papszKeyedValues != NULL && papszKeyedValues[iKey] != NULL;
iKey++ )
{
if( papszKeyedValues[iKey][0] == 'N' )
osFieldNames = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'T' )
osFieldTypes = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'G' )
osGeometryType = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'R' )
osRegion = papszKeyedValues[iKey] + 1;
if( papszKeyedValues[iKey][0] == 'J' )
{
CPLString osArg = papszKeyedValues[iKey] + 2;
if( osArg[0] == '"' && osArg[osArg.length()-1] == '"' )
{
osArg = osArg.substr(1,osArg.length()-2);
char *pszArg = CPLUnescapeString(osArg, NULL,
CPLES_BackslashQuotable);
osArg = pszArg;
CPLFree( pszArg );
}
if( papszKeyedValues[iKey][1] == 'e' )
osEPSG = osArg;
if( papszKeyedValues[iKey][1] == 'p' )
osProj4 = osArg;
if( papszKeyedValues[iKey][1] == 'w' )
osWKT = osArg;
}
}
nStartOfLine = VSIFTellL(fp);
}
/* -------------------------------------------------------------------- */
/* Handle coordinate system. */
/* -------------------------------------------------------------------- */
if( osWKT.length() )
{
char *pszWKT = (char *) osWKT.c_str();
poSRS = new OGRSpatialReference();
if( poSRS->importFromWkt(&pszWKT) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
else if( osEPSG.length() )
{
poSRS = new OGRSpatialReference();
if( poSRS->importFromEPSG( atoi(osEPSG) ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
else if( osProj4.length() )
{
poSRS = new OGRSpatialReference();
if( poSRS->importFromProj4( osProj4 ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Create the feature definition, and set the geometry type, if */
/* known. */
/* -------------------------------------------------------------------- */
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
if( osGeometryType == "POINT" )
poFeatureDefn->SetGeomType( wkbPoint );
else if( osGeometryType == "MULTIPOINT" )
poFeatureDefn->SetGeomType( wkbMultiPoint );
else if( osGeometryType == "LINESTRING" )
poFeatureDefn->SetGeomType( wkbLineString );
else if( osGeometryType == "MULTILINESTRING" )
poFeatureDefn->SetGeomType( wkbMultiLineString );
else if( osGeometryType == "POLYGON" )
poFeatureDefn->SetGeomType( wkbPolygon );
else if( osGeometryType == "MULTIPOLYGON" )
poFeatureDefn->SetGeomType( wkbMultiPolygon );
/* -------------------------------------------------------------------- */
/* Process a region line. */
/* -------------------------------------------------------------------- */
if( osRegion.length() > 0 )
{
char **papszTokens = CSLTokenizeStringComplex( osRegion.c_str(),
"/", FALSE, FALSE );
if( CSLCount(papszTokens) == 4 )
{
sRegion.MinX = CPLAtofM(papszTokens[0]);
sRegion.MaxX = CPLAtofM(papszTokens[1]);
sRegion.MinY = CPLAtofM(papszTokens[2]);
sRegion.MaxY = CPLAtofM(papszTokens[3]);
}
bRegionComplete = TRUE;
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Process fields. */
/* -------------------------------------------------------------------- */
if( osFieldNames.length() || osFieldTypes.length() )
{
char **papszFN = CSLTokenizeStringComplex( osFieldNames, "|",
TRUE, TRUE );
char **papszFT = CSLTokenizeStringComplex( osFieldTypes, "|",
TRUE, TRUE );
const int nFieldCount = MAX(CSLCount(papszFN),CSLCount(papszFT));
for( int iField = 0; iField < nFieldCount; iField++ )
{
OGRFieldDefn oField("", OFTString );
if( iField < CSLCount(papszFN) )
oField.SetName( papszFN[iField] );
else
oField.SetName( CPLString().Printf( "Field_%d", iField+1 ));
if( iField < CSLCount(papszFT) )
{
if( EQUAL(papszFT[iField],"integer") )
oField.SetType( OFTInteger );
else if( EQUAL(papszFT[iField],"double") )
oField.SetType( OFTReal );
else if( EQUAL(papszFT[iField],"datetime") )
oField.SetType( OFTDateTime );
}
poFeatureDefn->AddFieldDefn( &oField );
}
CSLDestroy( papszFN );
CSLDestroy( papszFT );
}
bValidFile = TRUE;
}
int OGRGmtLayer::ReadLine()
{
/* -------------------------------------------------------------------- */
/* Clear last line. */
/* -------------------------------------------------------------------- */
osLine.erase();
if( papszKeyedValues )
{
CSLDestroy( papszKeyedValues );
papszKeyedValues = NULL;
}
/* -------------------------------------------------------------------- */
/* Read newline. */
/* -------------------------------------------------------------------- */
const char *pszLine = CPLReadLineL( fp );
if( pszLine == NULL )
return FALSE; // end of file.
osLine = pszLine;
/* -------------------------------------------------------------------- */
/* If this is a comment line with keyed values, parse them. */
/* -------------------------------------------------------------------- */
if( osLine[0] != '#' || osLine.find_first_of('@') == std::string::npos )
return TRUE;
for( size_t i = 0; i < osLine.length(); i++ )
{
if( osLine[i] == '@' )
{
bool bInQuotes = false;
size_t iValEnd;
for( iValEnd = i+2; iValEnd < osLine.length(); iValEnd++ )
{
if( !bInQuotes && isspace((unsigned char)osLine[iValEnd]) )
break;
if( bInQuotes
&& iValEnd < osLine.length()-1
&& osLine[iValEnd] == '\\' )
{
iValEnd++;
}
else if( osLine[iValEnd] == '"' )
bInQuotes = !bInQuotes;
}
const CPLString osValue = osLine.substr(i+2,iValEnd-i-2);
// Unecape contents
char *pszUEValue = CPLUnescapeString( osValue, NULL,
CPLES_BackslashQuotable );
CPLString osKeyValue = osLine.substr(i+1,1);
osKeyValue += pszUEValue;
CPLFree( pszUEValue );
papszKeyedValues = CSLAddString( papszKeyedValues, osKeyValue );
i = iValEnd;
}
}
return TRUE;
}
