const char *DDFField::GetInstanceData( int nInstance,
int *pnInstanceSize )
{
int nRepeatCount = GetRepeatCount();
const char *pachWrkData;
if( nInstance < 0 || nInstance >= nRepeatCount )
return NULL;
/* -------------------------------------------------------------------- */
/* Special case for fields without subfields (like "0001"). We */
/* don't currently handle repeating simple fields. */
/* -------------------------------------------------------------------- */
if( poDefn->GetSubfieldCount() == 0 )
{
pachWrkData = GetData();
if( pnInstanceSize != 0 )
*pnInstanceSize = GetDataSize();
return pachWrkData;
}
/* -------------------------------------------------------------------- */
/* Get a pointer to the start of the existing data for this */
/* iteration of the field. */
/* -------------------------------------------------------------------- */
int nBytesRemaining1 = 0, nBytesRemaining2 = 0;
DDFSubfieldDefn *poFirstSubfield;
poFirstSubfield = poDefn->GetSubfield(0);
pachWrkData = GetSubfieldData(poFirstSubfield, &nBytesRemaining1,
nInstance);
/* -------------------------------------------------------------------- */
/* Figure out the size of the entire field instance, including */
/* unit terminators, but not any trailing field terminator. */
/* -------------------------------------------------------------------- */
if( pnInstanceSize != NULL )
{
DDFSubfieldDefn *poLastSubfield;
int nLastSubfieldWidth;
const char *pachLastData;
poLastSubfield = poDefn->GetSubfield(poDefn->GetSubfieldCount()-1);
pachLastData = GetSubfieldData( poLastSubfield, &nBytesRemaining2,
nInstance );
poLastSubfield->GetDataLength( pachLastData, nBytesRemaining2,
&nLastSubfieldWidth );
if((pachLastData[nLastSubfieldWidth-1] == 0) && (pachLastData[nLastSubfieldWidth - 2] == DDF_FIELD_TERMINATOR))
nLastSubfieldWidth -= 2;
*pnInstanceSize =
nBytesRemaining1 - (nBytesRemaining2 - nLastSubfieldWidth);
}
return pachWrkData;
}
int SDTSModId::Set( DDFField *poField )
{
const char *pachData = poField->GetData();
DDFFieldDefn *poDefn = poField->GetFieldDefn();
if( poDefn->GetSubfieldCount() >= 2
&& poDefn->GetSubfield(0)->GetWidth() == 4 )
{
if( strlen(pachData) < 5 )
return FALSE;
memcpy( szModule, pachData, 4 );
szModule[4] = '\0';
nRecord = atoi( pachData + 4 );
}
else
{
DDFSubfieldDefn *poSF
= poField->GetFieldDefn()->FindSubfieldDefn( "MODN" );
if( poSF == nullptr )
return FALSE;
int nBytesRemaining;
pachData = poField->GetSubfieldData(poSF, &nBytesRemaining);
if( pachData == nullptr )
return FALSE;
snprintf( szModule, sizeof(szModule), "%s",
poSF->ExtractStringData( pachData, nBytesRemaining, nullptr) );
poSF = poField->GetFieldDefn()->FindSubfieldDefn( "RCID" );
if( poSF != nullptr )
{
pachData = poField->GetSubfieldData(poSF, &nBytesRemaining);
if( pachData != nullptr )
nRecord = poSF->ExtractIntData( pachData, nBytesRemaining, nullptr);
}
}
if( poDefn->GetSubfieldCount() == 3 )
{
DDFSubfieldDefn *poSF = poField->GetFieldDefn()->FindSubfieldDefn( "OBRP" );
if( poSF != nullptr )
{
int nBytesRemaining;
pachData
= poField->GetSubfieldData(poSF, &nBytesRemaining);
if( pachData != nullptr )
{
snprintf( szOBRP, sizeof(szOBRP), "%s",
poSF->ExtractStringData( pachData, nBytesRemaining, nullptr) );
}
}
}
return FALSE;
}
void DDFFieldDefn::AddSubfield( const char *pszName,
const char *pszFormat )
{
DDFSubfieldDefn *poSFDefn = new DDFSubfieldDefn;
poSFDefn->SetName( pszName );
poSFDefn->SetFormat( pszFormat );
AddSubfield( poSFDefn );
}
int DDFFieldDefn::BuildSubfields()
{
char **papszSubfieldNames;
const char *pszSublist = _arrayDescr;
/* -------------------------------------------------------------------- */
/* It is valid to define a field with _arrayDesc */
/* '*STPT!CTPT!ENPT*YCOO!XCOO' and formatControls '(2b24)'. */
/* This basically indicates that there are 3 (YCOO,XCOO) */
/* structures named STPT, CTPT and ENPT. But we can't handle */
/* such a case gracefully here, so we just ignore the */
/* "structure names" and treat such a thing as a repeating */
/* YCOO/XCOO array. This occurs with the AR2D field of some */
/* AML S-57 files for instance. */
/* */
/* We accomplish this by ignoring everything before the last */
/* '*' in the subfield list. */
/* -------------------------------------------------------------------- */
if( strrchr(pszSublist, '*') != NULL )
pszSublist = strrchr(pszSublist,'*');
/* -------------------------------------------------------------------- */
/* Strip off the repeating marker, when it occurs, but mark our */
/* field as repeating. */
/* -------------------------------------------------------------------- */
if( pszSublist[0] == '*' )
{
bRepeatingSubfields = TRUE;
pszSublist++;
}
/* -------------------------------------------------------------------- */
/* split list of fields . */
/* -------------------------------------------------------------------- */
papszSubfieldNames = CSLTokenizeStringComplex( pszSublist, "!",
FALSE, FALSE );
/* -------------------------------------------------------------------- */
/* minimally initialize the subfields. More will be done later. */
/* -------------------------------------------------------------------- */
int nSFCount = CSLCount( papszSubfieldNames );
for( int iSF = 0; iSF < nSFCount; iSF++ )
{
DDFSubfieldDefn *poSFDefn = new DDFSubfieldDefn;
poSFDefn->SetName( papszSubfieldNames[iSF] );
AddSubfield( poSFDefn, TRUE );
}
CSLDestroy( papszSubfieldNames );
return TRUE;
}
int SDTSModId::Set( DDFField *poField )
{
const char *pachData = poField->GetData();
DDFFieldDefn *poDefn = poField->GetFieldDefn();
if( poDefn->GetSubfieldCount() >= 2
&& poDefn->GetSubfield(0)->GetWidth() == 4 )
{
memcpy( szModule, pachData, 4 );
szModule[4] = '\0';
nRecord = atoi( pachData + 4 );
}
else
{
DDFSubfieldDefn *poSF;
int nBytesRemaining;
const char *pachData;
poSF = poField->GetFieldDefn()->FindSubfieldDefn( "MODN" );
pachData = poField->GetSubfieldData(poSF, &nBytesRemaining);
strncpy( szModule,
poSF->ExtractStringData( pachData, nBytesRemaining, NULL),
sizeof(szModule) );
szModule[sizeof(szModule)-1] = '\0';
poSF = poField->GetFieldDefn()->FindSubfieldDefn( "RCID" );
pachData = poField->GetSubfieldData(poSF, &nBytesRemaining);
nRecord = poSF->ExtractIntData( pachData, nBytesRemaining, NULL);
}
if( poDefn->GetSubfieldCount() == 3 )
{
DDFSubfieldDefn *poSF;
poSF = poField->GetFieldDefn()->FindSubfieldDefn( "OBRP" );
if( poSF != NULL )
{
int nBytesRemaining;
const char *pachData;
pachData = poField->GetSubfieldData(poSF, &nBytesRemaining);
strncpy( szOBRP,
poSF->ExtractStringData( pachData, nBytesRemaining, NULL),
sizeof(szOBRP) );
szOBRP[sizeof(szOBRP)-1] = '\0';
}
}
return FALSE;
}
int DDFField::GetRepeatCount()
{
if( !poDefn->IsRepeating() )
return 1;
/* -------------------------------------------------------------------- */
/* The occurance count depends on how many copies of this */
/* field's list of subfields can fit into the data space. */
/* -------------------------------------------------------------------- */
if( poDefn->GetFixedWidth() )
{
return nDataSize / poDefn->GetFixedWidth();
}
/* -------------------------------------------------------------------- */
/* Note that it may be legal to have repeating variable width */
/* subfields, but I don't have any samples, so I ignore it for */
/* now. */
/* */
/* The file data/cape_royal_AZ_DEM/1183XREF.DDF has a repeating */
/* variable length field, but the count is one, so it isn't */
/* much value for testing. */
/* -------------------------------------------------------------------- */
int iOffset = 0, iRepeatCount = 1;
while( TRUE )
{
for( int iSF = 0; iSF < poDefn->GetSubfieldCount(); iSF++ )
{
int nBytesConsumed;
DDFSubfieldDefn * poThisSFDefn = poDefn->GetSubfield( iSF );
if( poThisSFDefn->GetWidth() > nDataSize - iOffset )
nBytesConsumed = poThisSFDefn->GetWidth();
else
poThisSFDefn->GetDataLength( pachData+iOffset,
nDataSize - iOffset,
&nBytesConsumed);
iOffset += nBytesConsumed;
if( iOffset > nDataSize )
return iRepeatCount - 1;
}
if( iOffset > nDataSize - 2 )
return iRepeatCount;
iRepeatCount++;
}
}
const char *DDFField::GetSubfieldData( DDFSubfieldDefn *poSFDefn,
int *pnMaxBytes, int iSubfieldIndex )
{
int iOffset = 0;
if( poSFDefn == NULL )
return NULL;
if( iSubfieldIndex > 0 && poDefn->GetFixedWidth() > 0 )
{
iOffset = poDefn->GetFixedWidth() * iSubfieldIndex;
iSubfieldIndex = 0;
}
while( iSubfieldIndex >= 0 )
{
for( int iSF = 0; iSF < poDefn->GetSubfieldCount(); iSF++ )
{
int nBytesConsumed;
DDFSubfieldDefn * poThisSFDefn = poDefn->GetSubfield( iSF );
if( nDataSize < iOffset )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid data size for subfield %s of %s",
poThisSFDefn->GetName(), poDefn->GetName());
return NULL;
}
if( poThisSFDefn == poSFDefn && iSubfieldIndex == 0 )
{
if( pnMaxBytes != NULL )
*pnMaxBytes = nDataSize - iOffset;
return pachData + iOffset;
}
poThisSFDefn->GetDataLength( pachData+iOffset, nDataSize - iOffset,
&nBytesConsumed);
iOffset += nBytesConsumed;
}
iSubfieldIndex--;
}
// We didn't find our target subfield or instance!
return NULL;
}
void SDTSFeature::ApplyATID( DDFField * poField )
{
DDFSubfieldDefn *poMODN
= poField->GetFieldDefn()->FindSubfieldDefn( "MODN" );
if( poMODN == nullptr )
{
// CPLAssert( false );
return;
}
bool bUsualFormat = poMODN->GetWidth() == 4;
const int nRepeatCount = poField->GetRepeatCount();
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
paoATID = reinterpret_cast<SDTSModId *>(
CPLRealloc( paoATID, sizeof(SDTSModId)*(nAttributes+1) ) );
SDTSModId *poModId = paoATID + nAttributes;
*poModId = SDTSModId();
if( bUsualFormat )
{
const char * pabyData
= poField->GetSubfieldData( poMODN, nullptr, iRepeat );
if( pabyData == nullptr || strlen(pabyData) < 5 )
return;
memcpy( poModId->szModule, pabyData, 4 );
poModId->szModule[4] = '\0';
poModId->nRecord = atoi(pabyData + 4);
poModId->szOBRP[0] = '\0';
}
else
{
poModId->Set( poField );
}
nAttributes++;
}
}
void SDTSFeature::ApplyATID( DDFField * poField )
{
int nRepeatCount = poField->GetRepeatCount();
int bUsualFormat;
DDFSubfieldDefn *poMODN;
poMODN = poField->GetFieldDefn()->FindSubfieldDefn( "MODN" );
if( poMODN == NULL )
{
CPLAssert( FALSE );
return;
}
bUsualFormat = poMODN->GetWidth() == 4;
for( int iRepeat = 0; iRepeat < nRepeatCount; iRepeat++ )
{
paoATID = (SDTSModId *) CPLRealloc(paoATID,
sizeof(SDTSModId)*(nAttributes+1));
const char * pabyData;
SDTSModId *poModId = paoATID + nAttributes;
if( bUsualFormat )
{
pabyData = poField->GetSubfieldData( poMODN, NULL, iRepeat );
memcpy( poModId->szModule, pabyData, 4 );
poModId->szModule[4] = '\0';
poModId->nRecord = atoi(pabyData + 4);
poModId->szOBRP[0] = '\0';
}
else
{
poModId->Set( poField );
}
nAttributes++;
}
}
int main( int nArgc, char ** papszArgv )
{
DDFModule oModule;
const char *pszFilename = NULL;
int bFSPTHack = FALSE;
int bXML = FALSE;
/* -------------------------------------------------------------------- */
/* Check arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-fspt_repeating") )
bFSPTHack = TRUE;
else if( EQUAL(papszArgv[iArg],"-xml") )
bXML = TRUE;
else
pszFilename = papszArgv[iArg];
}
if( pszFilename == NULL )
{
printf( "Usage: 8211dump [-xml] [-fspt_repeating] filename\n" );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Open file. */
/* -------------------------------------------------------------------- */
if( !oModule.Open( pszFilename ) )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Apply FSPT hack if required. */
/* -------------------------------------------------------------------- */
if( bFSPTHack )
{
DDFFieldDefn *poFSPT = oModule.FindFieldDefn( "FSPT" );
if( poFSPT == NULL )
fprintf( stderr,
"unable to find FSPT field to set repeating flag.\n" );
else
poFSPT->SetRepeatingFlag( TRUE );
}
/* -------------------------------------------------------------------- */
/* Dump header, and all records. */
/* -------------------------------------------------------------------- */
DDFRecord *poRecord;
if( bXML )
{
printf("<DDFModule>\n");
int nFieldDefnCount = oModule.GetFieldCount();
for( int i = 0; i < nFieldDefnCount; i++ )
{
DDFFieldDefn* poFieldDefn = oModule.GetField(i);
const char* pszDataStructCode;
switch( poFieldDefn->GetDataStructCode() )
{
case dsc_elementary:
pszDataStructCode = "elementary";
break;
case dsc_vector:
pszDataStructCode = "vector";
break;
case dsc_array:
pszDataStructCode = "array";
break;
case dsc_concatenated:
pszDataStructCode = "concatenated";
break;
default:
pszDataStructCode = "(unknown)";
break;
}
const char* pszDataTypeCode;
switch( poFieldDefn->GetDataTypeCode() )
{
case dtc_char_string:
pszDataTypeCode = "char_string";
break;
case dtc_implicit_point:
pszDataTypeCode = "implicit_point";
break;
case dtc_explicit_point:
pszDataTypeCode = "explicit_point";
break;
case dtc_explicit_point_scaled:
pszDataTypeCode = "explicit_point_scaled";
break;
case dtc_char_bit_string:
pszDataTypeCode = "char_bit_string";
break;
case dtc_bit_string:
pszDataTypeCode = "bit_string";
break;
case dtc_mixed_data_type:
pszDataTypeCode = "mixed_data_type";
break;
default:
pszDataTypeCode = "(unknown)";
break;
}
printf("<DDFFieldDefn tag=\"%s\" fieldName=\"%s\" arrayDescr=\"%s\" "
"formatControls=\"%s\" dataStructCode=\"%s\" dataTypeCode=\"%s\">\n",
poFieldDefn->GetName(),
poFieldDefn->GetDescription(),
poFieldDefn->GetArrayDescr(),
poFieldDefn->GetFormatControls(),
pszDataStructCode,
pszDataTypeCode);
int nSubfieldCount = poFieldDefn->GetSubfieldCount();
for( int iSubField = 0; iSubField < nSubfieldCount; iSubField++ )
{
DDFSubfieldDefn* poSubFieldDefn = poFieldDefn->GetSubfield(iSubField);
printf(" <DDFSubfieldDefn name=\"%s\" format=\"%s\"/>\n",
poSubFieldDefn->GetName(), poSubFieldDefn->GetFormat());
}
printf("</DDFFieldDefn>\n");
}
for( poRecord = oModule.ReadRecord();
poRecord != NULL; poRecord = oModule.ReadRecord() )
{
printf("<DDFRecord>\n");
int nFieldCount = poRecord->GetFieldCount();
for( int iField = 0; iField < nFieldCount; iField++ )
{
DDFField* poField = poRecord->GetField(iField);
DDFFieldDefn* poDefn = poField->GetFieldDefn();
const char* pszFieldName = poDefn->GetName();
printf(" <DDFField name=\"%s\"", pszFieldName);
if( poField->GetRepeatCount() > 1 )
printf(" repeatCount=\"%d\"", poField->GetRepeatCount());
int iOffset = 0, nLoopCount;
int nRepeatCount = poField->GetRepeatCount();
const char* pachData = poField->GetData();
int nDataSize = poField->GetDataSize();
if( nRepeatCount == 1 && poDefn->GetSubfieldCount() == 0 )
{
printf(" value=\"0x");
for( int i = 0; i < nDataSize - 1; i++ )
printf( "%02X", pachData[i] );
printf("\">\n");
}
else
printf(">\n");
for( nLoopCount = 0; nLoopCount < nRepeatCount; nLoopCount++ )
{
for( int iSubField = 0; iSubField < poDefn->GetSubfieldCount(); iSubField++ )
{
int nBytesConsumed;
DDFSubfieldDefn* poSubFieldDefn = poDefn->GetSubfield(iSubField);
const char* pszSubFieldName = poSubFieldDefn->GetName();
printf(" <DDFSubfield name=\"%s\" ", pszSubFieldName);
DDFDataType eType = poSubFieldDefn->GetType();
const char* pachSubdata = pachData + iOffset;
int nMaxBytes = nDataSize - iOffset;
if( eType == DDFFloat )
printf("type=\"float\">%f",
poSubFieldDefn->ExtractFloatData( pachSubdata, nMaxBytes, NULL ) );
else if( eType == DDFInt )
printf("type=\"integer\">%d",
poSubFieldDefn->ExtractIntData( pachSubdata, nMaxBytes, NULL ) );
else if( eType == DDFBinaryString )
{
int nBytes, i;
GByte *pabyBString = (GByte *)
poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, &nBytes );
printf( "type=\"binary\">0x" );
for( i = 0; i < nBytes; i++ )
printf( "%02X", pabyBString[i] );
}
else
{
GByte* pabyString = (GByte *)poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, NULL );
int bBinary = FALSE;
int i;
for( i = 0; pabyString[i] != '\0'; i ++ )
{
if( pabyString[i] < 32 || pabyString[i] > 127 )
{
bBinary = TRUE;
break;
}
}
if( bBinary )
{
printf( "type=\"binary\">0x" );
for( i = 0; pabyString[i] != '\0'; i ++ )
printf( "%02X", pabyString[i] );
}
else
{
char* pszEscaped = CPLEscapeString((const char*)pabyString, -1, CPLES_XML);
printf("type=\"string\">%s", pszEscaped);
CPLFree(pszEscaped);
}
}
printf("</DDFSubfield>\n");
poSubFieldDefn->GetDataLength( pachSubdata, nMaxBytes, &nBytesConsumed );
iOffset += nBytesConsumed;
}
}
printf(" </DDFField>\n");
}
printf("</DDFRecord>\n");
}
printf("</DDFModule>\n");
}
else
{
oModule.Dump( stdout );
long nStartLoc;
nStartLoc = VSIFTellL( oModule.GetFP() );
for( poRecord = oModule.ReadRecord();
poRecord != NULL; poRecord = oModule.ReadRecord() )
{
printf( "File Offset: %ld\n", nStartLoc );
poRecord->Dump( stdout );
nStartLoc = VSIFTellL( oModule.GetFP() );
}
}
oModule.Close();
#ifdef DBMALLOC
malloc_dump(1);
#endif
}
static void
WriteAttrRecordToDBF( DBFHandle hDBF, int iRecord,
SDTSTransfer * poTransfer, DDFField * poSR )
{
/* -------------------------------------------------------------------- */
/* Process each subfield in the record. */
/* -------------------------------------------------------------------- */
DDFFieldDefn *poFDefn = poSR->GetFieldDefn();
for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ )
{
DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF );
int iField;
int nMaxBytes;
const char * pachData = poSR->GetSubfieldData(poSFDefn,
&nMaxBytes);
/* -------------------------------------------------------------------- */
/* Identify the related DBF field, if any. */
/* -------------------------------------------------------------------- */
for( iField = 0; iField < hDBF->nFields; iField++ )
{
if( EQUALN(poSFDefn->GetName(),
hDBF->pszHeader+iField*32,10) )
break;
}
if( iField == hDBF->nFields )
iField = -1;
/* -------------------------------------------------------------------- */
/* Handle each of the types. */
/* -------------------------------------------------------------------- */
switch( poSFDefn->GetType() )
{
case DDFString:
const char *pszValue;
pszValue = poSFDefn->ExtractStringData(pachData, nMaxBytes,
NULL);
if( iField != -1 )
DBFWriteStringAttribute(hDBF, iRecord, iField, pszValue );
break;
case DDFFloat:
double dfValue;
dfValue = poSFDefn->ExtractFloatData(pachData, nMaxBytes,
NULL);
if( iField != -1 )
DBFWriteDoubleAttribute( hDBF, iRecord, iField, dfValue );
break;
case DDFInt:
int nValue;
nValue = poSFDefn->ExtractIntData(pachData, nMaxBytes, NULL);
if( iField != -1 )
DBFWriteIntegerAttribute( hDBF, iRecord, iField, nValue );
break;
default:
break;
}
} /* next subfield */
}
static void
AddPrimaryAttrToDBFSchema( DBFHandle hDBF, SDTSTransfer *poTransfer,
char ** papszModuleList )
{
for( int iModule = 0;
papszModuleList != NULL && papszModuleList[iModule] != NULL;
iModule++ )
{
SDTSAttrReader *poAttrReader;
/* -------------------------------------------------------------------- */
/* Get a reader on the desired module. */
/* -------------------------------------------------------------------- */
poAttrReader = (SDTSAttrReader *)
poTransfer->GetLayerIndexedReader(
poTransfer->FindLayer( papszModuleList[iModule] ) );
if( poAttrReader == NULL )
{
printf( "Unable to open attribute module %s, skipping.\n" ,
papszModuleList[iModule] );
continue;
}
poAttrReader->Rewind();
/* -------------------------------------------------------------------- */
/* Read the first record so we can clone schema information off */
/* of it. */
/* -------------------------------------------------------------------- */
SDTSAttrRecord *poAttrFeature;
poAttrFeature = (SDTSAttrRecord *) poAttrReader->GetNextFeature();
if( poAttrFeature == NULL )
{
fprintf( stderr,
"Didn't find any meaningful attribute records in %s.\n",
papszModuleList[iModule] );
continue;
}
/* -------------------------------------------------------------------- */
/* Clone schema off the first record. Eventually we need to */
/* get the information out of the DDR record, but it isn't */
/* clear to me how to accomplish that with the SDTS++ API. */
/* */
/* The following approach may fail (dramatically) if some */
/* records do not include all subfields. Furthermore, no */
/* effort is made to make DBF field names unique. The SDTS */
/* attributes often have names much beyond the 14 character dbf */
/* limit which may result in non-unique attributes. */
/* -------------------------------------------------------------------- */
DDFFieldDefn *poFDefn = poAttrFeature->poATTR->GetFieldDefn();
int iSF;
DDFField *poSR = poAttrFeature->poATTR;
for( iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ )
{
DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF );
int nWidth = poSFDefn->GetWidth();
switch( poSFDefn->GetType() )
{
case DDFString:
if( nWidth == 0 )
{
int nMaxBytes;
const char * pachData = poSR->GetSubfieldData(poSFDefn,
&nMaxBytes);
nWidth = strlen(poSFDefn->ExtractStringData(pachData,
nMaxBytes, NULL ));
}
DBFAddField( hDBF, poSFDefn->GetName(), FTString, nWidth, 0 );
break;
case DDFInt:
if( nWidth == 0 )
nWidth = 9;
DBFAddField( hDBF, poSFDefn->GetName(), FTInteger, nWidth, 0 );
break;
case DDFFloat:
DBFAddField( hDBF, poSFDefn->GetName(), FTDouble, 18, 6 );
break;
default:
fprintf( stderr,
"Dropping attribute `%s' of module `%s'. "
"Type unsupported\n",
poSFDefn->GetName(),
papszModuleList[iModule] );
break;
}
}
if( !poAttrReader->IsIndexed() )
delete poAttrFeature;
} /* next module */
}
OGRSDTSLayer::OGRSDTSLayer( SDTSTransfer * poTransferIn, int iLayerIn,
OGRSDTSDataSource * poDSIn ) :
bPolygonsBuilt(FALSE)
{
poDS = poDSIn;
poTransfer = poTransferIn;
iLayer = iLayerIn;
poReader = poTransfer->GetLayerIndexedReader( iLayer );
/* -------------------------------------------------------------------- */
/* Define the feature. */
/* -------------------------------------------------------------------- */
int iCATDEntry = poTransfer->GetLayerCATDEntry( iLayer );
poFeatureDefn =
new OGRFeatureDefn(poTransfer->GetCATD()->GetEntryModule(iCATDEntry));
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poDS->GetSpatialRef());
OGRFieldDefn oRecId( "RCID", OFTInteger );
poFeatureDefn->AddFieldDefn( &oRecId );
if( poTransfer->GetLayerType(iLayer) == SLTPoint )
{
poFeatureDefn->SetGeomType( wkbPoint );
}
else if( poTransfer->GetLayerType(iLayer) == SLTLine )
{
poFeatureDefn->SetGeomType( wkbLineString );
oRecId.SetName( "SNID" );
poFeatureDefn->AddFieldDefn( &oRecId );
oRecId.SetName( "ENID" );
poFeatureDefn->AddFieldDefn( &oRecId );
}
else if( poTransfer->GetLayerType(iLayer) == SLTPoly )
{
poFeatureDefn->SetGeomType( wkbPolygon );
}
else if( poTransfer->GetLayerType(iLayer) == SLTAttr )
{
poFeatureDefn->SetGeomType( wkbNone );
}
/* -------------------------------------------------------------------- */
/* Add schema from referenced attribute records. */
/* -------------------------------------------------------------------- */
char **papszATIDRefs = NULL;
if( poTransfer->GetLayerType(iLayer) != SLTAttr )
papszATIDRefs = poReader->ScanModuleReferences();
else
papszATIDRefs = CSLAddString( papszATIDRefs,
poTransfer->GetCATD()->GetEntryModule(iCATDEntry) );
for( int iTable = 0;
papszATIDRefs != NULL && papszATIDRefs[iTable] != NULL;
iTable++ )
{
SDTSAttrReader *poAttrReader;
DDFFieldDefn *poFDefn;
/* -------------------------------------------------------------------- */
/* Get the attribute table reader, and the associated user */
/* attribute field. */
/* -------------------------------------------------------------------- */
int nLayerIdx = poTransfer->FindLayer( papszATIDRefs[iTable] );
if( nLayerIdx < 0 )
continue;
poAttrReader = (SDTSAttrReader *)
poTransfer->GetLayerIndexedReader(nLayerIdx);
if( poAttrReader == NULL )
continue;
poFDefn = poAttrReader->GetModule()->FindFieldDefn( "ATTP" );
if( poFDefn == NULL )
poFDefn = poAttrReader->GetModule()->FindFieldDefn( "ATTS" );
if( poFDefn == NULL )
continue;
/* -------------------------------------------------------------------- */
/* Process each user subfield on the attribute table into an */
/* OGR field definition. */
/* -------------------------------------------------------------------- */
for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ )
{
DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF );
int nWidth = poSFDefn->GetWidth();
char *pszFieldName;
if( poFeatureDefn->GetFieldIndex( poSFDefn->GetName() ) != -1 )
pszFieldName = CPLStrdup( CPLSPrintf( "%s_%s",
papszATIDRefs[iTable],
poSFDefn->GetName() ) );
else
pszFieldName = CPLStrdup( poSFDefn->GetName() );
switch( poSFDefn->GetType() )
{
case DDFString:
{
OGRFieldDefn oStrField( pszFieldName, OFTString );
if( nWidth != 0 )
oStrField.SetWidth( nWidth );
poFeatureDefn->AddFieldDefn( &oStrField );
}
break;
case DDFInt:
{
OGRFieldDefn oIntField( pszFieldName, OFTInteger );
if( nWidth != 0 )
oIntField.SetWidth( nWidth );
poFeatureDefn->AddFieldDefn( &oIntField );
}
break;
case DDFFloat:
{
OGRFieldDefn oRealField( pszFieldName, OFTReal );
// We don't have a precision in DDF files, so we never even
// use the width. Otherwise with a precision of zero the
// result would look like an integer.
poFeatureDefn->AddFieldDefn( &oRealField );
}
break;
default:
break;
}
CPLFree( pszFieldName );
} /* next iSF (subfield) */
} /* next iTable */
CSLDestroy( papszATIDRefs );
}
static void
AssignAttrRecordToFeature( OGRFeature * poFeature,
CPL_UNUSED SDTSTransfer * poTransfer,
DDFField * poSR )
{
/* -------------------------------------------------------------------- */
/* Process each subfield in the record. */
/* -------------------------------------------------------------------- */
DDFFieldDefn *poFDefn = poSR->GetFieldDefn();
for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ )
{
DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF );
int iField;
int nMaxBytes;
const char * pachData = poSR->GetSubfieldData(poSFDefn,
&nMaxBytes);
/* -------------------------------------------------------------------- */
/* Indentify this field on the feature. */
/* -------------------------------------------------------------------- */
iField = poFeature->GetFieldIndex( poSFDefn->GetName() );
/* -------------------------------------------------------------------- */
/* Handle each of the types. */
/* -------------------------------------------------------------------- */
switch( poSFDefn->GetType() )
{
case DDFString:
const char *pszValue;
pszValue = poSFDefn->ExtractStringData(pachData, nMaxBytes,
NULL);
if( iField != -1 )
poFeature->SetField( iField, pszValue );
break;
case DDFFloat:
double dfValue;
dfValue = poSFDefn->ExtractFloatData(pachData, nMaxBytes,
NULL);
if( iField != -1 )
poFeature->SetField( iField, dfValue );
break;
case DDFInt:
int nValue;
nValue = poSFDefn->ExtractIntData(pachData, nMaxBytes, NULL);
if( iField != -1 )
poFeature->SetField( iField, nValue );
break;
default:
break;
}
} /* next subfield */
}
