void HFAEntry::SetPosition()
{
/* -------------------------------------------------------------------- */
/* Establish the location of this entry, and it's data. */
/* -------------------------------------------------------------------- */
if( nFilePos == 0 )
{
nFilePos = HFAAllocateSpace( psHFA,
psHFA->nEntryHeaderLength
+ nDataSize );
if( nDataSize > 0 )
nDataPos = nFilePos + psHFA->nEntryHeaderLength;
}
/* -------------------------------------------------------------------- */
/* Force all children to set their position. */
/* -------------------------------------------------------------------- */
for( HFAEntry *poThisChild = poChild;
poThisChild != NULL;
poThisChild = poThisChild->poNext )
{
poThisChild->SetPosition();
}
}
CPLErr HFABand::GetPCT( int * pnColors,
double **ppadfRed,
double **ppadfGreen,
double **ppadfBlue )
{
*pnColors = 0;
*ppadfRed = NULL;
*ppadfGreen = NULL;
*ppadfBlue = NULL;
/* -------------------------------------------------------------------- */
/* If we haven't already tried to load the colors, do so now. */
/* -------------------------------------------------------------------- */
if( nPCTColors == -1 )
{
HFAEntry *poColumnEntry;
int i, iColumn;
nPCTColors = 0;
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Red");
if( poColumnEntry == NULL )
return( CE_Failure );
nPCTColors = poColumnEntry->GetIntField( "numRows" );
for( iColumn = 0; iColumn < 3; iColumn++ )
{
apadfPCT[iColumn] = (double *)CPLMalloc(sizeof(double)*nPCTColors);
if( iColumn == 0 )
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Red");
else if( iColumn == 1 )
poColumnEntry= poNode->GetNamedChild("Descriptor_Table.Green");
else if( iColumn == 2 )
poColumnEntry = poNode->GetNamedChild("Descriptor_Table.Blue");
VSIFSeek( psInfo->fp, poColumnEntry->GetIntField("columnDataPtr"),
SEEK_SET );
VSIFRead( apadfPCT[iColumn], sizeof(double), nPCTColors,
psInfo->fp);
for( i = 0; i < nPCTColors; i++ )
HFAStandard( 8, apadfPCT[iColumn] + i );
}
}
/* -------------------------------------------------------------------- */
/* Return the values. */
/* -------------------------------------------------------------------- */
if( nPCTColors == 0 )
return( CE_Failure );
*pnColors = nPCTColors;
*ppadfRed = apadfPCT[0];
*ppadfGreen = apadfPCT[1];
*ppadfBlue = apadfPCT[2];
return( CE_None );
}
std::vector<HFAEntry*> HFAEntry::FindChildren( const char *pszName,
const char *pszType )
{
std::vector<HFAEntry*> apoChildren;
HFAEntry *poEntry;
if( this == NULL )
return apoChildren;
for( poEntry = GetChild(); poEntry != NULL; poEntry = poEntry->GetNext() )
{
std::vector<HFAEntry*> apoEntryChildren;
size_t i;
if( (pszName == NULL || EQUAL(poEntry->GetName(),pszName))
&& (pszType == NULL || EQUAL(poEntry->GetType(),pszType)) )
apoChildren.push_back( poEntry );
apoEntryChildren = poEntry->FindChildren( pszName, pszType );
for( i = 0; i < apoEntryChildren.size(); i++ )
apoChildren.push_back( apoEntryChildren[i] );
}
return apoChildren;
}
const Eprj_Datum *HFAGetDatum( HFAHandle hHFA )
{
HFAEntry *poMIEntry;
Eprj_Datum *psDatum;
int i;
if( hHFA->nBands < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we already have it? */
/* -------------------------------------------------------------------- */
if( hHFA->pDatum != NULL )
return( (Eprj_Datum *) hHFA->pDatum );
/* -------------------------------------------------------------------- */
/* Get the HFA node. */
/* -------------------------------------------------------------------- */
poMIEntry = hHFA->papoBand[0]->poNode->GetNamedChild( "Projection.Datum" );
if( poMIEntry == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Allocate the structure. */
/* -------------------------------------------------------------------- */
psDatum = (Eprj_Datum *) CPLCalloc(sizeof(Eprj_Datum),1);
/* -------------------------------------------------------------------- */
/* Fetch the fields. */
/* -------------------------------------------------------------------- */
psDatum->datumname = CPLStrdup(poMIEntry->GetStringField("datumname"));
psDatum->type = (Eprj_DatumType) poMIEntry->GetIntField("type");
for( i = 0; i < 7; i++ )
{
char szFieldName[30];
sprintf( szFieldName, "params[%d]", i );
psDatum->params[i] = poMIEntry->GetDoubleField(szFieldName);
}
psDatum->gridname = CPLStrdup(poMIEntry->GetStringField("gridname"));
hHFA->pDatum = (void *) psDatum;
return psDatum;
}
const Eprj_MapInfo *HFAGetMapInfo( HFAHandle hHFA )
{
HFAEntry *poMIEntry;
Eprj_MapInfo *psMapInfo;
if( hHFA->nBands < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we already have it? */
/* -------------------------------------------------------------------- */
if( hHFA->pMapInfo != NULL )
return( (Eprj_MapInfo *) hHFA->pMapInfo );
/* -------------------------------------------------------------------- */
/* Get the HFA node. */
/* -------------------------------------------------------------------- */
poMIEntry = hHFA->papoBand[0]->poNode->GetNamedChild( "Map_Info" );
if( poMIEntry == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Allocate the structure. */
/* -------------------------------------------------------------------- */
psMapInfo = (Eprj_MapInfo *) CPLCalloc(sizeof(Eprj_MapInfo),1);
/* -------------------------------------------------------------------- */
/* Fetch the fields. */
/* -------------------------------------------------------------------- */
psMapInfo->proName = CPLStrdup(poMIEntry->GetStringField("proName"));
psMapInfo->upperLeftCenter.x =
poMIEntry->GetDoubleField("upperLeftCenter.x");
psMapInfo->upperLeftCenter.y =
poMIEntry->GetDoubleField("upperLeftCenter.y");
psMapInfo->lowerRightCenter.x =
poMIEntry->GetDoubleField("lowerRightCenter.x");
psMapInfo->lowerRightCenter.y =
poMIEntry->GetDoubleField("lowerRightCenter.y");
psMapInfo->pixelSize.width =
poMIEntry->GetDoubleField("pixelSize.width");
psMapInfo->pixelSize.height =
poMIEntry->GetDoubleField("pixelSize.height");
psMapInfo->units = CPLStrdup(poMIEntry->GetStringField("units"));
hHFA->pMapInfo = (void *) psMapInfo;
return psMapInfo;
}
CPLErr HFABand::LoadBlockInfo()
{
int iBlock;
HFAEntry *poDMS;
if( panBlockStart != NULL )
return( CE_None );
poDMS = poNode->GetNamedChild( "RasterDMS" );
if( poDMS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Can't find RasterDMS field in Eimg_Layer with block list.\n");
return CE_Failure;
}
panBlockStart = (int *) CPLMalloc(sizeof(int) * nBlocks);
panBlockSize = (int *) CPLMalloc(sizeof(int) * nBlocks);
panBlockFlag = (int *) CPLMalloc(sizeof(int) * nBlocks);
for( iBlock = 0; iBlock < nBlocks; iBlock++ )
{
char szVarName[64];
int nLogvalid, nCompressType;
sprintf( szVarName, "blockinfo[%d].offset", iBlock );
panBlockStart[iBlock] = poDMS->GetIntField( szVarName );
sprintf( szVarName, "blockinfo[%d].size", iBlock );
panBlockSize[iBlock] = poDMS->GetIntField( szVarName );
sprintf( szVarName, "blockinfo[%d].logvalid", iBlock );
nLogvalid = poDMS->GetIntField( szVarName );
sprintf( szVarName, "blockinfo[%d].compressionType", iBlock );
nCompressType = poDMS->GetIntField( szVarName );
panBlockFlag[iBlock] = 0;
if( nLogvalid )
panBlockFlag[iBlock] |= BFLG_VALID;
if( nCompressType != 0 )
panBlockFlag[iBlock] |= BFLG_COMPRESSED;
}
return( CE_None );
}
std::vector<HFAEntry*> HFAEntry::FindChildren( const char *pszName,
const char *pszType,
int nRecLevel,
int* pbErrorDetected )
{
std::vector<HFAEntry*> apoChildren;
if( *pbErrorDetected )
return apoChildren;
if( nRecLevel == 50 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Bad entry structure: recursion detected !");
*pbErrorDetected = TRUE;
return apoChildren;
}
for( HFAEntry *poEntry = GetChild();
poEntry != NULL;
poEntry = poEntry->GetNext() )
{
std::vector<HFAEntry*> apoEntryChildren;
if( (pszName == NULL || EQUAL(poEntry->GetName(), pszName))
&& (pszType == NULL || EQUAL(poEntry->GetType(), pszType)) )
apoChildren.push_back( poEntry );
apoEntryChildren =
poEntry->FindChildren(pszName, pszType, nRecLevel + 1,
pbErrorDetected);
if( *pbErrorDetected )
return apoChildren;
for( size_t i = 0; i < apoEntryChildren.size(); i++ )
apoChildren.push_back( apoEntryChildren[i] );
}
return apoChildren;
}
CPLErr HFAGetDataRange( HFAHandle hHFA, int nBand,
double * pdfMin, double *pdfMax )
{
HFAEntry *poBinInfo;
if( nBand < 1 || nBand > hHFA->nBands )
return CE_Failure;
poBinInfo = hHFA->papoBand[nBand-1]->poNode->GetNamedChild("Statistics" );
if( poBinInfo == NULL )
return( CE_Failure );
*pdfMin = poBinInfo->GetDoubleField( "minimum" );
*pdfMax = poBinInfo->GetDoubleField( "maximum" );
if( *pdfMax > *pdfMin )
return CE_None;
else
return CE_Failure;
}
HFAEntry *HFAEntry::GetNamedChild( const char * pszName )
{
int nNameLen;
HFAEntry *poEntry;
/* -------------------------------------------------------------------- */
/* Establish how much of this name path is for the next child. */
/* Up to the '.' or end of estring. */
/* -------------------------------------------------------------------- */
for( nNameLen = 0;
pszName[nNameLen] != '.'
&& pszName[nNameLen] != '\0'
&& pszName[nNameLen] != ':';
nNameLen++ ) {}
/* -------------------------------------------------------------------- */
/* Scan children looking for this name. */
/* -------------------------------------------------------------------- */
for( poEntry = GetChild(); poEntry != NULL; poEntry = poEntry->GetNext() )
{
if( EQUALN(poEntry->GetName(),pszName,nNameLen)
&& (int) strlen(poEntry->GetName()) == nNameLen )
{
if( pszName[nNameLen] == '.' )
{
HFAEntry *poResult;
poResult = poEntry->GetNamedChild( pszName+nNameLen+1 );
if( poResult != NULL )
return poResult;
}
else
return poEntry;
}
}
return NULL;
}
HFAEntry *HFAEntry::GetNamedChild( const char * pszName )
{
int nNameLen;
HFAEntry *poEntry;
/* -------------------------------------------------------------------- */
/* Establish how much of this name path is for the next child. */
/* Up to the '.' or end of estring. */
/* -------------------------------------------------------------------- */
for( nNameLen = 0;
pszName[nNameLen] != '.'
&& pszName[nNameLen] != '\0'
&& pszName[nNameLen] != ':';
nNameLen++ ) {}
/* -------------------------------------------------------------------- */
/* Scan children looking for this name. */
/* -------------------------------------------------------------------- */
for( poEntry = GetChild(); poEntry != NULL; poEntry = poEntry->GetNext() )
{
if( EQUALN(poEntry->GetName(),pszName,nNameLen)
&& (int) strlen(poEntry->GetName()) == nNameLen )
{
break;
}
}
/* -------------------------------------------------------------------- */
/* Is there a remainder to process? */
/* -------------------------------------------------------------------- */
if( poEntry != NULL && pszName[nNameLen] == '.' )
return( poEntry->GetNamedChild( pszName+nNameLen+1 ) );
else
return( poEntry );
}
HFAHandle HFAOpen( const char * pszFilename, const char * pszAccess )
{
FILE *fp;
char szHeader[16];
HFAInfo_t *psInfo;
GUInt32 nHeaderPos;
HFAEntry *poNode;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszAccess,"r") || EQUAL(pszAccess,"rb" ) )
fp = VSIFOpen( pszFilename, "rb" );
else
fp = VSIFOpen( pszFilename, "r+b" );
/* should this be changed to use some sort of CPLFOpen() which will
set the error? */
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File open of %s failed.",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read and verify the header. */
/* -------------------------------------------------------------------- */
if( VSIFRead( szHeader, 16, 1, fp ) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to read 16 byte header failed for\n%s.",
pszFilename );
return NULL;
}
if( !EQUALN(szHeader,"EHFA_HEADER_TAG",15) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s is not an Imagine HFA file ... header wrong.",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the HFAInfo_t */
/* -------------------------------------------------------------------- */
psInfo = (HFAInfo_t *) CPLCalloc(sizeof(HFAInfo_t),1);
psInfo->fp = fp;
/* -------------------------------------------------------------------- */
/* Where is the header? */
/* -------------------------------------------------------------------- */
VSIFRead( &nHeaderPos, sizeof(GInt32), 1, fp );
HFAStandard( 4, &nHeaderPos );
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
VSIFSeek( fp, nHeaderPos, SEEK_SET );
VSIFRead( &(psInfo->nVersion), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nVersion) );
VSIFRead( szHeader, 4, 1, fp ); /* skip freeList */
VSIFRead( &(psInfo->nRootPos), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nRootPos) );
VSIFRead( &(psInfo->nEntryHeaderLength), sizeof(GInt16), 1, fp );
HFAStandard( 2, &(psInfo->nEntryHeaderLength) );
VSIFRead( &(psInfo->nDictionaryPos), sizeof(GInt32), 1, fp );
HFAStandard( 4, &(psInfo->nDictionaryPos) );
/* -------------------------------------------------------------------- */
/* Instantiate the root entry. */
/* -------------------------------------------------------------------- */
psInfo->poRoot = new HFAEntry( psInfo, psInfo->nRootPos, NULL, NULL );
/* -------------------------------------------------------------------- */
/* Read the dictionary */
/* -------------------------------------------------------------------- */
psInfo->pszDictionary = HFAGetDictionary( psInfo );
psInfo->poDictionary = new HFADictionary( psInfo->pszDictionary );
/* -------------------------------------------------------------------- */
/* Find the first band node. */
/* -------------------------------------------------------------------- */
psInfo->nBands = 0;
poNode = psInfo->poRoot->GetChild();
while( poNode != NULL )
{
if( EQUAL(poNode->GetType(),"Eimg_Layer") )
{
if( psInfo->nBands == 0 )
{
psInfo->nXSize = poNode->GetIntField("width");
psInfo->nYSize = poNode->GetIntField("height");
}
else if( poNode->GetIntField("width") != psInfo->nXSize
|| poNode->GetIntField("height") != psInfo->nYSize )
{
CPLAssert( FALSE );
continue;
}
psInfo->papoBand = (HFABand **)
CPLRealloc(psInfo->papoBand,
sizeof(HFABand *) * (psInfo->nBands+1));
psInfo->papoBand[psInfo->nBands] = new HFABand( psInfo, poNode );
psInfo->nBands++;
}
poNode = poNode->GetNext();
}
return psInfo;
}
const Eprj_ProParameters *HFAGetProParameters( HFAHandle hHFA )
{
HFAEntry *poMIEntry;
Eprj_ProParameters *psProParms;
int i;
if( hHFA->nBands < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we already have it? */
/* -------------------------------------------------------------------- */
if( hHFA->pProParameters != NULL )
return( (Eprj_ProParameters *) hHFA->pProParameters );
/* -------------------------------------------------------------------- */
/* Get the HFA node. */
/* -------------------------------------------------------------------- */
poMIEntry = hHFA->papoBand[0]->poNode->GetNamedChild( "Projection" );
if( poMIEntry == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Allocate the structure. */
/* -------------------------------------------------------------------- */
psProParms = (Eprj_ProParameters *)CPLCalloc(sizeof(Eprj_ProParameters),1);
/* -------------------------------------------------------------------- */
/* Fetch the fields. */
/* -------------------------------------------------------------------- */
psProParms->proType = (Eprj_ProType) poMIEntry->GetIntField("proType");
psProParms->proNumber = poMIEntry->GetIntField("proNumber");
psProParms->proExeName =CPLStrdup(poMIEntry->GetStringField("proExeName"));
psProParms->proName = CPLStrdup(poMIEntry->GetStringField("proName"));
psProParms->proZone = poMIEntry->GetIntField("proZone");
for( i = 0; i < 15; i++ )
{
char szFieldName[30];
sprintf( szFieldName, "proParams[%d]", i );
psProParms->proParams[i] = poMIEntry->GetDoubleField(szFieldName);
}
psProParms->proSpheroid.sphereName =
CPLStrdup(poMIEntry->GetStringField("proSpheroid.sphereName"));
psProParms->proSpheroid.a = poMIEntry->GetDoubleField("proSpheroid.a");
psProParms->proSpheroid.b = poMIEntry->GetDoubleField("proSpheroid.b");
psProParms->proSpheroid.eSquared =
poMIEntry->GetDoubleField("proSpheroid.eSquared");
psProParms->proSpheroid.radius =
poMIEntry->GetDoubleField("proSpheroid.radius");
hHFA->pProParameters = (void *) psProParms;
return psProParms;
}
int main( int argc, char ** argv )
{
const char *pszFilename = NULL;
int nDumpTree = FALSE;
int nDumpDict = FALSE;
int nRastReport = FALSE;
int i, nXSize, nYSize, nBands;
HFAHandle hHFA;
const Eprj_MapInfo *psMapInfo;
const Eprj_ProParameters *psProParameters;
const Eprj_Datum *psDatum;
/* -------------------------------------------------------------------- */
/* Handle arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"-dd") )
nDumpDict = TRUE;
else if( EQUAL(argv[i],"-dt") )
nDumpTree = TRUE;
else if( EQUAL(argv[i],"-dr") )
nRastReport = TRUE;
else if( pszFilename == NULL )
pszFilename = argv[i];
else
{
Usage();
exit( 1 );
}
}
if( pszFilename == NULL )
{
Usage();
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
hHFA = HFAOpen( pszFilename, "r" );
if( hHFA == NULL )
{
printf( "HFAOpen() failed.\n" );
exit( 100 );
}
/* -------------------------------------------------------------------- */
/* Do we want to walk the tree dumping out general information? */
/* -------------------------------------------------------------------- */
if( nDumpDict )
{
HFADumpDictionary( hHFA, stdout );
}
/* -------------------------------------------------------------------- */
/* Do we want to walk the tree dumping out general information? */
/* -------------------------------------------------------------------- */
if( nDumpTree )
{
HFADumpTree( hHFA, stdout );
}
/* -------------------------------------------------------------------- */
/* Dump indirectly collected data about bands. */
/* -------------------------------------------------------------------- */
HFAGetRasterInfo( hHFA, &nXSize, &nYSize, &nBands );
if( nRastReport )
{
printf( "Raster Size = %d x %d\n", nXSize, nYSize );
for( i = 1; i <= nBands; i++ )
{
int nDataType, nColors, nOverviews, iOverview;
double *padfRed, *padfGreen, *padfBlue, *padfAlpha, *padfBins;
int nBlockXSize, nBlockYSize, nCompressionType;
HFAGetBandInfo( hHFA, i, &nDataType, &nBlockXSize, &nBlockYSize,
&nCompressionType );
nOverviews = HFAGetOverviewCount( hHFA, i );
printf( "Band %d: %dx%d tiles, type = %d\n",
i, nBlockXSize, nBlockYSize, nDataType );
for( iOverview=0; iOverview < nOverviews; iOverview++ )
{
HFAGetOverviewInfo( hHFA, i, iOverview,
&nXSize, &nYSize,
&nBlockXSize, &nBlockYSize, NULL );
printf( " Overview: %dx%d (blocksize %dx%d)\n",
nXSize, nYSize, nBlockXSize, nBlockYSize );
}
if( HFAGetPCT( hHFA, i, &nColors, &padfRed, &padfGreen,
&padfBlue, &padfAlpha, &padfBins )
== CE_None )
{
int j;
for( j = 0; j < nColors; j++ )
{
printf( "PCT[%d] = %f,%f,%f %f\n",
(padfBins != NULL) ? (int) padfBins[j] : j,
padfRed[j], padfGreen[j],
padfBlue[j], padfAlpha[j]);
}
}
/* -------------------------------------------------------------------- */
/* Report statistics. We need to dig directly into the C++ API. */
/* -------------------------------------------------------------------- */
HFABand *poBand = hHFA->papoBand[i-1];
HFAEntry *poStats = poBand->poNode->GetNamedChild( "Statistics" );
if( poStats != NULL )
{
printf( " Min: %g Max: %g Mean: %g\n",
poStats->GetDoubleField( "minimum" ),
poStats->GetDoubleField( "maximum" ),
poStats->GetDoubleField( "mean" ) );
printf( " Median: %g Mode: %g Stddev: %g\n",
poStats->GetDoubleField( "median" ),
poStats->GetDoubleField( "mode" ),
poStats->GetDoubleField( "stddev" ) );
}
else
printf( " No Statistics found.\n" );
}
/* -------------------------------------------------------------------- */
/* Dump the map info structure. */
/* -------------------------------------------------------------------- */
psMapInfo = HFAGetMapInfo( hHFA );
if( psMapInfo != NULL )
{
printf( "MapInfo.proName = %s\n", psMapInfo->proName );
printf( "MapInfo.upperLeftCenter.x = %.2f\n",
psMapInfo->upperLeftCenter.x );
printf( "MapInfo.upperLeftCenter.y = %.2f\n",
psMapInfo->upperLeftCenter.y );
}
else
{
printf( "No Map Info found\n" );
}
}
psProParameters = HFAGetProParameters( hHFA );
psDatum = HFAGetDatum( hHFA );
HFAClose( hHFA );
#ifdef DBMALLOC
malloc_dump(1);
#endif
exit( 0 );
}
CPLErr HFAEntry::FlushToDisk()
{
CPLErr eErr = CE_None;
/* -------------------------------------------------------------------- */
/* If we are the root node, call SetPosition() on the whole */
/* tree to ensure that all entries have an allocated position. */
/* -------------------------------------------------------------------- */
if( poParent == NULL )
SetPosition();
/* ==================================================================== */
/* Only write this node out if it is dirty. */
/* ==================================================================== */
if( bDirty )
{
/* -------------------------------------------------------------------- */
/* Ensure we know where the relative entries are located. */
/* -------------------------------------------------------------------- */
if( poNext != NULL )
nNextPos = poNext->nFilePos;
if( poChild != NULL )
nChildPos = poChild->nFilePos;
/* -------------------------------------------------------------------- */
/* Write the Ehfa_Entry fields. */
/* -------------------------------------------------------------------- */
GUInt32 nLong;
//VSIFFlushL( psHFA->fp );
if( VSIFSeekL( psHFA->fp, nFilePos, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d for writing, out of disk space?",
nFilePos );
return CE_Failure;
}
nLong = nNextPos;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
if( poPrev != NULL )
nLong = poPrev->nFilePos;
else
nLong = 0;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
if( poParent != NULL )
nLong = poParent->nFilePos;
else
nLong = 0;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
nLong = nChildPos;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
nLong = nDataPos;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
nLong = nDataSize;
HFAStandard( 4, &nLong );
VSIFWriteL( &nLong, 4, 1, psHFA->fp );
VSIFWriteL( szName, 1, 64, psHFA->fp );
VSIFWriteL( szType, 1, 32, psHFA->fp );
nLong = 0; /* Should we keep the time, or set it more reasonably? */
if( VSIFWriteL( &nLong, 4, 1, psHFA->fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write HFAEntry %s(%s), out of disk space?",
szName, szType );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write out the data. */
/* -------------------------------------------------------------------- */
//VSIFFlushL( psHFA->fp );
if( nDataSize > 0 && pabyData != NULL )
{
if( VSIFSeekL( psHFA->fp, nDataPos, SEEK_SET ) != 0
|| VSIFWriteL( pabyData, nDataSize, 1, psHFA->fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %d bytes HFAEntry %s(%s) data,\n"
"out of disk space?",
nDataSize, szName, szType );
return CE_Failure;
}
}
//VSIFFlushL( psHFA->fp );
}
/* -------------------------------------------------------------------- */
/* Process all the children of this node */
/* -------------------------------------------------------------------- */
for( HFAEntry *poThisChild = poChild;
poThisChild != NULL;
poThisChild = poThisChild->poNext )
{
eErr = poThisChild->FlushToDisk();
if( eErr != CE_None )
return eErr;
}
bDirty = FALSE;
return CE_None;
}