void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
CPLString osExt = CPLGetExtension(pszDestFilename);
if (osExt.size())
{
GDALDriverH hThisDrv = GDALGetDriverByName(pszDriverName);
if( hThisDrv != NULL && DoesDriverHandleExtension(hThisDrv, osExt) )
return;
int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for(int i=0;i<nDriverCount;i++)
{
GDALDriverH hDriver = GDALGetDriver(i);
if( hDriver != hThisDrv && DoesDriverHandleExtension(hDriver, osExt) )
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
}
if (osConflictingDriverList.size())
{
fprintf(stderr,
"Warning: The target file has a '%s' extension, which is normally used by the %s driver%s,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
osExt.c_str(),
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
}
int OGRDXFWriterLayer::WriteValue( int nCode, int nValue )
{
CPLString osLinePair;
osLinePair.Printf( "%3d\n%d\n", nCode, nValue );
return VSIFWriteL( osLinePair.c_str(),
1, osLinePair.size(), fp ) == osLinePair.size();
}
/*
* ExecuteSQL()
*/
OGRLayer *OGRNGWDataset::ExecuteSQL( const char *pszStatement,
OGRGeometry *poSpatialFilter, const char *pszDialect )
{
// Clean statement string.
CPLString osStatement(pszStatement);
osStatement = osStatement.Trim().replaceAll(" ", " ");
if( STARTS_WITH_CI(osStatement.c_str(), "DELLAYER:") )
{
CPLString osLayerName = osStatement.substr(9);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete layer with name %s.", osLayerName.c_str());
for( int iLayer = 0; iLayer < nLayers; ++iLayer )
{
if( EQUAL(papoLayers[iLayer]->GetName(), osLayerName.c_str() ) )
{
DeleteLayer( iLayer );
break;
}
}
return nullptr;
}
if( STARTS_WITH_CI(osStatement.c_str(), "DELETE FROM") )
{
// Get layer name from pszStatement DELETE FROM layer;.
CPLString osLayerName = osStatement.substr(12);
if( osLayerName.endsWith(";") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 1);
osLayerName.Trim();
}
CPLDebug("NGW", "Delete features from layer with name %s.", osLayerName.c_str());
OGRNGWLayer *poLayer = static_cast<OGRNGWLayer*>(GetLayerByName(osLayerName));
if( poLayer )
{
poLayer->DeleteAllFeatures();
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Unknown layer : %s",
osLayerName.c_str());
}
return nullptr;
}
return GDALDataset::ExecuteSQL(pszStatement, poSpatialFilter, pszDialect);
}
void CheckExtensionConsistency(const char* pszDestFilename,
const char* pszDriverName)
{
char* pszDestExtension = CPLStrdup(CPLGetExtension(pszDestFilename));
if (pszDestExtension[0] != '\0')
{
int nDriverCount = GDALGetDriverCount();
CPLString osConflictingDriverList;
for(int i=0;i<nDriverCount;i++)
{
GDALDriverH hDriver = GDALGetDriver(i);
const char* pszDriverExtensions =
GDALGetMetadataItem( hDriver, GDAL_DMD_EXTENSIONS, NULL );
if( pszDriverExtensions )
{
char** papszTokens = CSLTokenizeString( pszDriverExtensions );
for(int j=0; papszTokens[j]; j++)
{
const char* pszDriverExtension = papszTokens[j];
if (EQUAL(pszDestExtension, pszDriverExtension))
{
if (GDALGetDriverByName(pszDriverName) != hDriver)
{
if (osConflictingDriverList.size())
osConflictingDriverList += ", ";
osConflictingDriverList += GDALGetDriverShortName(hDriver);
}
else
{
/* If the request driver allows the used extension, then */
/* just stop iterating now */
osConflictingDriverList = "";
break;
}
}
}
CSLDestroy(papszTokens);
}
}
if (osConflictingDriverList.size())
{
fprintf(stderr,
"Warning: The target file has a '%s' extension, which is normally used by the %s driver%s,\n"
"but the requested output driver is %s. Is it really what you want ?\n",
pszDestExtension,
osConflictingDriverList.c_str(),
strchr(osConflictingDriverList.c_str(), ',') ? "s" : "",
pszDriverName);
}
}
CPLFree(pszDestExtension);
}
CPLString OGRCSVDataSource::GetRealExtension(CPLString osFilename)
{
CPLString osExt = CPLGetExtension(osFilename);
if( STARTS_WITH(osFilename, "/vsigzip/") && EQUAL(osExt, "gz") )
{
if( osFilename.size() > 7
&& EQUAL(osFilename + osFilename.size() - 7, ".csv.gz") )
osExt = "csv";
else if( osFilename.size() > 7
&& EQUAL(osFilename + osFilename.size() - 7, ".tsv.gz") )
osExt = "tsv";
}
return osExt;
}
static bool IsValidXPath(const CPLString& osXPath )
{
// Check that the XPath syntax belongs to the subset we
// understand
bool bOK = !osXPath.empty();
for(size_t i = 0; i < osXPath.size(); ++i )
{
const char chCur = osXPath[i];
if( chCur == '/' )
{
// OK
}
else if( chCur == '@' &&
(i == 0 || osXPath[i-1] == '/') &&
i < osXPath.size()-1 &&
isalpha( static_cast<int>(osXPath[i+1]) ) )
{
// OK
}
else if( chCur == '_' ||
isalpha( static_cast<int>(chCur) ) )
{
// OK
}
else if( isdigit( static_cast<int>(chCur) ) &&
i > 0 &&
(isalnum( static_cast<int>(osXPath[i-1]) ) ||
osXPath[i-1] == '_') )
{
// OK
}
else if( chCur == ':' &&
i > 0 &&
(isalnum( static_cast<int>(osXPath[i-1]) ) ||
osXPath[i-1] == '_') &&
i < osXPath.size()-1 &&
isalpha( static_cast<int>(osXPath[i+1]) ) )
{
// OK
}
else
{
bOK = false;
break;
}
}
return bOK;
}
CPLString swq_expr_node::QuoteIfNecessary( const CPLString &osExpr,
char chQuote )
{
if( osExpr[0] == '_' )
return Quote(osExpr, chQuote);
if( osExpr == "*" )
return osExpr;
for( int i = 0; i < static_cast<int>(osExpr.size()); i++ )
{
char ch = osExpr[i];
if( (!(isalnum(static_cast<int>(ch)) || ch == '_')) || ch == '.' )
{
return Quote(osExpr, chQuote);
}
}
if( swq_is_reserved_keyword(osExpr) )
{
return Quote(osExpr, chQuote);
}
return osExpr;
}
int OGRSQLiteSelectLayer::TestCapability( const char * pszCap )
{
if (EQUAL(pszCap,OLCFastSpatialFilter))
{
if (osSQLCurrent != osSQLBase)
return TRUE;
size_t i = 0;
OGRSQLiteLayer* poBaseLayer = GetBaseLayer(i);
if (poBaseLayer == NULL)
{
CPLDebug("SQLITE", "Cannot find base layer");
return FALSE;
}
OGRPolygon oFakePoly;
const char* pszWKT = "POLYGON((0 0,0 1,1 1,1 0,0 0))";
oFakePoly.importFromWkt((char**) &pszWKT);
CPLString osSpatialWhere = poBaseLayer->GetSpatialWhere(&oFakePoly);
return osSpatialWhere.size() != 0;
}
else
return OGRSQLiteLayer::TestCapability( pszCap );
}
void GDALGMLJP2Expr::ReportError( const char* pszOriStr,
const char* pszStr,
const char* pszIntroMessage )
{
size_t nDist = static_cast<size_t>(pszStr - pszOriStr);
if( nDist > 40 )
nDist = 40;
CPLString osErrMsg(pszIntroMessage);
CPLString osInvalidExpr = CPLString(pszStr - nDist).substr(0, nDist + 20);
for( int i = static_cast<int>(nDist) - 1; i >= 0; --i )
{
if( osInvalidExpr[i] == '\n' )
{
osInvalidExpr = osInvalidExpr.substr(i+1);
nDist -= i + 1;
break;
}
}
for( size_t i = nDist; i < osInvalidExpr.size(); ++i )
{
if( osInvalidExpr[i] == '\n' )
{
osInvalidExpr.resize(i);
break;
}
}
osErrMsg += osInvalidExpr;
osErrMsg += "\n";
for( size_t i = 0; i < nDist; ++i )
osErrMsg += " ";
osErrMsg += "^";
CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrMsg.c_str());
}
CPLString wxGISDataset::FixPathSeparator(CPLString &szPath)
{
for(size_t i = 0; i < szPath.size(); ++i)
if(szPath[i] == '/')
szPath[i] = '\\';
return szPath;
}
OGRErr OGRSQLiteTableLayer::ResetStatement()
{
int rc;
CPLString osSQL;
ClearStatement();
iNextShapeId = 0;
osSQL.Printf( "SELECT _rowid_, * FROM '%s' %s",
pszEscapedTableName,
osWHERE.c_str() );
rc = sqlite3_prepare( poDS->GetDB(), osSQL, osSQL.size(),
&hStmt, NULL );
if( rc == SQLITE_OK )
{
return OGRERR_NONE;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"In ResetStatement(): sqlite3_prepare(%s):\n %s",
osSQL.c_str(), sqlite3_errmsg(poDS->GetDB()) );
hStmt = NULL;
return OGRERR_FAILURE;
}
}
CPLString GetWorldFilePath(const CPLString &soPath)
{
//1. thirst and last char from ext and third char set w (e.g. jpw)
CPLString sExt = CPLGetExtension(soPath);
CPLString sNewExt;
sNewExt += sExt[0];
sNewExt += sExt[sExt.size() - 1];
sNewExt += 'w';
CPLString szPath = (char*)CPLResetExtension(soPath, sNewExt);
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//4. add wx to ext
sNewExt += 'x';
szPath = (char*)CPLResetExtension(soPath, sNewExt);
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//2. wld
szPath = (char*)CPLResetExtension(soPath, "wld");
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//3. add w to ext
szPath = soPath + CPLString("w");
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
return CPLString();
}
CPLString OGRAmigoCloudResultLayer::GetSRS_SQL(const char* pszGeomCol)
{
CPLString osSQL;
CPLString osLimitedSQL;
size_t nPos = osBaseSQL.ifind(" LIMIT ");
if( nPos != std::string::npos )
{
osLimitedSQL = osBaseSQL;
size_t nSize = osLimitedSQL.size();
for(size_t i = nPos + strlen(" LIMIT "); i < nSize; i++)
{
if( osLimitedSQL[i] == ' ' && osLimitedSQL[i-1] == '0')
{
osLimitedSQL[i-1] = '1';
break;
}
osLimitedSQL[i] = '0';
}
}
else
osLimitedSQL.Printf("%s LIMIT 1", osBaseSQL.c_str());
/* Assuming that the SRID of the first non-NULL geometry applies */
/* to geometries of all rows. */
osSQL.Printf("SELECT srid, srtext FROM spatial_ref_sys WHERE srid IN "
"(SELECT ST_SRID(%s) FROM (%s) ogr_subselect)",
OGRAMIGOCLOUDEscapeIdentifier(pszGeomCol).c_str(),
osLimitedSQL.c_str());
return osSQL;
}
void OGRSQLiteViewLayer::BuildWhere()
{
osWHERE = "";
CPLString osSpatialWHERE = GetSpatialWhere(m_poFilterGeom);
if (osSpatialWHERE.size() != 0)
{
osWHERE = "WHERE ";
osWHERE += osSpatialWHERE;
}
if( osQuery.size() > 0 )
{
if( osWHERE.size() == 0 )
{
osWHERE = "WHERE ";
osWHERE += osQuery;
}
else
{
osWHERE += " AND (";
osWHERE += osQuery;
osWHERE += ")";
}
}
}
// This is a performance critical function, especially on geosciml schemas,
// and we make careful to not do any string copy or other memory allocation
// in it.
bool GMLASXPathMatcher::MatchesRefXPath(
const CPLString& osXPath,
const std::vector<XPathComponent>& oRefXPath) const
{
size_t iPos = 0;
size_t iIdxInRef = 0;
bool bDirectChild = oRefXPath[0].m_bDirectChild;
while( iPos < osXPath.size() && iIdxInRef < oRefXPath.size() )
{
bDirectChild = oRefXPath[iIdxInRef].m_bDirectChild;
size_t iPosNextSlash = osXPath.find('/', iPos);
bool bNodeMatch;
if( iPosNextSlash == std::string::npos )
{
bNodeMatch = osXPath.compare(iPos, std::string::npos,
oRefXPath[iIdxInRef].m_osValue) == 0;
}
else
{
bNodeMatch = osXPath.compare(iPos, iPosNextSlash - iPos,
oRefXPath[iIdxInRef].m_osValue) == 0;
}
if( !bNodeMatch )
{
if( bDirectChild )
return false;
if( iPosNextSlash == std::string::npos )
return false;
iPos = iPosNextSlash + 1;
continue;
}
if( iPosNextSlash == std::string::npos )
iPos = osXPath.size();
else
iPos = iPosNextSlash + 1;
iIdxInRef ++;
bDirectChild = true;
}
return (!bDirectChild || iPos == osXPath.size()) &&
iIdxInRef == oRefXPath.size();
}
void createkmlliststyle (
KmlFactory * poKmlFactory,
const char* pszBaseName,
ContainerPtr poKmlLayerContainer,
DocumentPtr poKmlDocument,
const CPLString& osListStyleType,
const CPLString& osListStyleIconHref)
{
if( osListStyleType.size() || osListStyleIconHref.size() )
{
StylePtr poKmlStyle = poKmlFactory->CreateStyle ( );
const char* pszStyleName = CPLSPrintf("%s_liststyle", OGRLIBKMLGetSanitizedNCName(pszBaseName).c_str());
poKmlStyle->set_id ( pszStyleName );
ListStylePtr poKmlListStyle = poKmlFactory->CreateListStyle ( );
poKmlStyle->set_liststyle ( poKmlListStyle );
if( osListStyleType.size() )
{
if( EQUAL(osListStyleType, "check") )
poKmlListStyle->set_listitemtype( kmldom::LISTITEMTYPE_CHECK );
else if( EQUAL(osListStyleType, "radioFolder") )
poKmlListStyle->set_listitemtype( kmldom::LISTITEMTYPE_RADIOFOLDER );
else if( EQUAL(osListStyleType, "checkOffOnly") )
poKmlListStyle->set_listitemtype( kmldom::LISTITEMTYPE_CHECKOFFONLY );
else if( EQUAL(osListStyleType, "checkHideChildren") )
poKmlListStyle->set_listitemtype( kmldom::LISTITEMTYPE_CHECKHIDECHILDREN );
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"Invalid value for list style type: %s. Defaulting to Check",
osListStyleType.c_str());
poKmlListStyle->set_listitemtype( kmldom::LISTITEMTYPE_CHECK );
}
}
if( osListStyleIconHref.size() )
{
ItemIconPtr poItemIcon = poKmlFactory->CreateItemIcon ( );
poItemIcon->set_href( osListStyleIconHref.c_str() );
poKmlListStyle->add_itemicon(poItemIcon);
}
poKmlDocument->add_styleselector ( poKmlStyle );
poKmlLayerContainer->set_styleurl( CPLSPrintf("#%s", pszStyleName) );
}
}
int OGRDXFWriterLayer::WriteValue( int nCode, const char *pszValue )
{
CPLString osLinePair;
osLinePair.Printf( "%3d\n", nCode );
if( strlen(pszValue) < 255 )
osLinePair += pszValue;
else
osLinePair.append( pszValue, 255 );
osLinePair += "\n";
return VSIFWriteL( osLinePair.c_str(),
1, osLinePair.size(), fp ) == osLinePair.size();
}
static CPLString GetSignature(const CPLString& osStringToSign,
const CPLString& osSecretAccessKey )
{
/* -------------------------------------------------------------------- */
/* Compute signature. */
/* -------------------------------------------------------------------- */
GByte abySignature[CPL_SHA1_HASH_SIZE] = {};
CPL_HMAC_SHA1( osSecretAccessKey.c_str(), osSecretAccessKey.size(),
osStringToSign, osStringToSign.size(),
abySignature);
char* pszBase64 = CPLBase64Encode( sizeof(abySignature), abySignature );
CPLString osSignature(pszBase64);
CPLFree(pszBase64);
return osSignature;
}
void OGREDIGEOLayer::AddFieldDefn(const CPLString& osName,
OGRFieldType eType,
const CPLString& osRID)
{
if (osRID.size() != 0)
mapAttributeToIndex[osRID] = poFeatureDefn->GetFieldCount();
OGRFieldDefn oFieldDefn(osName, eType);
poFeatureDefn->AddFieldDefn(&oFieldDefn);
}
OGRGeoJSONWriteLayer::~OGRGeoJSONWriteLayer()
{
VSILFILE* fp = poDS_->GetOutputFile();
VSIFPrintfL( fp, "\n]" );
if( bWriteFC_BBOX && sEnvelopeLayer.IsInit() )
{
CPLString osBBOX = "[ ";
if( bRFC7946_ )
{
osBBOX += CPLSPrintf("%.*f, ", nCoordPrecision_, sEnvelopeLayer.MinX);
osBBOX += CPLSPrintf("%.*f, ", nCoordPrecision_, sEnvelopeLayer.MinY);
if( bBBOX3D )
osBBOX += CPLSPrintf("%.*f, ", nCoordPrecision_, sEnvelopeLayer.MinZ);
osBBOX += CPLSPrintf("%.*f, ", nCoordPrecision_, sEnvelopeLayer.MaxX);
osBBOX += CPLSPrintf("%.*f", nCoordPrecision_, sEnvelopeLayer.MaxY);
if( bBBOX3D )
osBBOX += CPLSPrintf(", %.*f", nCoordPrecision_, sEnvelopeLayer.MaxZ);
}
else
{
osBBOX += CPLSPrintf("%.15g, ", sEnvelopeLayer.MinX);
osBBOX += CPLSPrintf("%.15g, ", sEnvelopeLayer.MinY);
if( bBBOX3D )
osBBOX += CPLSPrintf("%.15g, ", sEnvelopeLayer.MinZ);
osBBOX += CPLSPrintf("%.15g, ", sEnvelopeLayer.MaxX);
osBBOX += CPLSPrintf("%.15g", sEnvelopeLayer.MaxY);
if( bBBOX3D )
osBBOX += CPLSPrintf(", %.15g", sEnvelopeLayer.MaxZ);
}
osBBOX += " ]";
if( poDS_->GetFpOutputIsSeekable() &&
osBBOX.size() + 9 < OGRGeoJSONDataSource::SPACE_FOR_BBOX )
{
VSIFSeekL(fp, poDS_->GetBBOXInsertLocation(), SEEK_SET);
VSIFPrintfL( fp, "\"bbox\": %s,", osBBOX.c_str() );
VSIFSeekL(fp, 0, SEEK_END);
}
else
{
VSIFPrintfL( fp, ",\n\"bbox\": %s", osBBOX.c_str() );
}
}
VSIFPrintfL( fp, "\n}\n" );
if( nullptr != poFeatureDefn_ )
{
poFeatureDefn_->Release();
}
delete poCT_;
}
CPLString OGRPGDumpLayer::BuildCopyFields(int bSetFID)
{
int i = 0;
int nFIDIndex = -1;
CPLString osFieldList;
for( i = 0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
if( osFieldList.size() > 0 )
osFieldList += ", ";
OGRGeomFieldDefn* poGFldDefn = poFeatureDefn->GetGeomFieldDefn(i);
osFieldList += OGRPGDumpEscapeColumnName(poGFldDefn->GetNameRef());
}
bFIDColumnInCopyFields = (pszFIDColumn != NULL && bSetFID);
if( bFIDColumnInCopyFields )
{
if( osFieldList.size() > 0 )
osFieldList += ", ";
nFIDIndex = poFeatureDefn->GetFieldIndex( pszFIDColumn );
osFieldList += OGRPGDumpEscapeColumnName(pszFIDColumn);
}
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
if (i == nFIDIndex)
continue;
const char *pszName = poFeatureDefn->GetFieldDefn(i)->GetNameRef();
if( osFieldList.size() > 0 )
osFieldList += ", ";
osFieldList += OGRPGDumpEscapeColumnName(pszName);
}
return osFieldList;
}
void VSIMemFilesystemHandler::NormalizePath( CPLString &oPath )
{
int i, nSize = oPath.size();
for( i = 0; i < nSize; i++ )
{
if( oPath[i] == '\\' )
oPath[i] = '/';
}
}
void OGRPDSDataSource::CleanString( CPLString &osInput )
{
if( ( osInput.size() < 2 ) ||
((osInput.at(0) != '"' || osInput.at(osInput.size()-1) != '"' ) &&
( osInput.at(0) != '\'' || osInput.at(osInput.size()-1) != '\'')) )
return;
char *pszWrk = CPLStrdup(osInput.c_str() + 1);
pszWrk[strlen(pszWrk)-1] = '\0';
for( int i = 0; pszWrk[i] != '\0'; i++ )
{
if( pszWrk[i] == ' ' )
pszWrk[i] = '_';
}
osInput = pszWrk;
CPLFree( pszWrk );
}
OGRFeature *OGRSQLiteViewLayer::GetFeature( long nFeatureId )
{
if (HasLayerDefnError())
return NULL;
/* -------------------------------------------------------------------- */
/* If we don't have an explicit FID column, just read through */
/* the result set iteratively to find our target. */
/* -------------------------------------------------------------------- */
if( pszFIDColumn == NULL )
return OGRSQLiteLayer::GetFeature( nFeatureId );
/* -------------------------------------------------------------------- */
/* Setup explicit query statement to fetch the record we want. */
/* -------------------------------------------------------------------- */
CPLString osSQL;
int rc;
ClearStatement();
iNextShapeId = nFeatureId;
osSQL.Printf( "SELECT \"%s\", * FROM '%s' WHERE \"%s\" = %d",
OGRSQLiteEscapeName(pszFIDColumn).c_str(),
pszEscapedTableName,
OGRSQLiteEscapeName(pszFIDColumn).c_str(),
(int) nFeatureId );
CPLDebug( "OGR_SQLITE", "exec(%s)", osSQL.c_str() );
rc = sqlite3_prepare( poDS->GetDB(), osSQL, osSQL.size(),
&hStmt, NULL );
if( rc != SQLITE_OK )
{
CPLError( CE_Failure, CPLE_AppDefined,
"In GetFeature(): sqlite3_prepare(%s):\n %s",
osSQL.c_str(), sqlite3_errmsg(poDS->GetDB()) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Get the feature if possible. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = NULL;
poFeature = GetNextRawFeature();
ResetReading();
return poFeature;
}
/**
* CPLStrip()
*/
CPLString CPLStrip(const CPLString& sString, const char cChar)
{
if(sString.empty())
return sString;
size_t dCopyFrom = 0;
size_t dCopyCount = sString.size();
if (sString[0] == cChar)
{
dCopyFrom++;
dCopyCount--;
}
if (sString[sString.size() - 1] == cChar)
dCopyCount--;
if(dCopyCount == 0)
return CPLString();
return sString.substr(dCopyFrom, dCopyCount);
}
OGRErr OGRAmigoCloudDataSource::DeleteLayer(int iLayer)
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if( iLayer < 0 || iLayer >= nLayers )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %d not in legal range of 0 to %d.",
iLayer, nLayers-1 );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Blow away our OGR structures related to the layer. This is */
/* pretty dangerous if anything has a reference to this layer! */
/* -------------------------------------------------------------------- */
CPLString osDatasetId = papoLayers[iLayer]->GetDatasetId();
CPLDebug( "AMIGOCLOUD", "DeleteLayer(%s)", osDatasetId.c_str() );
int bDeferredCreation = papoLayers[iLayer]->GetDeferredCreation();
papoLayers[iLayer]->CancelDeferredCreation();
delete papoLayers[iLayer];
memmove( papoLayers + iLayer, papoLayers + iLayer + 1,
sizeof(void *) * (nLayers - iLayer - 1) );
nLayers--;
if (osDatasetId.size() == 0)
return OGRERR_NONE;
if( !bDeferredCreation )
{
std::stringstream url;
url << std::string(GetAPIURL()) << "/users/0/projects/" + std::string(GetProjetcId()) + "/datasets/"+ osDatasetId.c_str();
json_object *poObj = RunDELETE(url.str().c_str());
// json_object* poObj = RunSQL(osSQL);
if( poObj == NULL )
return OGRERR_FAILURE;
json_object_put(poObj);
}
return OGRERR_NONE;
}
OGRErr OGRCARTODataSource::DeleteLayer(int iLayer)
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
if( iLayer < 0 || iLayer >= nLayers )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %d not in legal range of 0 to %d.",
iLayer, nLayers-1 );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Blow away our OGR structures related to the layer. This is */
/* pretty dangerous if anything has a reference to this layer! */
/* -------------------------------------------------------------------- */
CPLString osLayerName = papoLayers[iLayer]->GetLayerDefn()->GetName();
CPLDebug( "CARTO", "DeleteLayer(%s)", osLayerName.c_str() );
int bDeferredCreation = papoLayers[iLayer]->GetDeferredCreation();
papoLayers[iLayer]->CancelDeferredCreation();
delete papoLayers[iLayer];
memmove( papoLayers + iLayer, papoLayers + iLayer + 1,
sizeof(void *) * (nLayers - iLayer - 1) );
nLayers--;
if (osLayerName.size() == 0)
return OGRERR_NONE;
if( !bDeferredCreation )
{
CPLString osSQL;
osSQL.Printf("DROP TABLE %s",
OGRCARTOEscapeIdentifier(osLayerName).c_str());
json_object* poObj = RunSQL(osSQL);
if( poObj == NULL )
return OGRERR_FAILURE;
json_object_put(poObj);
}
return OGRERR_NONE;
}
OGRErr OGRPGDumpLayer::CreateField( OGRFieldDefn *poFieldIn,
int bApproxOK )
{
CPLString osCommand;
CPLString osFieldType;
OGRFieldDefn oField( poFieldIn );
/* -------------------------------------------------------------------- */
/* Do we want to "launder" the column names into Postgres */
/* friendly format? */
/* -------------------------------------------------------------------- */
if( bLaunderColumnNames )
{
char *pszSafeName = poDS->LaunderName( oField.GetNameRef() );
oField.SetName( pszSafeName );
CPLFree( pszSafeName );
if( EQUAL(oField.GetNameRef(),"oid") )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Renaming field 'oid' to 'oid_' to avoid conflict with internal oid field." );
oField.SetName( "oid_" );
}
}
const char* pszOverrideType = CSLFetchNameValue(papszOverrideColumnTypes, oField.GetNameRef());
if( pszOverrideType != NULL )
osFieldType = pszOverrideType;
else
{
osFieldType = OGRPGTableLayerGetType(oField, bPreservePrecision, bApproxOK);
if (osFieldType.size() == 0)
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Create the new field. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "ALTER TABLE %s ADD COLUMN %s %s",
pszSqlTableName, OGRPGDumpEscapeColumnName(oField.GetNameRef()).c_str(),
osFieldType.c_str() );
if (bCreateTable)
poDS->Log(osCommand);
poFeatureDefn->AddFieldDefn( &oField );
return OGRERR_NONE;
}
int OGRDXFWriterDS::FixupHANDSEED( VSILFILE *fp )
{
/* -------------------------------------------------------------------- */
/* What is a good next handle seed? Scan existing values. */
/* -------------------------------------------------------------------- */
unsigned int nHighestHandle = 0;
std::set<CPLString>::iterator it;
for( it = aosUsedEntities.begin(); it != aosUsedEntities.end(); it++ )
{
unsigned int nHandle;
if( sscanf( (*it).c_str(), "%x", &nHandle ) == 1 )
{
if( nHandle > nHighestHandle )
nHighestHandle = nHandle;
}
}
/* -------------------------------------------------------------------- */
/* Read the existing handseed value, replace it, and write back. */
/* -------------------------------------------------------------------- */
char szWorkBuf[30];
int i = 0;
if( nHANDSEEDOffset == 0 )
return FALSE;
VSIFSeekL( fp, nHANDSEEDOffset, SEEK_SET );
VSIFReadL( szWorkBuf, 1, sizeof(szWorkBuf), fp );
while( szWorkBuf[i] != '\n' )
i++;
i++;
if( szWorkBuf[i] == '\r' )
i++;
CPLString osNewValue;
osNewValue.Printf( "%08X", nHighestHandle + 1 );
strncpy( szWorkBuf + i, osNewValue.c_str(), osNewValue.size() );
VSIFSeekL( fp, nHANDSEEDOffset, SEEK_SET );
VSIFWriteL( szWorkBuf, 1, sizeof(szWorkBuf), fp );
return TRUE;
}
CPLString OGRLIBKMLLayer::LaunderFieldNames(CPLString osName)
{
CPLString osLaunderedName;
for(int i=0;i<(int)osName.size();i++)
{
char ch = osName[i];
if ((ch >= '0' && ch <= '9') ||
(ch >= 'a' && ch <= 'z') ||
(ch >= 'A' && ch <= 'Z') ||
(ch == '_'))
osLaunderedName += ch;
else
osLaunderedName += "_";
}
return osLaunderedName;
}