std::string FindBoostDataBaseFile()
{
const char* pszBase = "date_time_zonespec";
const char* pszExt = "csv";
const char* pszFilename;
const char* pszNinjaPath;
const char* pszNinjaSharePath;
char pszFilePath[MAX_PATH];
CPLGetExecPath(pszFilePath, MAX_PATH);
pszNinjaPath = CPLGetPath(pszFilePath);
pszNinjaSharePath = CPLProjectRelativeFilename(pszNinjaPath,
"../share/windninja");
pszFilename = CPLFormFilename(CPLGetCurrentDir(), pszBase, pszExt);
if(CPLCheckForFile((char*)pszFilename, NULL)) {
return std::string((char*)pszFilename);
}
pszFilename = CPLFormFilename(pszNinjaPath, pszBase, pszExt);
if(CPLCheckForFile((char*)pszFilename, NULL)) {
return std::string((char*)pszFilename);
}
pszFilename = CPLFormFilename(pszNinjaSharePath, pszBase, pszExt);
if(CPLCheckForFile((char*)pszFilename, NULL)) {
return std::string((char*)pszFilename);
}
return std::string();
}
/**
* GDALMDReaderOrbView()
*/
GDALMDReaderOrbView::GDALMDReaderOrbView(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderBase(pszPath, papszSiblingFiles)
{
m_osIMDSourceFilename = GDALFindAssociatedFile( pszPath, "PVL",
papszSiblingFiles, 0 );
const char* pszBaseName = CPLGetBasename(pszPath);
const char* pszDirName = CPLGetDirname(pszPath);
const char* pszRPBSourceFilename = CPLFormFilename( pszDirName,
CPLSPrintf("%s_rpc",
pszBaseName),
"txt" );
if (CPLCheckForFile((char*)pszRPBSourceFilename, papszSiblingFiles))
{
m_osRPBSourceFilename = pszRPBSourceFilename;
}
else
{
pszRPBSourceFilename = CPLFormFilename( pszDirName, CPLSPrintf("%s_RPC",
pszBaseName), "TXT" );
if (CPLCheckForFile((char*)pszRPBSourceFilename, papszSiblingFiles))
{
m_osRPBSourceFilename = pszRPBSourceFilename;
}
}
if( m_osIMDSourceFilename.size() )
CPLDebug( "MDReaderOrbView", "IMD Filename: %s",
m_osIMDSourceFilename.c_str() );
if( m_osRPBSourceFilename.size() )
CPLDebug( "MDReaderOrbView", "RPB Filename: %s",
m_osRPBSourceFilename.c_str() );
}
/**
* GDALMDReaderRapidEye()
*/
GDALMDReaderRapidEye::GDALMDReaderRapidEye(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderBase(pszPath, papszSiblingFiles)
{
const char* pszDirName = CPLGetDirname(pszPath);
const char* pszBaseName = CPLGetBasename(pszPath);
const char* pszIMDSourceFilename = CPLFormFilename( pszDirName,
CPLSPrintf("%s_metadata",
pszBaseName), "xml" );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osXMLSourceFilename = pszIMDSourceFilename;
}
else
{
pszIMDSourceFilename = CPLFormFilename( pszDirName,
CPLSPrintf("%s_METADATA",
pszBaseName), "XML" );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osXMLSourceFilename = pszIMDSourceFilename;
}
}
if(m_osXMLSourceFilename.size())
CPLDebug( "MDReaderRapidEye", "XML Filename: %s",
m_osXMLSourceFilename.c_str() );
}
CPLString GMLASConfiguration::GetBaseCacheDirectory()
{
#ifdef WIN32
const char* pszHome = CPLGetConfigOption("USERPROFILE", NULL);
#else
const char* pszHome = CPLGetConfigOption("HOME", NULL);
#endif
if( pszHome != NULL )
{
return CPLFormFilename( pszHome, ".gdal", NULL) ;
}
else
{
const char *pszDir = CPLGetConfigOption( "CPL_TMPDIR", NULL );
if( pszDir == NULL )
pszDir = CPLGetConfigOption( "TMPDIR", NULL );
if( pszDir == NULL )
pszDir = CPLGetConfigOption( "TEMP", NULL );
const char* pszUsername = CPLGetConfigOption("USERNAME", NULL);
if( pszUsername == NULL )
pszUsername = CPLGetConfigOption("USER", NULL);
if( pszDir != NULL && pszUsername != NULL )
{
return CPLFormFilename( pszDir,
CPLSPrintf(".gdal_%s", pszUsername), NULL) ;
}
}
return CPLString();
}
/**
* GDALMDReaderSpot()
*/
GDALMDReaderSpot::GDALMDReaderSpot(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderPleiades(pszPath, papszSiblingFiles)
{
const char* pszIMDSourceFilename;
const char* pszDirName = CPLGetDirname(pszPath);
if(m_osIMDSourceFilename.empty())
{
pszIMDSourceFilename = CPLFormFilename( pszDirName, "METADATA.DIM", NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
pszIMDSourceFilename = CPLFormFilename( pszDirName, "metadata.dim", NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
}
// if the file name ended on METADATA.DIM
// Linux specific
// example: R2_CAT_091028105025131_1\METADATA.DIM
if(m_osIMDSourceFilename.empty())
{
if(EQUAL(CPLGetFilename(pszPath), "IMAGERY.TIF"))
{
pszIMDSourceFilename = CPLSPrintf( "%s\\METADATA.DIM",
CPLGetPath(pszPath));
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
pszIMDSourceFilename = CPLSPrintf( "%s\\metadata.dim",
CPLGetPath(pszPath));
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
}
}
if(m_osIMDSourceFilename.size())
CPLDebug( "MDReaderSpot", "IMD Filename: %s",
m_osIMDSourceFilename.c_str() );
}
OGRErr OGRCSVDataSource::DeleteLayer( int iLayer )
{
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"Layer %d cannot be deleted.\n",
pszName, iLayer );
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;
}
char *pszFilename =
CPLStrdup(
CPLFormFilename( pszName,
papoLayers[iLayer]->GetLayerDefn()->GetName(),
"csv" ) );
char *pszFilenameCSVT =
CPLStrdup(
CPLFormFilename( pszName,
papoLayers[iLayer]->GetLayerDefn()->GetName(),
"csvt" ) );
delete papoLayers[iLayer];
while( iLayer < nLayers - 1 )
{
papoLayers[iLayer] = papoLayers[iLayer+1];
iLayer++;
}
nLayers--;
VSIUnlink( pszFilename );
CPLFree( pszFilename );
VSIUnlink( pszFilenameCSVT );
CPLFree( pszFilenameCSVT );
return OGRERR_NONE;
}
TEST(MapTests, TestCreate) {
char** options = nullptr;
options = ngsListAddNameValue(options, "DEBUG_MODE", "ON");
options = ngsListAddNameValue(options, "SETTINGS_DIR",
ngsFormFileName(ngsGetCurrentDirectory(), "tmp",
nullptr));
EXPECT_EQ(ngsInit(options), COD_SUCCESS);
ngsListFree(options);
ngs::MapStore mapStore;
char mapId = mapStore.createMap(DEFAULT_MAP_NAME, "unit test",
DEFAULT_EPSG, ngs::DEFAULT_BOUNDS);
EXPECT_GE(mapId, 0);
ngs::MapViewPtr defMap = mapStore.getMap(mapId);
ASSERT_NE(defMap, nullptr);
ngsRGBA color = defMap->backgroundColor();
EXPECT_EQ(color.R, DEFAULT_MAP_BK.R);
EXPECT_EQ(color.G, DEFAULT_MAP_BK.G);
EXPECT_EQ(color.B, DEFAULT_MAP_BK.B);
// ngmd - NextGIS map document
ngs::CatalogPtr catalog = ngs::Catalog::instance();
CPLString tmpDir = CPLFormFilename(CPLGetCurrentDir(), "tmp", nullptr);
ngs::Folder::mkDir(tmpDir);
ngs::ObjectPtr tmpDirObj = catalog->getObjectBySystemPath(tmpDir);
ASSERT_NE(tmpDirObj, nullptr);
ngs::ObjectContainer* tmpDirContainer =
ngsDynamicCast(ngs::ObjectContainer, tmpDirObj);
CPLString mapPath = CPLFormFilename(tmpDirObj->path().c_str(), "default", "ngmd");
CPLString iconsPath = CPLFormFilename(CPLGetCurrentDir(), "data", nullptr);
CPLString iconSet = CPLFormFilename(iconsPath, "tex", "png");
defMap->addIconSet("simple", iconSet, true);
ngs::MapFile mapFile(tmpDirContainer, "default.ngmd", mapPath);
EXPECT_EQ(defMap->save(&mapFile), true);
mapId = mapStore.openMap(&mapFile);
defMap = mapStore.getMap(mapId);
defMap->setBackgroundColor({1,2,3,4});
EXPECT_EQ(defMap->save(&mapFile), true);
ngs::Catalog::setInstance(nullptr);
ngsUnInit();
}
CPLErr GNMFileNetwork::CreateFeaturesLayerFromFile( const char* pszFilename, char** papszOptions )
{
CPLErr eResult = CheckLayerDriver(GNM_MD_DEFAULT_FILE_FORMAT, papszOptions);
if(CE_None != eResult)
return eResult;
eResult = FormPath(pszFilename, papszOptions);
if(CE_None != eResult)
return eResult;
const char* pszExt = m_poLayerDriver->GetMetadataItem(GDAL_DMD_EXTENSION);
CPLString osDSFileName = CPLFormFilename(m_soNetworkFullName,
GNM_SYSLAYER_FEATURES, pszExt);
m_pFeaturesDS = m_poLayerDriver->Create(osDSFileName, 0, 0, 0, GDT_Unknown,
NULL );
if( m_pFeaturesDS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined, "Creation of '%s' file failed",
osDSFileName.c_str() );
return CE_Failure;
}
return GNMGenericNetwork::CreateFeaturesLayer(m_pFeaturesDS);
}
const char *CPLGenerateTempFilename( const char *pszStem )
{
const char *pszDir = CPLGetConfigOption( "CPL_TMPDIR", NULL );
static volatile int nTempFileCounter = 0;
if( pszDir == NULL )
pszDir = CPLGetConfigOption( "TMPDIR", NULL );
if( pszDir == NULL )
pszDir = CPLGetConfigOption( "TEMP", NULL );
if( pszDir == NULL )
pszDir = ".";
CPLString osFilename;
if( pszStem == NULL )
pszStem = "";
osFilename.Printf( "%s%u_%d", pszStem,
(int) CPLGetPID(), nTempFileCounter++ );
return CPLFormFilename( pszDir, osFilename, NULL );
}
OGRLayer* OGROpenFileGDBDataSource::GetLayerByName( const char* pszName )
{
OGRLayer* poLayer;
poLayer = OGRDataSource::GetLayerByName(pszName);
if( poLayer != NULL )
return poLayer;
for(size_t i=0;i<m_apoHiddenLayers.size();i++)
{
if( EQUAL(m_apoHiddenLayers[i]->GetName(), pszName) )
return m_apoHiddenLayers[i];
}
std::map<std::string, int>::const_iterator oIter = m_osMapNameToIdx.find(pszName);
if( oIter != m_osMapNameToIdx.end() )
{
int idx = oIter->second;
const char* pszFilename = CPLFormFilename(
m_osDirName, CPLSPrintf("a%08x", idx), "gdbtable");
if( FileExists(pszFilename) )
{
poLayer = new OGROpenFileGDBLayer(
pszFilename, pszName, "", "");
m_apoHiddenLayers.push_back(poLayer);
return poLayer;
}
}
return NULL;
}
int PDSDataset::ParseCompressedImage()
{
CPLString osFileName = GetKeyword( "COMPRESSED_FILE.FILE_NAME", "" );
CleanString( osFileName );
CPLString osPath = CPLGetPath(GetDescription());
CPLString osFullFileName = CPLFormFilename( osPath, osFileName, NULL );
int iBand;
poCompressedDS = (GDALDataset*) GDALOpen( osFullFileName, GA_ReadOnly );
if( poCompressedDS == NULL )
return FALSE;
nRasterXSize = poCompressedDS->GetRasterXSize();
nRasterYSize = poCompressedDS->GetRasterYSize();
for( iBand = 0; iBand < poCompressedDS->GetRasterCount(); iBand++ )
{
SetBand( iBand+1, new PDSWrapperRasterBand( poCompressedDS->GetRasterBand( iBand+1 ) ) );
}
return TRUE;
}
static const char* BuildFullName(const char* pszTOCFilename,
const char* pszFramePath,
const char* pszFrameName)
{
char* pszPath;
if (pszFramePath[0] == '.' &&
(pszFramePath[1] == '/' ||pszFramePath[1] == '\\'))
pszPath = CPLStrdup(pszFramePath + 2);
else
pszPath = CPLStrdup(pszFramePath);
for(int i=0;pszPath[i] != '\0';i++)
{
if (pszPath[i] == '\\')
pszPath[i] = '/';
}
const char* pszName = CPLFormFilename(pszPath, pszFrameName, NULL);
CPLFree(pszPath);
pszPath = NULL;
const char* pszTOCPath = CPLGetDirname(pszTOCFilename);
const char* pszFirstSlashInName = strchr(pszName, '/');
if (pszFirstSlashInName != NULL)
{
int nFirstDirLen = pszFirstSlashInName - pszName;
if ((int)strlen(pszTOCPath) >= nFirstDirLen + 1 &&
(pszTOCPath[strlen(pszTOCPath) - (nFirstDirLen + 1)] == '/' ||
pszTOCPath[strlen(pszTOCPath) - (nFirstDirLen + 1)] == '\\') &&
strncmp(pszTOCPath + strlen(pszTOCPath) - nFirstDirLen, pszName, nFirstDirLen) == 0)
{
pszTOCPath = CPLGetDirname(pszTOCPath);
}
}
return CPLProjectRelativeFilename(pszTOCPath, pszName);
}
/**
* \brief Find a file or folder in the WindNinja data path
*
* XXX: Refactored by Kyle 20130117
*
* For example the date_time_zonespec.csv file is location in data. If
* WINDNINJA_DATA is *not* defined, try to find the file relative to the bin
* path, ie ../share/data, otherwise return WINDNINJA_DATA + filename.
*
* \param file file or folder to look for.
* \return a full path to file
*/
std::string FindDataPath(std::string file)
{
const char* pszFilename;
const char* pszNinjaPath;
const char* pszNinjaDataPath;
const char* pszCurDir;
char pszExePath[MAX_PATH];
/* Check WINDNINJA_DATA */
VSIStatBufL sStat;
pszNinjaDataPath = CPLGetConfigOption( "WINDNINJA_DATA", NULL );
if( pszNinjaDataPath != NULL )
{
pszFilename = CPLFormFilename( pszNinjaDataPath, file.c_str(), NULL );
VSIStatL( pszFilename, &sStat );
if( VSI_ISREG( sStat.st_mode ) || VSI_ISDIR( sStat.st_mode ) )
{
return std::string( pszFilename );
}
}
/* Check 'normal' installation location */
CPLGetExecPath( pszExePath, MAX_PATH );
pszNinjaPath = CPLGetPath( pszExePath );
pszNinjaDataPath = CPLProjectRelativeFilename(pszNinjaPath,
"../share/windninja");
pszFilename = CPLFormFilename( pszNinjaDataPath, file.c_str(), NULL );
VSIStatL( pszFilename, &sStat );
if( VSI_ISREG( sStat.st_mode ) || VSI_ISDIR( sStat.st_mode ) )
{
return std::string( pszFilename );
}
/* Check the current directory */
pszCurDir = CPLGetCurrentDir();
pszFilename = CPLFormFilename( pszCurDir, file.c_str(), NULL );
CPLFree( (void*)pszCurDir );
if( CPLCheckForFile( (char*)pszFilename, NULL ))
{
return std::string( pszFilename );
}
return std::string();
}
bool GMLRegistryFeatureType::Parse(const char *pszRegistryFilename,
CPLXMLNode *psNode)
{
const char *pszElementName = CPLGetXMLValue(psNode, "elementName", NULL);
const char *pszSchemaLocation =
CPLGetXMLValue(psNode, "schemaLocation", NULL);
const char *pszGFSSchemaLocation =
CPLGetXMLValue(psNode, "gfsSchemaLocation", NULL);
if( pszElementName == NULL ||
(pszSchemaLocation == NULL && pszGFSSchemaLocation == NULL) )
return false;
const char *pszElementValue = CPLGetXMLValue(psNode, "elementValue", NULL);
osElementName = pszElementName;
if( pszSchemaLocation != NULL )
{
if( !STARTS_WITH(pszSchemaLocation, "http://") &&
!STARTS_WITH(pszSchemaLocation, "https://") &&
CPLIsFilenameRelative(pszSchemaLocation) )
{
pszSchemaLocation = CPLFormFilename(
CPLGetPath(pszRegistryFilename), pszSchemaLocation, NULL );
}
osSchemaLocation = pszSchemaLocation;
}
else if( pszGFSSchemaLocation != NULL )
{
if( !STARTS_WITH(pszGFSSchemaLocation, "http://") &&
!STARTS_WITH(pszGFSSchemaLocation, "https://") &&
CPLIsFilenameRelative(pszGFSSchemaLocation) )
{
pszGFSSchemaLocation = CPLFormFilename(
CPLGetPath(pszRegistryFilename), pszGFSSchemaLocation, NULL);
}
osGFSSchemaLocation = pszGFSSchemaLocation;
}
if ( pszElementValue != NULL )
{
osElementValue = pszElementValue;
}
return true;
}
GdalTestData()
{
GDALAllRegister();
OGRRegisterAll();
fetch = NULL;
poDS = NULL;
pszFilename =
CPLFormFilename( NULL, CPLGenerateTempFilename( "GDAL_TEST" ), ".tif" );
}
/**
* GDALMDReaderLandsat()
*/
GDALMDReaderLandsat::GDALMDReaderLandsat(const char *pszPath,
char **papszSiblingFiles) : GDALMDReaderBase(pszPath, papszSiblingFiles)
{
const char* pszBaseName = CPLGetBasename(pszPath);
const char* pszDirName = CPLGetDirname(pszPath);
size_t nBaseNameLen = strlen(pszBaseName);
if( nBaseNameLen > 511 )
return;
// split file name by _B or _b
char szMetadataName[512] = {0};
size_t i;
for(i = 0; i < nBaseNameLen; i++)
{
szMetadataName[i] = pszBaseName[i];
if(STARTS_WITH_CI(pszBaseName + i, "_B") || STARTS_WITH_CI(pszBaseName + i, "_b"))
{
break;
}
}
// form metadata file name
CPLStrlcpy(szMetadataName + i, "_MTL.txt", 9);
const char* pszIMDSourceFilename = CPLFormFilename( pszDirName,
szMetadataName, NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
else
{
CPLStrlcpy(szMetadataName + i, "_MTL.TXT", 9);
pszIMDSourceFilename = CPLFormFilename( pszDirName, szMetadataName, NULL );
if (CPLCheckForFile((char*)pszIMDSourceFilename, papszSiblingFiles))
{
m_osIMDSourceFilename = pszIMDSourceFilename;
}
}
if( !m_osIMDSourceFilename.empty() )
CPLDebug( "MDReaderLandsat", "IMD Filename: %s",
m_osIMDSourceFilename.c_str() );
}
OGRErr OGRGeoconceptDriver::DeleteDataSource( const char *pszDataSource )
{
int iExt;
VSIStatBuf sStatBuf;
static const char *apszExtensions[] =
{ "gxt", "txt", "gct", "gcm", "gcr", NULL };
if( VSIStat( pszDataSource, &sStatBuf ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a file or directory.",
pszDataSource );
return OGRERR_FAILURE;
}
if( VSI_ISREG(sStatBuf.st_mode)
&& (
EQUAL(CPLGetExtension(pszDataSource),"gxt") ||
EQUAL(CPLGetExtension(pszDataSource),"txt")
) )
{
for( iExt=0; apszExtensions[iExt] != NULL; iExt++ )
{
const char *pszFile = CPLResetExtension(pszDataSource,
apszExtensions[iExt] );
if( VSIStat( pszFile, &sStatBuf ) == 0 )
VSIUnlink( pszFile );
}
}
else if( VSI_ISDIR(sStatBuf.st_mode) )
{
char **papszDirEntries = CPLReadDir( pszDataSource );
int iFile;
for( iFile = 0;
papszDirEntries != NULL && papszDirEntries[iFile] != NULL;
iFile++ )
{
if( CSLFindString( (char **) apszExtensions,
CPLGetExtension(papszDirEntries[iFile])) != -1)
{
VSIUnlink( CPLFormFilename( pszDataSource,
papszDirEntries[iFile],
NULL ) );
}
}
CSLDestroy( papszDirEntries );
VSIRmdir( pszDataSource );
}
return OGRERR_NONE;
}
bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
CPLString szDirPath = CPLGetPath(m_sPath);
CPLString szName = CPLGetBasename(m_sPath);
CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8));
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
char **papszNewFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName)));
papszNewFileList = CSLAddString(papszNewFileList, szNewPath);
if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
for( --i; i >= 0; i-- )
RenameFile( papszNewFileList[i], papszFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return false;
}
}
m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath)));
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return true;
}
bool wxGISDataset::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to move"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
CPLString szFileName = CPLGetBasename(GetUniqPath(m_sPath, szDestPath, CPLGetBasename(m_sPath)));
char** papszMovedFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewDestFileName(CPLFormFilename(szDestPath, szFileName, GetExtension(papszFileList[i], szFileName)));
papszMovedFileList = CSLAddString(papszMovedFileList, szNewDestFileName);
if(!MoveFile(szNewDestFileName, papszFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
pTrackCancel->Reset();
for( --i; i >= 0; i-- )
MoveFile( papszFileList[i], papszMovedFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return false;
}
}
m_sPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return true;
}
CPLErr GNMFileNetwork::DeleteMetadataLayer()
{
if(NULL != m_pMetadataDS)
{
const char* pszSrsFileName = CPLFormFilename(m_soNetworkFullName,
GNM_SRSFILENAME, NULL);
VSIUnlink(pszSrsFileName); // just try to delete as file may not be existed
return m_pMetadataDS->DeleteLayer(0) == OGRERR_NONE ? CE_None : CE_Failure;
}
return CE_Failure;
}
/* GetFilePath: return a relative path to a file within an XML node.
* Returns Null on failure
*/
static const char *GetFilePath(CPLXMLNode *psXMLNode, const char **pszNodeType) {
const char *pszDirectory = CPLGetXMLValue( psXMLNode, "file.location.path", "" );
const char *pszFilename = CPLGetXMLValue( psXMLNode, "file.location.filename", "" );
*pszNodeType = CPLGetXMLValue (psXMLNode, "type", " " );
if (pszDirectory == NULL || pszFilename == NULL) {
return NULL;
}
return CPLFormFilename( pszDirectory, pszFilename, "" );
}
int GMLRegistryFeatureType::Parse(const char* pszRegistryFilename, CPLXMLNode* psNode)
{
const char* pszElementName = CPLGetXMLValue(psNode, "elementName", NULL);
const char* pszElementValue = CPLGetXMLValue(psNode, "elementValue", NULL);
const char* pszSchemaLocation = CPLGetXMLValue(psNode, "schemaLocation", NULL);
const char* pszGFSSchemaLocation = CPLGetXMLValue(psNode, "gfsSchemaLocation", NULL);
if( pszElementName == NULL || (pszSchemaLocation == NULL && pszGFSSchemaLocation == NULL) )
return FALSE;
osElementName = pszElementName;
if( pszSchemaLocation != NULL )
{
if( strncmp(pszSchemaLocation, "http://", 7) != 0 &&
strncmp(pszSchemaLocation, "https://", 8) != 0 &&
CPLIsFilenameRelative(pszSchemaLocation ) )
{
pszSchemaLocation = CPLFormFilename(
CPLGetPath(pszRegistryFilename), pszSchemaLocation, NULL );
}
osSchemaLocation = pszSchemaLocation;
}
else if( pszGFSSchemaLocation != NULL )
{
if( strncmp(pszGFSSchemaLocation, "http://", 7) != 0 &&
strncmp(pszGFSSchemaLocation, "https://", 8) != 0 &&
CPLIsFilenameRelative(pszGFSSchemaLocation ) )
{
pszGFSSchemaLocation = CPLFormFilename(
CPLGetPath(pszRegistryFilename), pszGFSSchemaLocation, NULL );
}
osGFSSchemaLocation = pszGFSSchemaLocation;
}
if ( pszElementValue != NULL )
{
osElementValue = pszElementValue;
}
return TRUE;
}
void wxGxOpenFileGDB::FillMetadata(bool bForce)
{
if (m_bIsMetadataFilled && !bForce)
return;
m_bIsMetadataFilled = true;
wxGISDataset* pDSet = GetDatasetFast();
if (NULL == pDSet)
{
return;
}
VSIStatBufL BufL;
wxULongLong nSize(0);
wxDateTime dt(1,wxDateTime::Jan, 1900);
int ret = VSIStatL(m_sPath, &BufL);
if (ret == 0)
{
//nSize += BufL.st_size;
//dt = wxDateTime(BufL.st_mtime);
if (VSI_ISDIR(BufL.st_mode))
{
char **papszItems = CPLReadDir(wxGxObjectContainer::GetPath());
if (papszItems && CSLCount(papszItems) > 0)
{
for (int i = 0; papszItems[i] != NULL; ++i)
{
if (wxGISEQUAL(papszItems[i], ".") || wxGISEQUAL(papszItems[i], ".."))
continue;
CPLString szFullPathFrom = CPLFormFilename(wxGxObjectContainer::GetPath(), papszItems[i], NULL);
ret = VSIStatL(szFullPathFrom, &BufL);
if (ret == 0)
{
nSize += BufL.st_size;
wxDateTime dtt(BufL.st_mtime);
if (dtt > dt)
dt = dtt;
}
}
}
CSLDestroy(papszItems);
}
}
m_nSize = nSize;
m_dtMod = dt;
wsDELETE(pDSet);
}
static CPLString getRscFilename( GDALOpenInfo *poOpenInfo )
{
CPLString osRscFilename;
char **papszSiblingFiles = poOpenInfo->GetSiblingFiles();
if ( papszSiblingFiles == NULL )
{
osRscFilename = CPLFormFilename( NULL, poOpenInfo->pszFilename,
"rsc" );
VSIStatBufL psRscStatBuf;
if ( VSIStatL( osRscFilename, &psRscStatBuf ) != 0 )
{
osRscFilename = "";
}
}
else
{
/* ------------------------------------------------------------ */
/* We need to tear apart the filename to form a .rsc */
/* filename. */
/* ------------------------------------------------------------ */
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetFilename( poOpenInfo->pszFilename );
int iFile = CSLFindString( papszSiblingFiles,
CPLFormFilename( NULL, osName, "rsc" ) );
if( iFile >= 0 )
{
osRscFilename = CPLFormFilename( osPath,
papszSiblingFiles[iFile],
NULL );
}
}
return osRscFilename;
}
CPLErr GNMFileNetwork::StoreNetworkSrs()
{
const char* pszSrsFileName = CPLFormFilename(m_soNetworkFullName,
GNM_SRSFILENAME, NULL);
VSILFILE *fpSrsPrj = VSIFOpenL(pszSrsFileName, "w");
if (fpSrsPrj != NULL)
{
if(VSIFWriteL(m_soSRS, (int)m_soSRS.size(), 1, fpSrsPrj) != 1)
{
CPLError( CE_Failure, CPLE_AppDefined, "Write SRS failed, disk full?" );
VSIFCloseL(fpSrsPrj);
return CE_Failure;
}
}
VSIFCloseL(fpSrsPrj);
return CE_None;
}
CPLErr GNMFileNetwork::FormPath(const char *pszFilename, char **papszOptions)
{
if(m_soNetworkFullName.empty())
{
const char* pszNetworkName = CSLFetchNameValue(papszOptions, GNM_MD_NAME);
if(NULL == pszNetworkName)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network name should be present" );
return CE_Failure;
}
m_soNetworkFullName = CPLFormFilename(pszFilename, pszNetworkName, NULL);
CPLDebug( "GNM", "Network name: %s", m_soNetworkFullName.c_str() );
}
return CE_None;
}
CPLErr GNMFileNetwork::LoadNetworkSrs()
{
const char* pszSrsFileName = CPLFormFilename(m_soNetworkFullName,
GNM_SRSFILENAME, NULL);
char** papszLines = CSLLoad(pszSrsFileName);
if ( NULL == papszLines )
{
CPLError( CE_Failure, CPLE_AppDefined, "Loading of '%s' layer failed",
GNM_SYSLAYER_META );
return CE_Failure;
}
m_soSRS = papszLines[0];
CSLDestroy( papszLines );
return CE_None;
}
void OGROpenFileGDBDataSource::AddLayer( const CPLString& osName,
int nInterestTable,
int& nCandidateLayers,
int& nLayersSDC,
const CPLString& osDefinition,
const CPLString& osDocumentation,
const char* pszGeomName,
OGRwkbGeometryType eGeomType )
{
std::map<std::string, int>::const_iterator oIter =
m_osMapNameToIdx.find(osName);
int idx = 0;
if( oIter != m_osMapNameToIdx.end() )
idx = oIter->second;
if( idx > 0 && (nInterestTable < 0 || nInterestTable == idx) )
{
const char* pszFilename = CPLFormFilename(
m_osDirName, CPLSPrintf("a%08x", idx), "gdbtable");
if( FileExists(pszFilename) )
{
nCandidateLayers ++;
if( m_papszFiles != NULL )
{
const char* pszSDC = CPLResetExtension(pszFilename, "gdbtable.sdc");
if( FileExists(pszSDC) )
{
nLayersSDC ++;
CPLError(CE_Warning, CPLE_AppDefined,
"%s layer has a %s file whose format is unhandled",
osName.c_str(), pszSDC);
return;
}
}
m_apoLayers.push_back(
new OGROpenFileGDBLayer(pszFilename,
osName,
osDefinition,
osDocumentation,
pszGeomName, eGeomType));
}
}
}
void GMLASConfiguration::Finalize()
{
if( m_bAllowXSDCache && m_osXSDCacheDirectory.empty() )
{
m_osXSDCacheDirectory = GetBaseCacheDirectory();
if( m_osXSDCacheDirectory.empty() )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Could not determine a directory for GMLAS XSD cache");
}
else
{
m_osXSDCacheDirectory = CPLFormFilename( m_osXSDCacheDirectory,
"gmlas_xsd_cache", NULL) ;
CPLDebug("GMLAS", "XSD cache directory: %s",
m_osXSDCacheDirectory.c_str());
}
}
}
int S57ClassRegistrar::FindFile( const char *pszTarget,
const char *pszDirectory,
int bReportErr,
VSILFILE **pfp )
{
const char *pszFilename;
if( pszDirectory == NULL )
{
pszFilename = CPLFindFile( "s57", pszTarget );
if( pszFilename == NULL )
pszFilename = pszTarget;
}
else
{
pszFilename = CPLFormFilename( pszDirectory, pszTarget, NULL );
}
*pfp = VSIFOpenL( pszFilename, "rb" );
#ifdef S57_BUILTIN_CLASSES
if( *pfp == NULL )
{
if( EQUAL(pszTarget, "s57objectclasses.csv") )
papszNextLine = gpapszS57Classes;
else
papszNextLine = gpapszS57attributes;
}
#else
if( *pfp == NULL )
{
if( bReportErr )
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n",
pszFilename );
return FALSE;
}
#endif
return TRUE;
}
