CPLErr GDALWMSCache::Write(const char *key, const CPLString &file_name) {
CPLString cache_file(KeyToCacheFile(key));
// printf("GDALWMSCache::Write(%s, %s) -> %s\n", key, file_name.c_str());
if (CPLCopyFile(cache_file.c_str(), file_name.c_str()) != CE_None) {
MakeDirs(cache_file.c_str());
CPLCopyFile(cache_file.c_str(), file_name.c_str());
}
return CE_None;
}
int OGRGeneralCmdLineProcessor( int nArgc, char ***ppapszArgv, int nOptions )
{
char **papszReturn = NULL;
int iArg;
char **papszArgv = *ppapszArgv;
(void) nOptions;
/* -------------------------------------------------------------------- */
/* Preserve the program name. */
/* -------------------------------------------------------------------- */
papszReturn = CSLAddString( papszReturn, papszArgv[0] );
/* ==================================================================== */
/* Loop over all arguments. */
/* ==================================================================== */
for( iArg = 1; iArg < nArgc; iArg++ )
{
/* -------------------------------------------------------------------- */
/* --version */
/* -------------------------------------------------------------------- */
if( EQUAL(papszArgv[iArg],"--version") )
{
printf( "%s\n", GDALVersionInfo( "--version" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --license */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--license") )
{
printf( "%s\n", GDALVersionInfo( "LICENSE" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --config */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--config") )
{
if( iArg + 2 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--config option given without a key and value argument." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( papszArgv[iArg+1], papszArgv[iArg+2] );
iArg += 2;
}
/* -------------------------------------------------------------------- */
/* --mempreload */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--mempreload") )
{
int i;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload option given without directory path.");
CSLDestroy( papszReturn );
return -1;
}
char **papszFiles = CPLReadDir( papszArgv[iArg+1] );
if( CSLCount(papszFiles) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload given invalid or empty directory.");
CSLDestroy( papszReturn );
return -1;
}
for( i = 0; papszFiles[i] != NULL; i++ )
{
CPLString osOldPath, osNewPath;
if( EQUAL(papszFiles[i],".") || EQUAL(papszFiles[i],"..") )
continue;
osOldPath = CPLFormFilename( papszArgv[iArg+1],
papszFiles[i], NULL );
osNewPath.Printf( "/vsimem/%s", papszFiles[i] );
CPLDebug( "VSI", "Preloading %s to %s.",
osOldPath.c_str(), osNewPath.c_str() );
if( CPLCopyFile( osNewPath, osOldPath ) != 0 )
return -1;
}
CSLDestroy( papszFiles );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --debug */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--debug") )
{
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--debug option given without debug level." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( "CPL_DEBUG", papszArgv[iArg+1] );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --optfile */
/* */
/* Annoyingly the options inserted by --optfile will *not* be */
/* processed properly if they are general options. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--optfile") )
{
const char *pszLine;
FILE *fpOptFile;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--optfile option given without filename." );
CSLDestroy( papszReturn );
return -1;
}
fpOptFile = VSIFOpen( papszArgv[iArg+1], "rb" );
if( fpOptFile == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open optfile '%s'.\n%s",
papszArgv[iArg+1], VSIStrerror( errno ) );
CSLDestroy( papszReturn );
return -1;
}
while( (pszLine = CPLReadLine( fpOptFile )) != NULL )
{
char **papszTokens;
int i;
if( pszLine[0] == '#' || strlen(pszLine) == 0 )
continue;
papszTokens = CSLTokenizeString( pszLine );
for( i = 0; papszTokens != NULL && papszTokens[i] != NULL; i++)
papszReturn = CSLAddString( papszReturn, papszTokens[i] );
CSLDestroy( papszTokens );
}
VSIFClose( fpOptFile );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --formats */
/* -------------------------------------------------------------------- */
#ifdef OGR_ENABLED
else if( EQUAL(papszArgv[iArg], "--formats") )
{
int iDr;
printf( "Supported Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
CSLDestroy( papszReturn );
return 0;
}
#endif /* OGR_ENABLED */
/* -------------------------------------------------------------------- */
/* --locale */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--locale") && iArg < nArgc-1 )
{
setlocale( LC_ALL, papszArgv[++iArg] );
}
/* -------------------------------------------------------------------- */
/* --pause - "hit enter" pause useful to connect a debugger. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--pause") )
{
char szLine[81];
printf( "Hit <ENTER> to continue.\n" );
fgets( szLine, sizeof(szLine), stdin );
}
/* -------------------------------------------------------------------- */
/* --help-general */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--help-general") )
{
printf( "Generic GDAL/OGR utility command options:\n" );
printf( " --version: report version of GDAL/OGR in use.\n" );
printf( " --license: report GDAL/OGR license info.\n" );
#ifdef OGR_ENABLED
printf( " --formats: report all configured format drivers.\n" );
#endif /* OGR_ENABLED */
printf( " --optfile filename: expand an option file into the argument list.\n" );
printf( " --config key value: set system configuration option.\n" );
printf( " --debug [on/off/value]: set debug level.\n" );
printf( " --help-general: report detailed help on general options.\n" );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* carry through unrecognised options. */
/* -------------------------------------------------------------------- */
else
{
papszReturn = CSLAddString( papszReturn, papszArgv[iArg] );
}
}
*ppapszArgv = papszReturn;
return CSLCount( *ppapszArgv );
}
OGRErr FGdbDriver::StartTransaction(OGRDataSource*& poDSInOut, int& bOutHasReopenedDS)
{
CPLMutexHolderOptionalLockD(hMutex);
bOutHasReopenedDS = FALSE;
OGRMutexedDataSource* poMutexedDS = (OGRMutexedDataSource*)poDSInOut;
FGdbDataSource* poDS = (FGdbDataSource* )poMutexedDS->GetBaseDataSource();
if( !poDS->GetUpdate() )
return OGRERR_FAILURE;
FGdbDatabaseConnection* pConnection = poDS->GetConnection();
if( pConnection->GetRefCount() != 1 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot start transaction as database is opened in another connection");
return OGRERR_FAILURE;
}
if( pConnection->IsLocked() )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Transaction is already in progress");
return OGRERR_FAILURE;
}
bOutHasReopenedDS = TRUE;
CPLString osName(poMutexedDS->GetName());
CPLString osNameOri(osName);
if( osName[osName.size()-1] == '/' || osName[osName.size()-1] == '\\' )
osName.resize(osName.size()-1);
#ifndef WIN32
int bPerLayerCopyingForTransaction = poDS->HasPerLayerCopyingForTransaction();
#endif
pConnection->m_nRefCount ++;
delete poDSInOut;
poDSInOut = NULL;
poMutexedDS = NULL;
poDS = NULL;
pConnection->CloseGeodatabase();
CPLString osEditedName(osName);
osEditedName += ".ogredited";
CPLPushErrorHandler(CPLQuietErrorHandler);
CPL_IGNORE_RET_VAL(CPLUnlinkTree(osEditedName));
CPLPopErrorHandler();
OGRErr eErr = OGRERR_NONE;
CPLString osDatabaseToReopen;
#ifndef WIN32
if( bPerLayerCopyingForTransaction )
{
int bError = FALSE;
if( VSIMkdir( osEditedName, 0755 ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot create directory '%s'.",
osEditedName.c_str() );
bError = TRUE;
}
// Only copy a0000000X.Y files with X >= 1 && X <= 8, gdb and timestamps
// and symlink others
char** papszFiles = VSIReadDir(osName);
for(char** papszIter = papszFiles; !bError && *papszIter; ++papszIter)
{
if( strcmp(*papszIter, ".") == 0 || strcmp(*papszIter, "..") == 0 )
continue;
if( ((*papszIter)[0] == 'a' && atoi((*papszIter)+1) >= 1 &&
atoi((*papszIter)+1) <= 8) || EQUAL(*papszIter, "gdb") ||
EQUAL(*papszIter, "timestamps") )
{
if( CPLCopyFile(CPLFormFilename(osEditedName, *papszIter, NULL),
CPLFormFilename(osName, *papszIter, NULL)) != 0 )
{
bError = TRUE;
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot copy %s", *papszIter);
}
}
else
{
CPLString osSourceFile;
if( CPLIsFilenameRelative(osName) )
osSourceFile = CPLFormFilename(CPLSPrintf("../%s", CPLGetFilename(osName.c_str())), *papszIter, NULL);
else
osSourceFile = osName;
if( EQUAL(CPLGetConfigOption("FGDB_SIMUL_FAIL", ""), "CASE1") ||
CPLSymlink( osSourceFile,
CPLFormFilename(osEditedName.c_str(), *papszIter, NULL),
NULL ) != 0 )
{
bError = TRUE;
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot symlink %s", *papszIter);
}
}
}
CSLDestroy(papszFiles);
if( bError )
{
eErr = OGRERR_FAILURE;
osDatabaseToReopen = osName;
}
else
osDatabaseToReopen = osEditedName;
}
else
#endif
{
if( EQUAL(CPLGetConfigOption("FGDB_SIMUL_FAIL", ""), "CASE1") ||
CPLCopyTree( osEditedName, osName ) != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot backup geodatabase");
eErr = OGRERR_FAILURE;
osDatabaseToReopen = osName;
}
else
osDatabaseToReopen = osEditedName;
}
pConnection->m_pGeodatabase = new Geodatabase;
long hr = ::OpenGeodatabase(StringToWString(osDatabaseToReopen), *(pConnection->m_pGeodatabase));
if( EQUAL(CPLGetConfigOption("FGDB_SIMUL_FAIL", ""), "CASE2") || FAILED(hr))
{
delete pConnection->m_pGeodatabase;
pConnection->m_pGeodatabase = NULL;
Release(osName);
GDBErr(hr, CPLSPrintf("Failed to open %s. Dataset should be closed",
osDatabaseToReopen.c_str()));
return OGRERR_FAILURE;
}
FGdbDataSource* pDS = new FGdbDataSource(this, pConnection);
pDS->Open(osDatabaseToReopen, TRUE, osNameOri);
#ifndef WIN32
if( eErr == OGRERR_NONE && bPerLayerCopyingForTransaction )
{
pDS->SetPerLayerCopyingForTransaction(bPerLayerCopyingForTransaction);
pDS->SetSymlinkFlagOnAllLayers();
}
#endif
poDSInOut = new OGRMutexedDataSource(pDS, TRUE, hMutex, TRUE);
if( eErr == OGRERR_NONE )
pConnection->SetLocked(TRUE);
return eErr;
}
