static
int VSI_SHP_Flush( SAFile file )
{
OGRSHPDBFFile* pFile = (OGRSHPDBFFile*) file;
return VSIFFlushL( pFile->fp );
}
OGRErr OGRSelafinLayer::ISetFeature(OGRFeature *poFeature) {
OGRGeometry *poGeom=poFeature->GetGeometryRef();
if (poGeom==0) return OGRERR_FAILURE;
if (eType==POINTS) {
// If it's a point layer, it's the "easy" case: we change the coordinates and attributes of the feature and update the file
if (poGeom->getGeometryType()!=wkbPoint) {
CPLError( CE_Failure, CPLE_AppDefined, "The new feature should be of the same Point geometry as the existing ones in the layer.");
return OGRERR_FAILURE;
}
OGRPoint *poPoint=(OGRPoint*)poGeom;
GIntBig nFID=poFeature->GetFID();
poHeader->paadfCoords[0][nFID]=poPoint->getX();
poHeader->paadfCoords[1][nFID]=poPoint->getY();
CPLDebug("Selafin","SetFeature(" CPL_FRMT_GIB ",%f,%f)",nFID,poHeader->paadfCoords[0][nFID],poHeader->paadfCoords[1][nFID]);
if (VSIFSeekL(poHeader->fp,88+16+40*poHeader->nVar+48+((poHeader->panStartDate!=0)?32:0)+24+(poHeader->nElements*poHeader->nPointsPerElement+2)*4+(poHeader->nPoints+2)*4+4+nFID*4,SEEK_SET)!=0) return OGRERR_FAILURE;
CPLDebug("Selafin","Write_float(" CPL_FRMT_GUIB ",%f)",VSIFTellL(poHeader->fp),poHeader->paadfCoords[0][nFID]-poHeader->adfOrigin[0]);
if (Selafin::write_float(poHeader->fp,poHeader->paadfCoords[0][nFID]-poHeader->adfOrigin[0])==0) return OGRERR_FAILURE;
if (VSIFSeekL(poHeader->fp,88+16+40*poHeader->nVar+48+((poHeader->panStartDate!=0)?32:0)+24+(poHeader->nElements*poHeader->nPointsPerElement+2)*4+(poHeader->nPoints+2)*4+(poHeader->nPoints+2)*4+4+nFID*4,SEEK_SET)!=0) return OGRERR_FAILURE;
CPLDebug("Selafin","Write_float(" CPL_FRMT_GUIB ",%f)",VSIFTellL(poHeader->fp),poHeader->paadfCoords[1][nFID]-poHeader->adfOrigin[1]);
if (Selafin::write_float(poHeader->fp,poHeader->paadfCoords[1][nFID]-poHeader->adfOrigin[1])==0) return OGRERR_FAILURE;
for (long i=0;i<poHeader->nVar;++i) {
double nData=poFeature->GetFieldAsDouble(i);
if (VSIFSeekL(poHeader->fp,poHeader->getPosition(nStepNumber,(long)nFID,i),SEEK_SET)!=0) return OGRERR_FAILURE;
if (Selafin::write_float(poHeader->fp,nData)==0) return OGRERR_FAILURE;
}
} else {
// Else, we have a layer of polygonal elements. Here we consider that the vertices are moved when we change the geometry (which will also lead to a modification in the corresponding point layer). The attributes table can't be changed, because attributes are calculated from those of the vertices.
// First we check that the new feature is a polygon with the right number of vertices
if (poGeom->getGeometryType()!=wkbPolygon) {
CPLError( CE_Failure, CPLE_AppDefined, "The new feature should be of the same Polygon geometry as the existing ones in the layer.");
return OGRERR_FAILURE;
}
OGRLinearRing *poLinearRing=((OGRPolygon*)poGeom)->getExteriorRing();
if (poLinearRing->getNumPoints()!=poHeader->nPointsPerElement+1) {
CPLError( CE_Failure, CPLE_AppDefined, "The new feature should have the same number of vertices %li as the existing ones in the layer.",poHeader->nPointsPerElement);
return OGRERR_FAILURE;
}
CPLError(CE_Warning,CPLE_AppDefined,"The attributes of elements layer in Selafin files can't be updated.");
CPLDebug("Selafin","SetFeature(" CPL_FRMT_GIB ",%f,%f,%f,%f,%f,%f)",poFeature->GetFID(),poLinearRing->getX(0),poLinearRing->getY(0),poLinearRing->getX(1),poLinearRing->getY(1),poLinearRing->getX(2),poLinearRing->getY(2)); //!< This is not safe as we can't be sure there are at least three vertices in the linear ring, but we can assume that for a debug mode
long nFID=poFeature->GetFID();
// Now we change the coordinates of points in the layer based on the vertices of the new polygon. We don't look at the order of points and we assume that it is the same as in the original layer.
for (long i=0;i<poHeader->nPointsPerElement;++i) {
long nPointId=poHeader->panConnectivity[nFID*poHeader->nPointsPerElement+i]-1;
poHeader->paadfCoords[0][nPointId]=poLinearRing->getX(i);
poHeader->paadfCoords[1][nPointId]=poLinearRing->getY(i);
if (VSIFSeekL(poHeader->fp,88+16+40*poHeader->nVar+48+((poHeader->panStartDate!=0)?32:0)+24+(poHeader->nElements*poHeader->nPointsPerElement+2)*4+(poHeader->nPoints+2)*4+4+nPointId*4,SEEK_SET)!=0) return OGRERR_FAILURE;
CPLDebug("Selafin","Write_float(" CPL_FRMT_GUIB ",%f)",VSIFTellL(poHeader->fp),poHeader->paadfCoords[0][nPointId]-poHeader->adfOrigin[0]);
if (Selafin::write_float(poHeader->fp,poHeader->paadfCoords[0][nPointId]-poHeader->adfOrigin[0])==0) return OGRERR_FAILURE;
if (VSIFSeekL(poHeader->fp,88+16+40*poHeader->nVar+48+((poHeader->panStartDate!=0)?32:0)+24+(poHeader->nElements*poHeader->nPointsPerElement+2)*4+(poHeader->nPoints+2)*4+(poHeader->nPoints+2)*4+4+nPointId*4,SEEK_SET)!=0) return OGRERR_FAILURE;
CPLDebug("Selafin","Write_float(" CPL_FRMT_GUIB ",%f)",VSIFTellL(poHeader->fp),poHeader->paadfCoords[1][nPointId]-poHeader->adfOrigin[1]);
if (Selafin::write_float(poHeader->fp,poHeader->paadfCoords[1][nPointId]-poHeader->adfOrigin[1])==0) return OGRERR_FAILURE;
}
}
VSIFFlushL(poHeader->fp);
return OGRERR_NONE;
}
void MoveOverwrite(VSILFILE *fpDest,VSILFILE *fpSource) {
VSIRewindL(fpSource);
VSIRewindL(fpDest);
VSIFTruncateL(fpDest,0);
char anBuf[0x10000];
while (!VSIFEofL(fpSource)) {
size_t nSize=VSIFReadL(anBuf,1,0x10000,fpSource);
size_t nLeft=nSize;
while (nLeft>0) nLeft-=VSIFWriteL(anBuf+nSize-nLeft,1,nLeft,fpDest);
}
VSIFCloseL(fpSource);
VSIFFlushL(fpDest);
}
term_destination (j_compress_ptr cinfo)
{
my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
/* Write any data remaining in the buffer */
if (datacount > 0) {
if (VSIFWriteL(dest->buffer, 1, datacount, dest->outfile) != datacount)
ERREXIT(cinfo, JERR_FILE_WRITE);
}
if( VSIFFlushL(dest->outfile) != 0 )
ERREXIT(cinfo, JERR_FILE_WRITE);
}
term_destination (j_compress_ptr cinfo)
{
my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
/* Write any data remaining in the buffer */
if (datacount > 0) {
if (VSIFWriteL(dest->buffer, 1, datacount, dest->outfile) != datacount)
{
cinfo->err->msg_code = JERR_FILE_WRITE;
cinfo->err->error_exit((j_common_ptr) (cinfo));
}
}
if( VSIFFlushL(dest->outfile) != 0 )
{
cinfo->err->msg_code = JERR_FILE_WRITE;
cinfo->err->error_exit((j_common_ptr) (cinfo));
}
}
OGRErr OGRSelafinLayer::AlterFieldDefn(int iField,
OGRFieldDefn *poNewFieldDefn,
CPL_UNUSED int nFlags) {
CPLDebug("Selafin","AlterFieldDefn(%i,%s,%s)",iField,poNewFieldDefn->GetNameRef(),OGRFieldDefn::GetFieldTypeName(poNewFieldDefn->GetType()));
// Test if the field type is legal (only double precision values are allowed)
if (poNewFieldDefn->GetType()!=OFTReal) {
CPLError(CE_Failure,CPLE_AppDefined,"Attempt to update field with type %s, but this is not supported for Selafin files (only double precision fields are allowed).",poNewFieldDefn->GetFieldTypeName(poNewFieldDefn->GetType()));
return OGRERR_FAILURE;
}
// Since the field type can't change, only the field name is changed. We change it in the header
CPLFree(poHeader->papszVariables[iField]);
poHeader->papszVariables[iField]=(char*)VSIMalloc2(sizeof(char),33);
strncpy(poHeader->papszVariables[iField],poNewFieldDefn->GetNameRef(),32);
poHeader->papszVariables[iField][32]=0;
// And we update the file
if (VSIFSeekL(poHeader->fp,88+16+40*iField,SEEK_SET)!=0) return OGRERR_FAILURE;
if (Selafin::write_string(poHeader->fp,poHeader->papszVariables[iField],32)==0) return OGRERR_FAILURE;
VSIFFlushL(poHeader->fp);
return OGRERR_NONE;
}
CPLErr RawRasterBand::FlushCache()
{
CPLErr eErr;
eErr = GDALRasterBand::FlushCache();
if( eErr != CE_None )
return eErr;
// If we have unflushed raw, flush it to disk now.
if ( bDirty )
{
if( bIsVSIL )
VSIFFlushL( fpRawL );
else
VSIFFlush( fpRaw );
bDirty = FALSE;
}
return CE_None;
}
OGRLayer *OGRSelafinDataSource::ICreateLayer( const char *pszLayerName, OGRSpatialReference *poSpatialRefP, OGRwkbGeometryType eGType, char ** papszOptions ) {
CPLDebug("Selafin","CreateLayer(%s,%s)",pszLayerName,(eGType==wkbPoint)?"wkbPoint":"wkbPolygon");
// Verify we are in update mode.
if (!bUpdate) {
CPLError( CE_Failure, CPLE_NoWriteAccess, "Data source %s opened read-only.\n" "New layer %s cannot be created.\n", pszName, pszLayerName );
return NULL;
}
// Check that new layer is a point or polygon layer
if (eGType!=wkbPoint) {
CPLError( CE_Failure, CPLE_NoWriteAccess, "Selafin format can only handle %s layers whereas input is %s\n.", OGRGeometryTypeToName(wkbPoint),OGRGeometryTypeToName(eGType));
return NULL;
}
// Parse options
double dfDate;
const char *pszTemp=CSLFetchNameValue(papszOptions,"DATE");
if (pszTemp!=NULL) dfDate=CPLAtof(pszTemp); else dfDate=0.0;
// Set the SRS of the datasource if this is the first layer
if (nLayers==0 && poSpatialRefP!=NULL) {
poSpatialRef=poSpatialRefP;
poSpatialRef->Reference();
const char* szEpsg=poSpatialRef->GetAttrValue("GEOGCS|AUTHORITY",1);
int nEpsg=0;
if (szEpsg!=NULL) nEpsg=(int)strtol(szEpsg,NULL,10);
if (nEpsg==0) {
CPLError(CE_Warning,CPLE_AppDefined,"Could not find EPSG code for SRS. The SRS won't be saved in the datasource.");
} else {
poHeader->nEpsg=nEpsg;
}
}
// Create the new layer in the Selafin file by adding a "time step" at the end
// Beware, as the new layer shares the same header, it automatically contains the same number of features and fields as the existing ones. This may not be intuitive for the user.
if (VSIFSeekL(poHeader->fp,0,SEEK_END)!=0) return NULL;
if (Selafin::write_integer(poHeader->fp,4)==0 ||
Selafin::write_float(poHeader->fp,dfDate)==0 ||
Selafin::write_integer(poHeader->fp,4)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
return NULL;
}
double *pdfValues=NULL;
if (poHeader->nPoints>0)
{
pdfValues=(double*)VSI_MALLOC2_VERBOSE(sizeof(double),poHeader->nPoints);
if( pdfValues == NULL )
return NULL;
}
for (int i=0;i<poHeader->nVar;++i) {
if (Selafin::write_floatarray(poHeader->fp,pdfValues,poHeader->nPoints)==0) {
CPLError( CE_Failure, CPLE_FileIO, "Could not write to Selafin file %s.\n",pszName);
CPLFree(pdfValues);
return NULL;
}
}
CPLFree(pdfValues);
VSIFFlushL(poHeader->fp);
poHeader->nSteps++;
// Create two layers as usual, one for points and one for elements
nLayers+=2;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * nLayers);
CPLString szName=pszLayerName;
CPLString szNewLayerName=szName+"_p";
papoLayers[nLayers-2] = new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,poHeader->nSteps-1,POINTS);
szNewLayerName=szName+"_e";
papoLayers[nLayers-1] = new OGRSelafinLayer( szNewLayerName, bUpdate, poSpatialRef, poHeader,poHeader->nSteps-1,ELEMENTS);
return papoLayers[nLayers-2];
}
/**********************************************************************
* TABRawBinBlock::CommitToFile()
*
* Commit the current state of the binary block to the file to which
* it has been previously attached.
*
* Derived classes may want to (optionally) reimplement this method if
* they need to do special processing before committing the block to disk.
*
* For files created with bHardBlockSize=TRUE, a complete block of
* the specified size is always written, otherwise only the number of
* used bytes in the block will be written to disk.
*
* Returns 0 if successful or -1 if an error happened, in which case
* CPLError() will have been called.
**********************************************************************/
int TABRawBinBlock::CommitToFile()
{
int nStatus = 0;
if (m_fp == NULL || m_nBlockSize <= 0 || m_pabyBuf == NULL ||
m_nFileOffset < 0)
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"TABRawBinBlock::CommitToFile(): Block has not been initialized yet!");
return -1;
}
/*----------------------------------------------------------------
* If block has not been modified, then just return... nothing to do.
*---------------------------------------------------------------*/
if (!m_bModified)
return 0;
/*----------------------------------------------------------------
* Move the output file pointer to the right position...
*---------------------------------------------------------------*/
if (VSIFSeekL(m_fp, m_nFileOffset, SEEK_SET) != 0)
{
/*------------------------------------------------------------
* Moving pointer failed... we may need to pad with zeros if
* block destination is beyond current end of file.
*-----------------------------------------------------------*/
int nCurPos = (int)VSIFTellL(m_fp);
if (nCurPos < m_nFileOffset &&
VSIFSeekL(m_fp, 0L, SEEK_END) == 0 &&
(nCurPos = (int)VSIFTellL(m_fp)) < m_nFileOffset)
{
const GByte cZero = 0;
while(nCurPos < m_nFileOffset && nStatus == 0)
{
if (VSIFWriteL(&cZero, 1, 1, m_fp) != 1)
{
CPLError(CE_Failure, CPLE_FileIO,
"Failed writing 1 byte at offset %d.", nCurPos);
nStatus = -1;
break;
}
nCurPos++;
}
}
if (nCurPos != m_nFileOffset)
nStatus = -1; // Error message will follow below
}
/*----------------------------------------------------------------
* At this point we are ready to write to the file.
*
* If m_bHardBlockSize==FALSE, then we do not write a complete block;
* we write only the part of the block that was used.
*---------------------------------------------------------------*/
int numBytesToWrite = m_bHardBlockSize?m_nBlockSize:m_nSizeUsed;
/*CPLDebug("MITAB", "Committing to offset %d", m_nFileOffset);*/
if (nStatus != 0 ||
VSIFWriteL(m_pabyBuf,sizeof(GByte),
numBytesToWrite, m_fp) != (size_t)numBytesToWrite )
{
CPLError(CE_Failure, CPLE_FileIO,
"Failed writing %d bytes at offset %d.",
numBytesToWrite, m_nFileOffset);
return -1;
}
if( m_nFileOffset + numBytesToWrite > m_nFileSize )
{
m_nFileSize = m_nFileOffset + numBytesToWrite;
}
VSIFFlushL(m_fp);
m_bModified = FALSE;
return 0;
}
